# Everything Claude Code (ECC) User Guide

## 1. Quick Start

Everything Claude Code (ECC) is a comprehensive collection of battle-tested configurations, skills, hooks, rules, commands, and agents for Claude Code and compatible AI-assisted coding tools. Evolved over 10+ months of intensive daily use by an Anthropic hackathon winner, ECC transforms Claude Code from a capable assistant into a fully governed, multi-agent development environment.

**Key features:**

- 130+ domain-specific skills covering languages, frameworks, security, DevOps, and business workflows
- 80+ slash commands for code review, TDD, deployment, and project management
- 19+ specialized agent definitions (planner, security-reviewer, e2e-runner, and more)
- Event-driven hook system with quality gates, formatting, and safety guardrails
- Language-specific rules for TypeScript, Python, Go, Rust, Swift, Kotlin, Java, C++, PHP, C#, Perl, and Dart
- Multi-IDE support (Claude Code, Cursor, Codex, Gemini, OpenCode, AntiGravity, CodeBuddy)
- Curated MCP server catalog with 20+ pre-configured integrations
- ECC 2.0 TUI dashboard for session orchestration and worktree management (Rust)

**Prerequisites:**

- Node.js >= 18
- Claude Code (or a compatible IDE target)
- Git

**Install in one command:**

```bash
npx ecc typescript
```

```text
  ecc-universal installed!
  Run: npx ecc typescript
```

**What to try next:** Run `/tdd` to start a test-driven development workflow, `/code-review` for instant code review, or `/plan` to create an implementation plan.

> [!TIP]
> If you already have an existing Claude Code setup, ECC merges its configuration non-destructively. Your existing rules and hooks are preserved.

---

## 2. Installation

### System Requirements

| Requirement | Minimum | Recommended |
|---|---|---|
| Node.js | 18+ | 20+ |
| OS | Windows 10, macOS 12, Linux (kernel 5.4+) | Latest stable |
| Disk | 50 MB | 100 MB |
| Claude Code | Any version | Latest |

### Install Methods

=== "npm (recommended)"
    ```bash
    npx ecc typescript
    ```

=== "yarn"
    ```bash
    yarn dlx ecc-universal typescript
    ```

=== "Manual (install script)"
    ```bash
    git clone https://github.com/affaan-m/everything-claude-code.git
    cd everything-claude-code
    ./install.sh typescript
    ```

=== "Windows (PowerShell)"
    ```bash
    git clone https://github.com/affaan-m/everything-claude-code.git
    cd everything-claude-code
    .\install.ps1 typescript
    ```

> [!IMPORTANT]
> When installing manually, copy entire rule directories — do not flatten with `/*`. The `common/` and language-specific directories contain files with the same names, and flattening breaks the `../common/` relative references that language-specific files depend on.

### Multiple Languages

Install support for multiple languages at once:

```bash
npx ecc typescript python golang
```

Or install individual language packs:

```bash
npx ecc python
npx ecc golang
npx ecc swift
npx ecc kotlin
npx ecc java
npx ecc cpp
npx ecc php
npx ecc csharp
npx ecc perl
npx ecc dart
npx ecc rust
```

### Install Profiles

ECC supports profile-based installation for targeted setups:

```bash
# Install a named profile from ecc-install.json
npx ecc-install --profile web-fullstack
```

Profiles group components by use case. You can also use component-based selection:

```bash
# Include specific capability components
npx ecc-install --include baseline:rules --include lang:typescript --include capability:security
```

| Component Family | Examples | Purpose |
|---|---|---|
| `baseline` | `baseline:rules`, `baseline:hooks`, `baseline:commands`, `baseline:agents`, `baseline:platform`, `baseline:workflow` | Core infrastructure |
| `lang` | `lang:typescript`, `lang:python`, `lang:go`, `lang:java`, `lang:swift`, `lang:cpp`, `lang:kotlin`, `lang:rust`, `lang:perl`, `lang:dart`, `lang:csharp` | Language-specific guidance |
| `framework` | `framework:react`, `framework:nextjs`, `framework:django`, `framework:springboot` | Framework-specific patterns |
| `capability` | `capability:security`, `capability:database`, `capability:research`, `capability:media`, `capability:orchestration` | Domain capabilities |

### Multi-IDE Targets

ECC supports installation across different AI coding tools:

| Target | Command | Description |
|---|---|---|
| Claude Code | `npx ecc typescript` | Default target |
| Cursor | `npx ecc --target cursor typescript` | Cursor IDE |
| Codex | `npx ecc --target codex typescript` | OpenAI Codex |
| Gemini | `npx ecc --target gemini typescript` | Google Gemini |
| OpenCode | `npx ecc --target opencode typescript` | OpenCode |
| AntiGravity | `npx ecc --target antigravity typescript` | AntiGravity |
| CodeBuddy | `npx ecc --target codebuddy typescript` | CodeBuddy |

### Post-Install Verification

After installation, verify the setup:

```bash
npx ecc --version
```

```text
1.10.0
```

Check installed components:

```bash
node scripts/list-installed.js
```

Run the diagnostic tool:

```bash
node scripts/doctor.js
```

> [!TIP]
> Use `node scripts/doctor.js` after installation to detect misconfigurations, missing hooks, or broken skill references.

### Uninstalling

```bash
node scripts/uninstall.js
```

---

## 3. Configuration

### Hook Profiles

ECC hooks enforce code quality and safety checks automatically. Control their behavior with environment variables:

```bash
# Set hook profile: minimal | standard | strict
export ECC_HOOK_PROFILE=standard

# Disable specific hooks by ID (comma-separated)
export ECC_DISABLED_HOOKS="pre:bash:tmux-reminder,post:edit:typecheck"
```

| Profile | Behavior |
|---|---|
| `minimal` | Only essential lifecycle and security hooks |
| `standard` | Default — balanced quality + safety checks |
| `strict` | Extra reminders and stricter guardrails |

### Package Manager

ECC detects your project's package manager automatically. Override it with:

```bash
export CLAUDE_PACKAGE_MANAGER=yarn
```

Or run the interactive setup:

```bash
node scripts/setup-package-manager.js
```

### MCP Server Configuration

ECC includes a curated catalog of 20+ MCP server configurations in `mcp-configs/mcp-servers.json`. To use them, copy the servers you need to your `~/.claude.json` `mcpServers` section:

```json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_GITHUB_PAT_HERE"
      }
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    }
  }
}
```

> [!WARNING]
> Keep under 10 MCP servers enabled at once to preserve your context window. Disable unused MCPs with `ECC_DISABLED_MCPS=github,context7,...` during install or sync.

For a full configuration reference, see the Admin Guide.

---

## 4. Core Usage

### Skills

Skills are contextual knowledge modules that Claude Code loads automatically based on what you are working on. Each skill lives in `skills/<name>/SKILL.md` and contains domain-specific patterns, best practices, and code examples.

**How skills activate:** When you edit a Python file, `python-patterns` and `python-testing` load. Working on a Django project triggers `django-patterns`, `django-security`, and `django-tdd`. Running a TDD workflow activates `tdd-workflow`.

#### Skill Categories

| Category | Example Skills | When They Activate |
|---|---|---|
| Language Patterns | `python-patterns`, `golang-patterns`, `rust-patterns`, `kotlin-patterns` | Editing files in that language |
| Framework | `django-patterns`, `springboot-patterns`, `laravel-patterns`, `nextjs-turbopack` | Framework-specific projects |
| Testing | `python-testing`, `golang-testing`, `e2e-testing`, `tdd-workflow` | Writing or running tests |
| Security | `security-review`, `security-scan`, `django-security`, `laravel-security` | Security-sensitive code |
| DevOps | `docker-patterns`, `deployment-patterns`, `database-migrations` | Infrastructure work |
| AI/ML | `pytorch-patterns`, `cost-aware-llm-pipeline`, `eval-harness` | AI/ML development |
| Business | `article-writing`, `investor-materials`, `market-research`, `seo` | Content and communications |
| Media | `video-editing`, `manim-video`, `fal-ai-media`, `remotion-video-creation` | Media generation |
| Orchestration | `autonomous-loops`, `continuous-agent-loop`, `enterprise-agent-ops` | Multi-agent workflows |

> [!NOTE]
> The full skill catalog includes 130+ skills. Run `node scripts/catalog.js` to see the current inventory with descriptions.

### Slash Commands

Slash commands are quick-access workflows invoked with `/<command-name>` in Claude Code. ECC provides 80+ commands organized by purpose.

#### Development Commands

| Command | Purpose |
|---|---|
| `/plan` | Create a structured implementation plan |
| `/tdd` | Start a test-driven development workflow |
| `/code-review` | Run code review for quality and security |
| `/build-fix` | Fix build and TypeScript errors |
| `/refactor-clean` | Remove dead code and clean up |
| `/verify` | Run build, test, and lint verification loop |
| `/test-coverage` | Analyze and improve test coverage |
| `/feature-dev` | Full feature development workflow |

#### Language-Specific Commands

| Command | Purpose |
|---|---|
| `/go-build`, `/go-test`, `/go-review` | Go development |
| `/rust-build`, `/rust-test`, `/rust-review` | Rust development |
| `/kotlin-build`, `/kotlin-test`, `/kotlin-review` | Kotlin development |
| `/cpp-build`, `/cpp-test`, `/cpp-review` | C++ development |
| `/python-review` | Python code review |
| `/flutter-build`, `/flutter-test`, `/flutter-review` | Flutter development |

#### Workflow Commands

| Command | Purpose |
|---|---|
| `/e2e` | Generate and run E2E Playwright tests |
| `/eval` | Run evaluation against criteria |
| `/update-docs` | Update documentation and codemaps |
| `/quality-gate` | Run quality gate checks |
| `/prompt-optimize` | Optimize prompts for LLM efficiency |
| `/hookify` | Create hooks through conversation |
| `/orchestrate` | Launch multi-agent orchestration |
| `/learn` | Trigger continuous learning evaluation |

#### Session Management Commands

| Command | Purpose |
|---|---|
| `/sessions` | List active sessions |
| `/save-session` | Save current session state |
| `/resume-session` | Resume a saved session |
| `/claw` | Interactive session launcher |

### Agents

Agents are specialized AI personas with focused expertise. They are defined in `AGENTS.md` and the `agents/` directory.

| Agent | Purpose | When to Use |
|---|---|---|
| `planner` | Implementation planning | Complex features, refactoring |
| `architect` | System design and scalability | Architectural decisions |
| `tdd-guide` | Test-driven development | New features, bug fixes |
| `code-reviewer` | Code quality | After writing code |
| `security-reviewer` | Vulnerability detection | Before commits, sensitive code |
| `build-error-resolver` | Fix build/type errors | When builds fail |
| `e2e-runner` | End-to-end Playwright testing | Critical user flows |
| `refactor-cleaner` | Dead code cleanup | Code maintenance |
| `doc-updater` | Documentation and codemaps | Updating docs |
| `loop-operator` | Autonomous loop execution | Running loops safely |
| `harness-optimizer` | Harness config tuning | Reliability, cost, throughput |

**Language-specific agents** are also available: `go-reviewer`, `python-reviewer`, `typescript-reviewer`, `rust-reviewer`, `java-reviewer`, `kotlin-reviewer`, `cpp-reviewer`, and `database-reviewer`.

> [!TIP]
> Use `/agent-sort` to automatically select the best agent for your current task based on the code context.

### Hooks

Hooks run automatically before or after Claude Code tool executions. They enforce quality, safety, and consistency without manual intervention.

#### PreToolUse Hooks (run before actions)

| Hook | Triggers On | Behavior |
|---|---|---|
| Bash preflight dispatcher | `Bash` | Quality, tmux, push, and GateGuard checks |
| Doc file warning | `Write` | Warns about non-standard `.md`/`.txt` files |
| Suggest compact | `Edit\|Write` | Suggests `/compact` at logical intervals (~50 tool calls) |
| Config protection | `Write\|Edit\|MultiEdit` | Blocks modifications to linter/formatter config files |
| MCP health check | `*` | Checks MCP server health before MCP tool calls |
| GateGuard fact-force | `Edit\|Write\|MultiEdit` | Blocks first edit per file until investigation is done |
| Governance capture | `Bash\|Write\|Edit\|MultiEdit` | Captures secrets and policy violation events (opt-in via `ECC_GOVERNANCE_CAPTURE=1`) |

#### PostToolUse Hooks (run after actions)

| Hook | Triggers On | Behavior |
|---|---|---|
| Bash postflight dispatcher | `Bash` | Logging, PR tracking, build notifications |
| Quality gate | `Edit\|Write\|MultiEdit` | Runs quality checks after edits |
| Design quality check | `Edit\|Write\|MultiEdit` | Warns when UI drifts toward generic templates |
| Edit accumulator | `Edit\|Write\|MultiEdit` | Records paths for batch format+typecheck at Stop |
| Console.log warning | `Edit` | Warns about `console.log` statements |

#### Lifecycle Hooks

| Hook | Event | Behavior |
|---|---|---|
| Session start | `SessionStart` | Loads previous context and detects package manager |
| Pre-compact | `PreCompact` | Saves state before context compaction |

> [!WARNING]
> The GateGuard fact-force hook blocks the first `Edit`/`Write`/`MultiEdit` per file, requiring you to investigate the file's importers, data schemas, and user instructions before making changes. This prevents blind modifications. If this is too strict for your workflow, set `ECC_HOOK_PROFILE=minimal` or disable it with `ECC_DISABLED_HOOKS="pre:edit-write:gateguard-fact-force"`.

### Rules

Rules define broad coding standards and conventions. They are organized in a layered structure:

```text
rules/
├── common/          # Language-independent (always installed)
│   ├── coding-style.md
│   ├── git-workflow.md
│   ├── testing.md
│   ├── performance.md
│   ├── patterns.md
│   ├── hooks.md
│   ├── agents.md
│   └── security.md
├── typescript/      # TypeScript/JavaScript
├── python/          # Python
├── golang/          # Go
├── swift/           # Swift
├── kotlin/          # Kotlin
├── java/            # Java
├── rust/            # Rust
├── cpp/             # C/C++
├── php/             # PHP
├── csharp/          # C#
├── perl/            # Perl
├── dart/            # Dart
└── web/             # Web-specific
```

**Rule priority:** When a language-specific rule conflicts with a common rule, the language-specific rule takes precedence — similar to CSS specificity.

> [!NOTE]
> Rules tell you *what* to do; skills tell you *how* to do it. Language-specific rule files reference relevant skills for detailed implementation guidance.

---

## 5. Common Tasks

### Start Test-Driven Development

**Goal:** Write a new feature using TDD methodology.

1. Run `/tdd` to start the TDD workflow
2. Claude will prompt you for the feature requirements
3. Write failing tests first
4. Implement the minimum code to pass
5. Refactor with confidence

**Verify:** Tests pass and coverage meets the 80% minimum threshold.

**If it fails:** Run `/build-fix` to resolve any build errors, then re-run tests.

### Run a Code Review

**Goal:** Get a comprehensive code review before committing.

1. Run `/code-review` with your changes staged
2. Claude reviews for quality, security, patterns, and test coverage
3. Address any findings
4. Run `/verify` to confirm all checks pass

### Set Up Multi-Agent Orchestration

**Goal:** Run parallel agent sessions across git worktrees.

1. Run `/orchestrate` to launch the orchestration template
2. Define worker tasks and agent types
3. Each agent works in an isolated worktree
4. Use `node scripts/orchestration-status.js` to monitor progress
5. Merge completed worktrees back to the main branch

**Verify:** Run `node scripts/orchestration-status.js` — all workers should show completed status.

### Add a New Skill

**Goal:** Create a custom skill for your domain.

1. Create a directory `skills/your-skill-name/`
2. Add a `SKILL.md` file with YAML frontmatter:

```markdown
---
name: your-skill-name
description: Brief description shown in skill list
---

# Your Skill Title

Brief overview.

## Core Concepts

Key patterns and guidelines.

## Code Examples

\`\`\`language
// Practical examples
\`\`\`

## Best Practices

- Actionable guideline 1
- Actionable guideline 2
```

3. Run `npm run catalog:sync` to update the catalog

### Configure MCP Servers

**Goal:** Set up external tool integrations.

1. Open `mcp-configs/mcp-servers.json` for the full catalog
2. Copy desired server configurations to `~/.claude.json`
3. Replace `YOUR_*_HERE` placeholders with actual API keys
4. Restart Claude Code to activate the new servers

**Common MCP servers:**

| Server | Purpose | API Key Required |
|---|---|---|
| `github` | PR, issue, and repo operations | Yes (GitHub PAT) |
| `context7` | Live documentation lookup | No |
| `exa-web-search` | Web research | Yes (Exa API key) |
| `playwright` | Browser automation and E2E testing | No |
| `memory` | Persistent memory across sessions | No |
| `sequential-thinking` | Chain-of-thought reasoning | No |

### Write Custom Hooks

**Goal:** Add project-specific automation to Claude Code.

Hooks are shell commands that receive JSON via stdin and output JSON to stdout.

```javascript
// my-hook.js
let data = '';
process.stdin.on('data', chunk => data += chunk);
process.stdin.on('end', () => {
  const input = JSON.parse(data);
  const toolName = input.tool_name;
  const toolInput = input.tool_input;

  // Warn (non-blocking): write to stderr
  console.error('[Hook] Warning message shown to Claude');

  // Block (PreToolUse only): exit with code 2
  // process.exit(2);

  // Always output the original data to stdout
  console.log(data);
});
```

**Exit codes:** `0` = success (continue), `2` = block tool call (PreToolUse only), other non-zero = error (logged, not blocked).

### Use the Python GUI Dashboard

**Goal:** Browse ECC components visually.

```bash
python3 ecc_dashboard.py
```

The TkInter-based dashboard provides tabs for browsing agents, skills, commands, and rules with search and filtering capabilities.

> [!TIP]
> The dashboard supports light and dark themes. Switch themes in the Settings tab.

### Use the ECC 2.0 TUI

**Goal:** Use the Rust-based terminal dashboard for session management.

```bash
# Build the TUI (requires Rust toolchain)
cd ecc2
cargo build --release

# Launch the dashboard
./target/release/ecc-tui dashboard
```

The TUI provides real-time session monitoring, worktree management, merge queues, and coordination status. See the Admin Guide for the full `ecc` CLI reference.

---

## 6. Troubleshooting

### Diagnostic Decision Tree

```text
ECC not working?
├── Installation issues → Check Node.js version (>=18), run `node scripts/doctor.js`
├── Hooks not firing → Check `ECC_HOOK_PROFILE`, verify hooks.json is loaded
├── Skills not loading → Verify skill directory structure, check SKILL.md frontmatter
├── MCP servers offline → Check `ECC_MCP_HEALTH_STATE_PATH`, verify API keys
├── Windows-specific → Check path separators, ENOENT errors for spawn
└── Performance → Reduce enabled MCP servers (<10), check context window usage
```

### Error: `Failed to load hooks from hooks.json`

**Cause:** Claude Code 2.1.x changed the hook schema to expect string commands, but ECC previously used argv arrays.

**Solution:**
1. Update ECC to the latest version: `npx ecc typescript`
2. If the issue persists, check that your `hooks.json` uses string `"command"` fields, not arrays

**Prevention:** Keep ECC updated. The hooks system validates against `schemas/hooks.schema.json` at CI time.

### Error: `ENOENT` when spawning `claude` or `npx` on Windows

**Cause:** Windows cannot find the `claude` or `npx` binary in the system PATH, especially when spawned from hooks (GitHub issue #1469).

**Solution:**
1. Ensure Claude Code and Node.js are in your system PATH
2. For `claw.js` specifically, ensure the `claude` binary is accessible from the hook execution context
3. Set the `BASH` environment variable if hooks need a specific shell

**Prevention:** Run `node scripts/doctor.js` to verify all required binaries are discoverable.

### Error: GateGuard blocks all tool calls in auto mode

**Cause:** The `gateguard-fact-force` hook can enter a state where it blocks all operations, including the commands needed to disable it (GitHub issue #1427).

**Solution:**
1. Set `ECC_DISABLED_HOOKS="pre:edit-write:gateguard-fact-force"` before starting Claude Code
2. On Windows, if `fs.renameSync` fails with `EEXIST`, update ECC to get the Windows-specific fix (GitHub issue #1435)
3. Clear the GateGuard state: delete files in the directory specified by `GATEGUARD_STATE_DIR`

**Prevention:** Use `ECC_HOOK_PROFILE=minimal` for autonomous/batch operations.

> [!CAUTION]
> The GateGuard race condition (GitHub issue #1441) in the session state read-modify-write path can cause inconsistent state under concurrent access. Avoid running multiple Claude Code sessions with GateGuard enabled against the same state directory.

### Error: `PreToolUse+PostToolUse fork storm causes EAGAIN posix_spawn` (macOS)

**Cause:** Dense Bash tool calls trigger too many hook processes simultaneously, exhausting system resources (GitHub issue #1423).

**Solution:**
1. Reduce the number of synchronous hooks — mark non-critical hooks as `"async": true`
2. Increase the process limit on macOS: `ulimit -u 2048`
3. Update ECC for consolidated dispatcher hooks that reduce fork count

**Prevention:** Use the consolidated `pre-bash-dispatcher.js` and `post-bash-dispatcher.js` (default in recent versions) instead of individual hook scripts.

### Error: ECC breaks Claude Desktop `/` slash menu

**Cause:** `getSupportedCommands` validation failure when ECC is installed as a plugin (GitHub issue #1476).

**Solution:** This is a known open issue. As a workaround, install ECC directly via `install.sh` rather than as a Claude Desktop plugin.

### Error: MCP health-check blocks all MCP calls on Windows

**Cause:** The MCP health-check hook spawns `npx` which fails with `ENOENT` on Windows (GitHub issue #1455).

**Solution:**
1. Disable the MCP health check: `ECC_DISABLED_HOOKS="pre:mcp-health-check"`
2. Or set `ECC_MCP_HEALTH_FAIL_OPEN=1` to allow MCP calls even when health checks fail

### Dashboard fails to launch on Windows

**Cause:** Terminal launch paths contain spaces or Windows-specific path issues (GitHub issue #1472).

**Solution:** Run the dashboard from a path without spaces, or update to the latest version which sanitizes `cmd.exe` command strings.

> [!WARNING]
> Several Windows-specific issues exist in hooks that use `spawn`. If you encounter `ENOENT` errors on Windows, check whether the hook is trying to spawn a command that requires the full path on Windows. Setting `ECC_HOOK_PROFILE=minimal` is a reliable workaround.

---

## 7. FAQ

**Q: What is the difference between rules and skills?**

Rules define broad standards and conventions (e.g., "80% test coverage", "no hardcoded secrets"). Skills provide detailed, actionable reference material for specific tasks (e.g., `python-patterns` shows you *how* to implement Python design patterns). Rules say *what*; skills say *how*.

**Q: Do I need to install all skills?**

No. Install only the components relevant to your technology stack. Use the component-based installer (`--include lang:typescript --include capability:security`) to pick exactly what you need.

**Q: Can I use ECC with Cursor, Codex, or other AI tools?**

Yes. ECC supports multiple IDE targets. Use `npx ecc --target cursor typescript` for Cursor, `--target codex` for Codex, and so on. Not all features are available on all targets — hooks and MCP configurations are Claude Code-specific.

**Q: How do I disable a hook that is too aggressive?**

Set `ECC_DISABLED_HOOKS` to a comma-separated list of hook IDs. For example: `ECC_DISABLED_HOOKS="pre:edit-write:gateguard-fact-force,pre:bash:tmux-reminder"`. You can find hook IDs in `hooks/hooks.json` under the `"id"` field.

**Q: How do I add support for a new programming language?**

Create a `rules/<language>/` directory with files that extend the common rules (`coding-style.md`, `testing.md`, `patterns.md`, `hooks.md`, `security.md`). Each file should start with `> This file extends [common/xxx.md](../common/xxx.md) with <language>-specific content.` Then create relevant skills under `skills/`.

**Q: What is ECC 2.0 (ecc2)?**

ECC 2.0 is a Rust-based TUI (Terminal User Interface) that acts as an agentic IDE control plane. It manages multi-agent sessions, git worktrees, merge queues, task delegation, and coordination — all from a terminal dashboard. It is a separate binary (`ecc-tui`) built with Rust and requires `cargo build` to compile. See the Admin Guide for the complete CLI reference.

**Q: How do I update ECC?**

Run `npx ecc typescript` again (or your chosen languages). The installer merges updates non-destructively. For git-cloned installs, `git pull && ./install.sh typescript`.

**Q: What happens if I run multiple Claude Code sessions with the same hooks?**

Most hooks are stateless and safe for concurrent use. However, GateGuard uses file-based state that has a known race condition under concurrent access (GitHub issue #1441). Use `ECC_HOOK_PROFILE=minimal` for parallel autonomous sessions.

**Q: How do I contribute a new skill or command?**

Create a skill directory with `SKILL.md`, or add a command markdown file under `commands/`. Run `npm run catalog:sync` to update the catalog. Run `npm test` to validate all manifests, schemas, and file references. Submit a PR to the repository.

**Q: What is the plugin-hook-bootstrap.js that wraps all hooks?**

Every hook command is wrapped by `plugin-hook-bootstrap.js`, which resolves the ECC installation root (whether installed globally, as a plugin, or from source). This bootstrap layer ensures hooks can locate their helper scripts regardless of installation method. You do not need to interact with it directly.

---

_Generated May 2026 from affaan-m/everything-claude-code at 1a50145. AI-generated documentation. The library is checked by sampling (three repositories so far); this guide was not individually reviewed. Verify against the project before relying on it. Unofficial; not affiliated with or reviewed by the project._