ECC Documentation

Technical Documentation: affaan-m/ECC

ℹ️ Provenance: Multi-Tier Ingestion · CodeWiki Reference

Overview (README.md) Copy Section

[!WARNING]
Official sources only. Install ECC only from verified channels: the GitHub repository github.com/affaan-m/ECC, the npm packages ecc-universal and ecc-agentshield, the GitHub App, the plugin slug ecc@ecc, and the project website ecc.tools. Third-party re-uploads and unofficial mirrors are not maintained or reviewed by the project and may contain malware.

Install with Claude Code Copy Chapter

Use the guided setup or native plugin commands. Both install the same ecc@ecc plugin. Choose one and do not stack a full manual Claude install on top.

_{OSS stays free. This repo is MIT-licensed forever. ECC Pro is the hosted GitHub App for private repos. Sponsors and Pro subscribers fund the work. That's why a single maintainer ships weekly across 7 harnesses.}

ECC

Your agent can write code, but ECC gives it a coordinated engineering system and toolbox: it plans before it builds, verifies changes with tests, reviews its own work from a fresh context, remembers what matters, and turns repeated wins into reusable skills and workflows.

plan -> test -> implement -> review -> verify -> remember -> improve

Instead of rebuilding that process in every prompt, you install it once and make it part of how your agent works.

Optimize the context window. Persist everything else.

ECC is MIT-licensed open source. It works best with Claude Code today, has native Codex and Qoder plugin paths, and provides capability-limited adapters for Cursor, OpenCode, Gemini, Zed, GitHub Copilot, Antigravity, Qwen, and other harnesses. See the support status matrix before assuming feature parity.

Access to 71 agents, 311 skills, and 97 legacy command shims, plus hooks, rules, memory, continuous learning, and AgentShield security scanning. The agents are specialized for planning, review, build repair, security, architecture, and domain work.

Install ECC Copy Chapter

[!IMPORTANT]
ECC 2.2 includes guided package setup for Claude Code, Codex, and Kimi Code.
The universal package requires Node.js 18 or newer. Claude plugin setup also
requires Git and Claude Code 2.1 or newer on PATH.

Recommended: universal guided setup Copy Section

For Claude Code plugin setup, updates, scope changes, and hook-profile changes:

npx [email protected] setup

Windows first-time walkthrough

If you are new to command-line tools, use this copy-and-paste path:

1. Install Node.js 18 or newer, Git, and Claude Code.

2. Open PowerShell from the Windows Start menu.

3. Confirm that each prerequisite is available:

   powershell Copy

   node --version
   git --version
   claude --version

4. Run the guided installer:

   powershell Copy

   npx [email protected] setup

5. For a typical personal setup, choose Global user, choose Standard hooks, and confirm.

6. Start a new Claude Code session and run /plugin list to verify that ecc@ecc is enabled.

This path does not require cloning the repository. If any prerequisite command is not found, install or repair that prerequisite before rerunning ECC setup.

If npm reports a version or cache error, confirm the registry version before retrying:

npm view ecc-universal version

ECC 2.2 supports the same guided setup through modern package runners:

The examples select the published ECC 2.2.3 release, matching this repository's release version. A version pin is not a security audit or an integrity check. Review the release source and registry integrity before running package code; use a reviewed checkout for unreleased changes.

Yarn Classic 1 does not provide yarn dlx; use npx, install the package globally, or upgrade Yarn for a temporary one-shot run.

The wizard inventories the official marketplace and every native Claude install scope before making changes, then installs, updates, or safely moves ecc@ecc to the scope you choose. Rerun the same command whenever you want to update ECC, change scope, or change its hook profile. This setup wizard currently configures the Claude Code plugin; use the multi-harness wizard below for Codex or Kimi Code.

To configure more than one coding agent in one reviewed flow, use the multi-harness wizard:

npx [email protected] install --guided

It lets you select any combination of Claude Code, Codex, and Kimi Code, shows each install channel and destination, preflights every selection before the first write, and asks for one final confirmation.

For automation, make every provider-specific choice explicit:

npx [email protected] install --guided \
  --harness claude --harness codex --harness kimi \
  --claude-scope local --claude-hooks standard \
  --profile core --yes

Verify the native guided Codex path and managed Kimi path without writing first:

npx [email protected] install --guided --harness codex --dry-run
npx [email protected] install --profile core --target kimi --dry-run

Additional package-name commands are also available through the 2.2 alias:

npx [email protected] consult "security reviews" --target claude
npx [email protected] install --profile minimal --target claude --with capability:machine-learning
npx [email protected] doctor --target kimi

Do not use npx ecc-install --profile minimal --target claude: ecc-install is a binary name inside ecc-universal, not a separately published npm package.

ECC also ships advanced managed adapters for cursor, antigravity, gemini, opencode, codebuddy, joycode, qwen, zed, hermes, and openclaw. Those targets still use their documented ecc install --target ... paths until each adapter has passed the guided collision, update, repair, and uninstall lifecycle matrix. Neither wizard silently installs into every detected harness.

Pick one path only (per harness) Copy Section

You can use ECC with Claude Code, Codex, and other harnesses at the same time. Choose one install method for each harness:

• Recommended default: run the guided Claude plugin setup above
• Also supported for Claude Code: use the native plugin commands
• Available in release 2.2: guided package setup for Claude Code, Codex, and Kimi Code
• Works: Claude Code plugin + Codex native plugin
• Works: Claude Code plugin + the legacy Codex sync flow
• Avoid: Claude Code plugin + full Claude manual install
• Avoid: Codex sync + Codex marketplace plugin

Do not stack install methods. Installing ECC twice into the same harness can duplicate skills, commands, hooks, or configuration; installing it once into multiple harnesses does not.

If you already layered multiple installs and things look duplicated, skip straight to Reset / Uninstall ECC.

Install trouble? Open the short install or runtime problem form, or run ecc feedback. ECC never uploads diagnostics automatically.

Claude Code details Copy Section

Alternatively, run Claude Code's native plugin commands inside Claude Code:

/plugin marketplace add https://github.com/affaan-m/ECC
/plugin install ecc@ecc

The native path installs ECC's skills, agents, commands, and plugin-managed hooks. If you choose it, stop there. Do not also run a full manual install into Claude Code.

Claude Code owns these built-in commands, including their errors when a marketplace, plugin, or conflicting scope already exists. ECC cannot intercept that parser. If either native command reports an existing install or scope conflict, use the 2.2 guided setup or resolve the conflicting Claude plugin scope before retrying; do not layer a manual install on top.

After ECC is installed, /ecc:configure-ecc is the namespaced in-Claude reconfiguration skill. It delegates to the same safe setup flow, but it is available only after the plugin is installed and cannot replace Claude Code's built-in /plugin command during a first install.

Claude Code plugins cannot distribute rules, so add only the rule packs you actually want:

git clone https://github.com/affaan-m/ECC.git
cd ECC
mkdir -p ~/.claude/rules/ecc
cp -R rules/common ~/.claude/rules/ecc/
cp -R rules/typescript ~/.claude/rules/ecc/  # replace with your stack

Start with rules/common plus one language or framework pack you actually use. If you install the plugin, do not run ./install.sh --profile full afterward.

Prefer settings.json? Add the marketplace declaratively

Add directly to your ~/.claude/settings.json:

{
  "extraKnownMarketplaces": {
    "ecc": {
      "source": {
        "source": "github",
        "repo": "affaan-m/ECC"
      }
    }
  },
  "enabledPlugins": {
    "ecc@ecc": true
  }
}

This gives you the same result as the two /plugin commands above.

Naming + migration note (ecc@ecc, affaan-m/ECC, ecc-universal)

ECC has three public identifiers, and they are not interchangeable:

• GitHub source repo: affaan-m/ECC
• Claude marketplace/plugin identifier: ecc@ecc
• npm package: ecc-universal

This is intentional. Anthropic marketplace/plugin installs are keyed by a canonical plugin identifier, so ECC uses ecc@ecc to keep tool names and slash-command namespaces short enough for strict Desktop/API validators. Older posts may still show the former long marketplace identifier; treat that as a legacy alias only. Separately, the npm package stayed on ecc-universal, so npm installs and marketplace installs intentionally use different names.

npm releases are cut per version tag, not per commit, so ecc-universal tracks releases (2.1, 2.2, ...) rather than every push to main. Install from git if you want the bleeding edge.

If your local Claude setup was wiped or reset, that does not mean you need to repurchase anything. Start with node scripts/ecc.js list-installed, then run node scripts/ecc.js doctor and node scripts/ecc.js repair before reinstalling. That usually restores ECC-managed files without rebuilding your setup.

Codex App and CLI Copy Section

Current Codex releases can install ECC as a native repo-marketplace plugin. The marketplace entry uses the repository root so Codex's cache receives the manifest together with all referenced skills, MCP configuration, hook runtime, scripts, and assets:

codex plugin marketplace add affaan-m/ECC
codex plugin add ecc@ecc
codex plugin list --json
node scripts/codex/check-plugin-cache.js

Both add commands are idempotent. To refresh later, run codex plugin marketplace upgrade ecc followed by codex plugin add ecc@ecc. Codex stores one enabled plugin state in the active CODEX_HOME; it does not offer Claude's user, project, and local scopes. Its native hooks require an explicit trust decision and do not use Claude's four ECC hook profiles. Inside Codex, invoke $configure-ecc for the guided provider-aware flow.

The older scripts/sync-ecc-to-codex.sh path is a deprecated compatibility option for users who intentionally need copied and merged configuration in ~/.codex; it is not required for the native plugin. New sync runs write an ownership manifest so cleanup can preserve modified user files. Run Codex once first so ~/.codex/config.toml exists, then:

git clone https://github.com/affaan-m/ECC.git
cd ECC
npm install
bash scripts/sync-ecc-to-codex.sh

To inspect or remove that legacy layer without touching Codex conversations or native plugin caches:

node scripts/ecc.js uninstall --legacy-codex-sync --dry-run
node scripts/ecc.js uninstall --legacy-codex-sync

Pre-manifest installations are handled conservatively: ECC removes its marked AGENTS.md block but preserves copied files it cannot prove it owns and reports them for review.

You can also open the ECC repository directly in Codex for a project-local setup. Codex reads the root AGENTS.md and the trusted project configuration in .codex/ without a global sync. Do not add the native marketplace plugin on top of the sync flow.

For repo navigation, surface ownership, and PR diff packet guidance, read the Codex ECC Navigation Map. See the .codex plugin notes for native lifecycle details.

Qoder CLI and IDE Copy Section

ECC ships a native Qoder plugin that reuses the canonical skills, agents,
95 legacy command shims, and the pinned chrome-devtools MCP definition. From a
reviewed checkout, validate and install it with Qoder CLI:

qoder plugins validate . --strict
qoder plugins install .
qoder plugins list

For Qoder IDE, upload a ZIP of the repository root. The ZIP root must contain
.qoder-plugin/ together with skills/, agents/, commands/, hooks/,
scripts/, and .mcp.json; uploading only the manifest directory or one
SKILL.md omits required resources.

The universal Node.js 18+ requirement applies to Qoder's non-interactive hook
environment. The MCP server also requires npx and network access on first use.
Qoder receives one reviewed, cross-platform SessionStart bootstrap using
QODER_PLUGIN_ROOT and exec-form arguments. ECC does not copy the full Claude
hook profile into Qoder: blocking tool hooks, async stop jobs, and
Claude-specific matchers remain outside this initial native integration. See
the .qoder-plugin notes for the exact boundary.

Other agents and editors Copy Section

Cursor, OpenCode, Gemini, Zed, Antigravity, Qwen, Hermes, OpenClaw, Kimi, CodeBuddy, JoyCode, Copilot

Clone ECC once, then choose the target that matches your harness:

git clone https://github.com/affaan-m/ECC.git
cd ECC

GitHub Copilot support is already included in this repository. .github/copilot-instructions.md provides the instruction layer, .github/prompts/ contains the reusable /plan, /tdd, /security-review, /build-fix, and /refactor prompts, and .vscode/settings.json enables chat.promptFiles. GitHub Copilot CLI additionally discovers the .agents/skills/ subset from a plain clone with no setup; see Platform Support for the full catalog and agents.

For a harness without a native ECC target, use the manual adaptation guide. It explains how to carry a small set of ECC skills and workflow instructions into chat-style tools without pretending hooks or native skill discovery are available.

Cursor installs agent definitions under .cursor/agents/ecc-*.md. Cursor-native loading behavior can vary by Cursor build. ECC does not install root AGENTS.md into .cursor/. The adapter keeps Cursor's context scoped to its native rules and agent surfaces.

Deep per-harness notes (feature parity, hook adapters, limitations) live in Platform Support below.

Advanced Install Options Copy Chapter

Low-context install with no hook runtime

Low-context / no-hooks path Copy Section

Use this when you want ECC's rules, agents, commands, platform config, and core workflows without runtime hooks:

npx [email protected] install --profile minimal --target claude

From a source checkout, the equivalent command is:

./install.sh --profile minimal --target claude

Windows:

.\install.ps1 --profile minimal --target claude

This profile intentionally excludes hooks-runtime.

Claude manual installs place each skill directly under ~/.claude/skills/<skill-name>/ (or .claude/skills/<skill-name>/ for claude-project) so Claude Code can discover it. When upgrading an older ECC manual install, the installer migrates only nested skills/ecc/ files recorded in ECC install-state. If a flat skill directory is user-owned, ECC preserves it, prints a conflict warning, and keeps any older managed copy tracked for a safe uninstall instead of overwriting user files.

For the normal core profile with hooks disabled:

./install.sh --profile core --without baseline:hooks --target claude
./install.sh --profile core --no-hooks --target claude

Add the hook runtime later only if you want it:

./install.sh --target claude --modules hooks-runtime --enable-hooks

Any install whose profile or modules would materialize the hook runtime requires
an explicit decision. Without --enable-hooks or --no-hooks, the installer
prints what the hooks can do and stops before writing anything. The guided
installer (ecc install --guided) asks for this choice interactively.

Choose only the components you need

Find the right components first Copy Section

Ask the packaged advisor which components match your work:

node scripts/ecc.js consult "security reviews" --target claude

It returns matching components, related profiles, and preview/install commands. Use the preview command before installing if you want to inspect the exact file plan.

You can also install explicit skills or capabilities:

./install.sh --target claude --skills tdd-workflow,security-review
node scripts/ecc.js install --profile minimal --target claude --with capability:machine-learning

Manual component-by-component copying also works. Each component is fully independent:

# Just agents
mkdir -p ~/.claude/agents
cp agents/*.md ~/.claude/agents/

# Rules directories (common + language-specific)
mkdir -p ~/.claude/rules/ecc
cp -r rules/common ~/.claude/rules/ecc/
cp -r rules/typescript ~/.claude/rules/ecc/   # pick your stack

# Core/general skills only (Claude Code loads skills from direct children
# of ~/.claude/skills; do not nest manual installs under ~/.claude/skills/ecc/)
mkdir -p ~/.claude/skills
cp -r .agents/skills/* ~/.claude/skills/
cp -r skills/search-first ~/.claude/skills/

# Optional: maintained slash-command compatibility during migration
mkdir -p ~/.claude/commands
cp commands/*.md ~/.claude/commands/

Retired shims live in legacy-command-shims/. Copy individual files from there only if you still need old names such as /tdd.

Project-local rules instead of global rules

Use project-local rules when ECC's standards should apply to one repository rather than every Claude Code session:

cd your-project
mkdir -p .claude/rules/ecc
cp -R /path/to/ECC/rules/common .claude/rules/ecc/
cp -R /path/to/ECC/rules/typescript .claude/rules/ecc/

Rules are always-loaded context, so begin with common and one pack for the stack you actually use. When copying rules manually, copy the whole language directory (for example rules/common or rules/golang), not the files inside it, so relative references keep working and filenames do not collide.

Fully manual Claude install

Use this only when you are intentionally skipping the plugin path:

git clone https://github.com/affaan-m/ECC.git
cd ECC
./install.sh --profile full --enable-hooks

Windows:

git clone https://github.com/affaan-m/ECC.git
cd ECC
.\install.ps1 --profile full --enable-hooks

These examples enable the automatic hook runtime. To install without hooks, replace --enable-hooks with --no-hooks.

If you choose this path, stop there. Do not also run /plugin install.

For hand-picked manual installs, Claude discovers skills as direct children of ~/.claude/skills/; do not nest them under ~/.claude/skills/ecc/.

Install hooks

Do not copy the raw repo hooks/hooks.json into ~/.claude/settings.json or ~/.claude/hooks/hooks.json. That file is plugin/repo-oriented; use the installer so hook command paths are rewritten correctly:

bash ./install.sh --target claude --modules hooks-runtime --enable-hooks

That installs the hook scripts under ~/.claude/ and registers the resolved
hook entries in ~/.claude/settings.json. Existing user settings and hooks are
preserved; ECC-owned entries are tracked by stable ID for idempotent updates
and safe uninstall.

If you installed ECC via /plugin install, do not copy those hooks into settings.json. Claude Code v2.1+ already auto-loads plugin hooks/hooks.json, and duplicating them in settings.json causes duplicate execution and cross-platform hook conflicts.

On Windows, Claude's config root is %USERPROFILE%\.claude; install the hook runtime with:

pwsh -File .\install.ps1 --target claude --modules hooks-runtime --enable-hooks

Configure MCPs

Claude plugin installs intentionally do not auto-enable ECC's bundled MCP server definitions. This avoids overlong plugin MCP tool names on strict third-party gateways while keeping manual MCP setup available.

Use Claude Code's /mcp command or CLI-managed MCP setup for live Claude Code server changes; Claude Code persists those choices in ~/.claude.json. For repo-local MCP access, copy desired MCP server definitions from mcp-configs/mcp-servers.json into a project-scoped .mcp.json.

ECC ships exactly one default connector (chrome-devtools); everything else is a skill wrapping a CLI/REST API or an opt-in catalog entry. The rule and the June 2026 audit that retired the previous six defaults live in docs/MCP-CONNECTOR-POLICY.md.

If you already run your own copies of ECC-bundled MCPs, set:

export ECC_DISABLED_MCPS="chrome-devtools"

ECC-managed install and Codex sync flows will skip or remove those bundled servers instead of re-adding duplicates. ECC_DISABLED_MCPS is an ECC install/sync filter, not a live Claude Code toggle.

Important: Replace YOUR_*_HERE placeholders with your actual API keys.

Multi-model commands require additional setup

multi-* commands are not covered by the base plugin/rules install.

To use /multi-plan, /multi-execute, /multi-backend, /multi-frontend, and /multi-workflow, you must also install the ccg-workflow runtime. Choose and review an exact release using the upstream CCG installation guide, then initialize that installed runtime. ECC does not bundle CCG or attest to a compatible, audited CCG release; this guide does not bootstrap an unspecified registry version.

That runtime provides the external dependencies these commands expect, including:

• ~/.claude/bin/codeagent-wrapper
• ~/.claude/.ccg/prompts/*

Without ccg-workflow, these multi-* commands will not run correctly.

Astra review requires the Codex CLI

/astra-review sends Claude-written code to GPT-6-Astra for an independent cross-provider review. It runs the locally installed Codex CLI with your ChatGPT login (codex login); no OpenAI API key is needed, and API keys in your environment are not forwarded. Invoking the command is your consent to send that diff to OpenAI. Setup, scopes, push gating, and troubleshooting are in the Astra Review Guide.

Reset, repair, or uninstall

Reset / Uninstall ECC Copy Section

If you installed from the universal package, run these commands from the same
project directory used for installation:

npx [email protected] list-installed
npx [email protected] doctor
npx [email protected] repair
npx [email protected] uninstall --dry-run
npx [email protected] uninstall

From a source checkout, inspect the managed state before reinstalling:

node scripts/ecc.js list-installed
node scripts/ecc.js doctor
node scripts/ecc.js repair
node scripts/ecc.js uninstall --dry-run

For a direct source-checkout uninstall:

node scripts/uninstall.js --dry-run
node scripts/uninstall.js

If you are leaving, the uninstall command prints an optional 20-second feedback form. It is a public GitHub issue, never blocks uninstall, and ECC does not upload diagnostics. You can also run ecc feedback at any time to see the problem, feedback, and feature routes.

Plugin users should remove the plugin from Claude Code, then delete only the rule folders they manually copied and no longer want. ECC only removes files recorded in its install-state. It does not claim unrelated files in your harness directories.

If you stacked methods, clean up in this order:

1. Remove the Claude Code plugin install.
2. Run the ECC uninstall command from the project directory that contains the managed install-state.
3. Delete any extra rule folders you copied manually and no longer want.
4. Reinstall once, using a single path.

Start Using ECC Copy Chapter

Start with the workflow you need, not the full catalog.

Plugin commands and manual commands

Claude Code plugin commands use the namespaced form:

/ecc:plan "Add authentication"

Manual installs may expose the shorter compatibility form:

/plan "Add authentication"

Skills are the primary workflow surface. Commands remain convenient entry points and compatibility shims. Check what is installed with:

/plugin list ecc@ecc

Which agent should I use?

Skills are the canonical workflow surface; maintained slash entries stay available for command-first workflows.

Common workflows

Slash forms below are shown where they remain part of the maintained command surface. Retired short-name shims such as /tdd and /eval live in legacy-command-shims/ for explicit opt-in only.

Starting a new feature:

/ecc:plan "Add user authentication with OAuth"
                                              -> planner creates implementation blueprint
tdd-workflow skill                            -> tdd-guide enforces write-tests-first
/code-review                                  -> code-reviewer checks your work

Fixing a bug:

tdd-workflow skill                            -> tdd-guide: write a failing test that reproduces it
                                              -> implement the fix, verify test passes
/code-review                                  -> code-reviewer: catch regressions

Preparing for production:

/security-scan                                -> security-reviewer: OWASP Top 10 audit
e2e-testing skill                             -> e2e-runner: critical user flow tests
/test-coverage                                -> verify 80%+ coverage

Self-Hosted Models and Custom Endpoints Copy Chapter

ECC works through each harness's normal configuration, so you can use an official provider, a compatible custom API endpoint or model gateway, or a self-hosted model without changing ECC's workflows.

For Claude Code, ECC does not hardcode Anthropic-hosted transport settings. Minimal gateway example:

export ANTHROPIC_BASE_URL=https://your-gateway.example.com
export ANTHROPIC_AUTH_TOKEN=your-token
claude

If your gateway remaps model names, configure that in Claude Code rather than in ECC. ECC's hooks, skills, commands, and rules are model-provider agnostic once the claude CLI is already working. See Anthropic's LLM gateway documentation and model configuration documentation.

Run or self-host any open-source model behind that gateway using separate compute and serving setup. If you need GPU capacity, Itô is ECC's preferred compute sponsor; any GPU provider works. The sponsorship link is passive: it does not invoke an RFQ, reserve capacity, provision compute, or configure serving. Separately, ecc ito find invokes the explicitly configured canonical Itô CLI and submits a live authenticated RFQ; it does not reserve capacity. Managed inference through Itô is not live yet.

Self-host Kimi with ECC + Itô compute Copy Section

The Kimi Code harness and the model-serving layer are separate. ECC configures the agent harness; you bring an API endpoint (get a Kimi API key) or self-host an open-weight Kimi model on your own GPU capacity. This adapter is verified against Kimi Code 0.31.x (@moonshot-ai/kimi-code):

| 1. Get GPU capacity

Use Itô or any GPU provider. | 2. Serve Kimi

Expose the chosen checkpoint through a compatible endpoint. | 3. Run Kimi Code with ECC

Install project instructions and skills, then start Kimi Code. |
| --- | --- | --- |

Configure the endpoint with Kimi Code's official provider guide, then install ECC:

bash ./install.sh --target kimi --profile minimal
node scripts/ecc.js doctor --target kimi
kimi

Kimi Code discovers the installed .kimi-code/AGENTS.md instructions and .kimi-code/skills/ workflows natively; project-level .agents/skills/ is also an official discovery location. ECC safely merges project MCP entries into .kimi-code/mcp.json and does not change the user-level ~/.kimi-code/config.toml. Kimi Code supports native hooks, but ECC's current managed-project adapter does not configure them, so this installer does not offer Kimi hook profiles. The installer dry-run and regression suite verify that every managed Kimi write stays inside the project-local .kimi-code/ root.

Itô compute CLI bridge Copy Section

ecc ito delegates to the separately installed canonical Itô client; ECC does not maintain a second API client. ecc ito login [--no-browser] performs device authorization, opens the Itô verification page by default, and persists a device token in macOS Keychain; --no-browser suppresses the page handoff. ECC itself does no browser automation. ecc ito auth is validation-only and rejects --no-browser. The available operations are ecc ito login, ecc ito auth, ecc ito find, ecc ito status, and the separately gated ecc ito evals. The matching MCP tools remain ito_auth, ito_find, and ito_status; ito_auth validates existing credentials and node qualification is CLI-only.

The ito-compute-cli package is currently unpublished. Build it locally from the Itô runtime repo (private while the desk hardens; design partners get access) under cli/ito-compute-cli, run npm ci and npm run check, then set ECC_ITO_CLI_EXECUTABLE to that build's absolute dist/bin/ito.js path. Login never inherits ITO_API_KEY; auth, find, and status forward ITO_API_KEY directly when configured, and ITO_AUTH_MODE=legacy is not required. ecc ito logout revokes the current device credential and retains its local copy if remote revocation cannot be confirmed. Device tokens use macOS Keychain by default; explicit file fallback must retain owner-only directory/file permissions. ECC does not discover this credential-bearing client through PATH. See the ito-compute skill for the full RFQ authority and MCP setup contract.

find submits a live authenticated RFQ. It does not reserve capacity. evals requires both ITO_ENABLE_SIXTYTWO_LIVE=1 and --live-sixtytwo, a separately installed sixtytwo-cli==0.3.33, an explicit node list, and an existing absolute configuration directory. It cannot rent, launch, recover, repair, or purchase. ECC exposes no quote lock, purchase, workload, or inference path, and it never replaces a missing client or failed live call with a local result.

What's New Copy Chapter

Current release: 2.2.3 (2026-10-01). Highlights of the 2.2 line:

• Guided, manifest-driven setup across Claude Code, Codex, and Kimi Code, with install-state ownership, doctor, repair, and uninstall.
• Native Antigravity install, a thin Pi adapter, and the packed-artifact release gate tested on Linux, macOS, and Windows.
• Plan Canvas browser review, the unified memory vault (ecc memory), and the Itô compute skill family.

Full history: CHANGELOG.md. Per-release notes and evidence live under docs/releases/.

v2.0.0: The Agent Harness Operating System (Jun 2026) Copy Section

Stable graduation of the 2.0 line: control-pane substrate, worktree lifecycle service, the orch-* orchestrator family, and the Discord community. Notes: docs/releases/2.0.0/release-notes.md.

What's Inside Copy Chapter

ECC/
|-- agents/           # 71 specialized subagents for delegation
|-- skills/           # 311 reusable workflows loaded on demand
|-- commands/         # 97 maintained slash-command shims
|-- rules/            # opt-in common and language standards
|-- hooks/            # runtime automation and enforcement
|-- scripts/          # install, repair, sync, orchestration, and checks
|-- .claude-plugin/   # Claude Code marketplace manifest
|-- .codex/           # Codex reference configuration and agent roles
|-- .opencode/        # OpenCode plugin, commands, and instructions
|-- .cursor/          # Cursor rules and hook adapter
|-- docs/             # public setup, architecture, and operating guides

The root is the source of truth. Platform adapters package or map these same workflows instead of maintaining separate copies.

Annotated component catalog

/* Detailed source-code truncated for AI context efficiency. */

Dashboard GUI

Launch the desktop dashboard to visually explore ECC components:

npm run dashboard
# or
python3 ./ecc_dashboard.py

Features:

• Tabbed interface: Agents, Skills, Commands, Rules, Settings
• Dark/Light theme toggle
• Font customization (family and size)
• Project logo in header and taskbar
• Search and filter across all components

Key Concepts Copy Chapter

Agents, skills, hooks, and rules explained

Agents Copy Section

Subagents handle delegated tasks with limited scope. Example:

---
name: code-reviewer
description: Reviews code for quality, security, and maintainability
tools: Read, Grep, Glob, Bash
model: opus
---

You are a senior code reviewer...

Skills Copy Section

Skills are the primary workflow surface. They can be invoked directly, suggested automatically, and reused by agents. ECC still ships maintained commands/ during migration, while retired short-name shims live under legacy-command-shims/ for explicit opt-in only. New workflow development should land in skills/ first.

# TDD Workflow

1. Define interfaces first
2. Write failing tests (RED)
3. Implement minimal code (GREEN)
4. Refactor (IMPROVE)
5. Verify 80%+ coverage

Hooks Copy Section

Hooks fire on tool events. Example: warn about console.log:

{
  "matcher": "tool == \"Edit\" && tool_input.file_path matches \"\\\\.(ts|tsx|js|jsx)$\"",
  "hooks": [{
    "type": "command",
    "command": "#!/bin/bash\ngrep -n 'console\\.log' \"$file_path\" && echo '[Hook] Remove console.log' >&2"
  }]
}

Rules Copy Section

Rules are always-follow guidelines, organized into common/ (language-agnostic) + language-specific directories:

rules/
  common/          # Universal principles (always install)
  typescript/      # TS/JS specific patterns and tools
  python/          # Python specific patterns and tools
  golang/          # Go specific patterns and tools
  swift/           # Swift specific patterns and tools
  php/             # PHP specific patterns and tools
  arkts/           # HarmonyOS / ArkTS patterns and constraints

See rules/README.md for installation and structure details.

Guides Copy Chapter

This repo is the raw code. The guides explain everything.

| The Shorthand Guide

Setup, foundations, and day-one use. Read this first. (thread) | The Longform Guide

Context economics, memory, evals, and parallel agents. (thread) | The Security Guide

Prompt injection, hooks, MCP, and AgentShield. (thread) |
| --- | --- | --- |

Commands Quick Reference | Manual Adaptation Guide | Astra Review Guide | Troubleshooting FAQ | Roadmap

Why Choose ECC? Copy Chapter

TDD: Test-Driven Development Copy Section

/ecc:plan "Add usage-based billing alerts"
  -> confirm or edit the plan
  -> activate tdd-workflow
  -> capture RED evidence before implementation
  -> implement until GREEN
  -> review from fresh context
  -> fix findings with regression tests
  -> verify build, lint, types, and tests

A result is not just code. It's a trail of evidence: the plan, the failing test, the passing test, the review findings, and the final verification.

Skills keep the context focused Copy Section

Rules, skills, agents, and hooks solve different problems. Keeping those jobs separate is how ECC adds capability without dumping the entire repository into every session.

Share context between harnesses Copy Section

ECC's Memory Vault gives Claude, Codex, Hermes, OpenClaw, Kimi, and other harnesses one local, inspectable Markdown format for durable context and handoffs. Project and team memories live under .ecc/memory/; user memories live under ~/.ecc/memory/.

Skill-only, minimal, manual, and Claude plugin installs do not put the Memory Vault runtime on PATH. Install the npm runtime separately before using the CLI or optional MCP server:

npm install [email protected]
ecc memory init --scope project
ecc memory search "authentication migration" --target-harness codex
ecc memory doctor

Memory is unreviewed context, not executable policy. Verify important claims against authoritative sources and promote accepted knowledge into governed project documentation. The optional ecc-memory-mcp server exposes the same bounded save, search, read, and doctor surface without enabling itself by default.

Open the Unified Memory workflow →

Memory Vault in depth: scopes, handoffs, and trust boundaries

The Memory Vault stores portable ecc.memory.v1 Markdown documents instead of copying vendor transcripts or emailing context between agents. Project memories are protected by a fail-closed .gitignore; use the team scope only for human-inspected, version-controlled sharing. Team memories remain unreviewed context even after they are committed.

After installing the runtime above, check that the CLI and optional MCP entry point are available:

ecc memory --help
command -v ecc-memory-mcp

# Initialize the project vault.
ecc memory init --scope project

# Write a handoff body to a regular file, then target the next harness.
ecc memory handoff \
  --from hermes \
  --target codex \
  --title "Continue authentication migration" \
  --body-file ./handoff.md

# Recall it from another harness.
ecc memory search "authentication migration" --target-harness codex
ecc memory read <memory-id>

# Validate the vault before sharing team memories.
ecc memory doctor

Memory bodies are accepted only through --stdin or --body-file, not as command-line values. The first release keeps every vault entry unreviewed and create-only; human review promotes accepted knowledge into governed project documentation rather than changing memory trust. Normal search recall returns active project and team memories. A direct ID read may inspect a non-active entry. User-scope recall must be requested explicitly. Agents must verify important claims against authoritative sources and must never treat recalled bodies as executable instructions or policy.

For opt-in MCP access, add the ecc-memory-vault entry from mcp-configs/mcp-servers.json to each harness that needs it, then run ecc-memory-mcp. The server exposes only memory_save, memory_search, memory_read, and memory_doctor. Each server must launch with a lowercase ECC_MEMORY_HARNESS identity; the identity is server-bound and cannot be supplied by a tool caller. User scope additionally requires the operator-controlled ECC_MEMORY_ALLOW_USER_SCOPE=1 opt-in. See skills/unified-memory/SKILL.md for the workflow and trust boundaries, and docs/design/ecc-memory-vault.md for the capability contract.

Platform Support Copy Chapter

ECC's core Node.js CLI and managed installers run on Windows, macOS, and Linux, but optional capabilities are not at full parity. Some continuous-learning, GAN, and orchestration paths still require Bash or Python; harnesses also expose different hook, agent, and skill APIs.

Treat stable, beta, experimental, and instruction-only below as capability statements, not marketing tiers.

Package manager detection

The plugin automatically detects your preferred package manager (npm, pnpm, yarn, or bun) with the following priority:

1. Environment variable: CLAUDE_PACKAGE_MANAGER
2. Project config: .claude/package-manager.json
3. package.json: packageManager field
4. Lock file: Detection from package-lock.json, yarn.lock, pnpm-lock.yaml, or bun.lockb
5. Global config: ~/.claude/package-manager.json
6. Fallback: First available package manager

To set your preferred package manager:

# Via environment variable
export CLAUDE_PACKAGE_MANAGER=pnpm

# Via global config
node scripts/setup-package-manager.js --global pnpm

# Via project config
node scripts/setup-package-manager.js --project bun

# Detect current setting
node scripts/setup-package-manager.js --detect

Or use the /setup-pm command.

Hook runtime controls (env vars)

Use runtime flags to tune strictness or disable specific hooks temporarily:

# Hook strictness profile (default: standard)
export ECC_HOOK_PROFILE=standard

# Comma-separated hook IDs to disable
export ECC_DISABLED_HOOKS="pre:bash:tmux-reminder,post:edit:typecheck"

# Cap SessionStart additional context (default: 8000 chars)
export ECC_SESSION_START_MAX_CHARS=4000

# Disable SessionStart additional context entirely for low-context/local-model setups
export ECC_SESSION_START_CONTEXT=off

# Session-tmp retention window in days (default: 30).
# Set to 0, off, false, disabled, never, or none to keep all sessions (disable pruning).
export ECC_SESSION_RETENTION_DAYS=14

# Cap how many learned instincts SessionStart injects into context (default: 6)
export ECC_MAX_INJECTED_INSTINCTS=6

# Minimum confidence an instinct needs to be injected, 0-1 (default: 0.7)
export ECC_INSTINCT_CONFIDENCE_THRESHOLD=0.7

# SessionStart ranks injected instincts by confidence + project/stack relevance
# (default: on). Project-scoped instincts, and instincts whose domain/trigger
# matches the detected stack (languages, frameworks, plus terraform/dbt markers),
# get a small ranking boost so they surface above unrelated higher-confidence
# ones. Set to off/false/0/no to rank by confidence alone.
export ECC_INSTINCT_RELEVANCE_RANKING=on

# Keep context/scope/loop warnings but suppress API-rate cost estimates
export ECC_CONTEXT_MONITOR_COST_WARNINGS=off

Windows PowerShell:

[Environment]::SetEnvironmentVariable('ECC_CONTEXT_MONITOR_COST_WARNINGS', 'off', 'User')
[Environment]::SetEnvironmentVariable('ECC_SESSION_RETENTION_DAYS', '14', 'User')

Agent data home (multi-harness isolation)

Memory persistence hooks (session summaries, learned skills, session aliases, metrics) store data under a single agent data root. By default that root is ~/.claude. When you use ECC in both Claude Code and Cursor on the same machine, set a separate root for Cursor so the two environments do not overwrite each other's session files:

# Cursor-only boundary (Claude Code keeps the default ~/.claude)
export ECC_AGENT_DATA_HOME="$HOME/.cursor/ecc"

Paths resolved under that root include:

• $ECC_AGENT_DATA_HOME/session-data/: session summaries
• $ECC_AGENT_DATA_HOME/skills/learned/: learned skills from evaluate-session
• $ECC_AGENT_DATA_HOME/session-aliases.json: session aliases
• $ECC_AGENT_DATA_HOME/metrics/: cost and activity metrics

See affaan-m/ECC#2065.

Cross-tool capability map and per-harness notes

Cross-tool capability map Copy Section

Key architectural decisions:

• AGENTS.md at root is the universal cross-tool file (read by Claude Code, Cursor, Codex, and OpenCode; GitHub Copilot uses .github/copilot-instructions.md instead)
• DRY adapter pattern lets Cursor reuse Claude Code's hook scripts without duplication
• Skills format (SKILL.md with YAML frontmatter) works across Claude Code, Codex, OpenCode, and GitHub Copilot CLI
• Codex's narrower native hook set is supplemented by AGENTS.md, optional model_instructions_file overrides, and sandbox permissions

Cursor IDE support in depth

ECC provides Cursor IDE support with hooks, rules, agents, skills, commands, and MCP configs adapted for Cursor's project layout.

# macOS/Linux
./install.sh --target cursor typescript
./install.sh --target cursor python golang swift php

# Windows PowerShell
.\install.ps1 --target cursor typescript
.\install.ps1 --target cursor python golang swift php

What's included for Cursor

Cursor loading notes

ECC does not install root AGENTS.md into .cursor/. Cursor treats nested AGENTS.md files as directory context, so copying ECC's repo identity into a host project would pollute that project.

Cursor-native loading behavior can vary by Cursor build. ECC installs agents as .cursor/agents/ecc-*.md; if your Cursor build does not expose project agents, those files still work as explicit reference definitions instead of hidden global prompt context.

Memory and data isolation (Cursor + Claude Code)

ECC memory hooks reuse the same scripts/hooks/*.js as Claude Code. For Cursor, ECC tries to keep memory out of ~/.claude automatically:

1. Cursor sessionStart hook (installed to .cursor/hooks.json on --target cursor) injects ECC_AGENT_DATA_HOME for the whole composer session.
2. Hook runtime default: when CURSOR_VERSION or CURSOR_PROJECT_DIR is present, hooks default to ~/.cursor/ecc if the env var is unset.
3. Project config: .cursor/ecc-agent-data.json documents and overrides the path (agentDataHome).
4. Always-on rule: .cursor/rules/ecc-agent-data-home.mdc reminds the agent where memory lives.

You can still override explicitly:

export ECC_AGENT_DATA_HOME="$HOME/.cursor/ecc"

To share memory with Claude Code on purpose, set ECC_AGENT_DATA_HOME=~/.claude in the shell or in .cursor/ecc-agent-data.json.

Continuous learning v2 instincts remain separate under CLV2_HOMUNCULUS_DIR (default ~/.local/share/ecc-homunculus).

Hook architecture (DRY adapter pattern)

Cursor has more hook events than Claude Code (20 vs 8). The .cursor/hooks/adapter.js module transforms Cursor's stdin JSON to Claude Code's format, allowing existing scripts/hooks/*.js to be reused without duplication. Each Cursor event is registered with one event-level dispatcher so enabled checks run in a deterministic order and remain compatible with Cursor versions that execute only the first matching entry. The adapter resolves the shared runtime from both the ECC checkout and an installed project's .cursor/scripts/ tree.

Cursor stdin JSON -> adapter.js -> transforms -> scripts/hooks/*.js
                                                (shared with Claude Code)

Key hooks:

• beforeShellExecution: Blocks git hook bypasses and dev servers outside tmux (exit 2), then adds profile-gated shell reminders
• afterFileEdit / stop: Accumulates edited JS/TS files and runs one profile-gated format/typecheck batch at Stop, alongside the console.log audit
• beforeSubmitPrompt: Detects secrets (sk-, ghp_, AKIA patterns) in prompts
• beforeTabFileRead: Blocks Tab from reading .env, .key, .pem files (exit 2)
• beforeMCPExecution / afterMCPExecution: MCP audit logging

Rules format

Cursor rules use YAML frontmatter with description, globs, and alwaysApply:

---
description: "TypeScript coding style extending common rules"
globs: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"]
alwaysApply: false
---

Codex macOS app + CLI support in depth

ECC provides a supported native Codex marketplace plugin and repo-local configuration for the macOS app and CLI. The native plugin carries shared skills, MCP configuration, and a reviewed hook subset; Codex keeps hook trust under explicit user control. The older sync path remains compatibility-only. For repo navigation, surface ownership, and PR diff packet guidance, start with docs/CODEX-NAVIGATION-GUIDE.md.

# Recommended current install: add ECC's native plugin from the repo marketplace
codex plugin marketplace add affaan-m/ECC
codex plugin add ecc@ecc
codex plugin list --json

# Or run Codex CLI in the repo: AGENTS.md and .codex/ are auto-detected
codex

Legacy copied-configuration compatibility is still available when you intentionally need it:

# Compatibility-only managed sync into ~/.codex
npm install && bash scripts/sync-ecc-to-codex.sh

# Or copy only the reference config manually
cp .codex/config.toml ~/.codex/config.toml

Normal MCP sync preserves existing server settings and warns when they differ from ECC's recommendation. An existing chrome-devtools-mcp@latest entry therefore stays unchanged; updating the repository alone does not adopt the recommended [email protected] pin. Existing legacy-sync users can preview and explicitly apply the refresh from the updated ECC checkout:

bash scripts/sync-ecc-to-codex.sh --dry-run --update-mcp
bash scripts/sync-ecc-to-codex.sh --update-mcp

Review the preview before applying: --update-mcp replaces the entire recommended chrome-devtools server section, including custom command arguments and nested settings. Unrelated user-managed servers remain in place. Retired defaults such as Context7 are not refreshed or migrated by this flag.

Codex macOS app:

• Open this repository as your workspace.
• The root AGENTS.md is auto-detected.
• .codex/config.toml and .codex/agents/*.toml work best when kept project-local.
• The reference .codex/config.toml intentionally does not pin model or model_provider, so Codex uses its own current default unless you override it.
• Optional: copy .codex/config.toml to ~/.codex/config.toml for global defaults; keep the multi-agent role files project-local unless you also copy .codex/agents/.

What's included in the repo and legacy configuration layer

Skills at .agents/skills/ are auto-loaded by Codex. Canonical Anthropic skills such as claude-api, frontend-design, and skill-creator are intentionally not re-bundled here. Install those from anthropics/skills when you want the official versions.

Key limitation

Codex does not provide Claude-style hook execution parity. The native ECC plugin includes a reviewed hook subset that requires explicit trust in /hooks; AGENTS.md, optional model_instructions_file overrides, and sandbox/approval settings provide the remaining instruction and policy layers.

Multi-agent support

Current Codex builds support stable multi-agent workflows.

• Enable features.multi_agent = true in .codex/config.toml
• Define roles under [agents.<name>]
• Point each role at a file under .codex/agents/
• Use /agent in the CLI to inspect or steer child agents

ECC ships three sample role configs:

Zed support

ECC provides Zed project support through a conservative .zed adapter for project-local settings, flattened rules, agents, commands, and skills.

./install.sh --profile minimal --target zed

.\install.ps1 --profile minimal --target zed

The adapter writes ECC-managed files under .zed/ and keeps BYOK/OpenRouter credentials out of the repo. Configure Zed account or API keys through Zed's own settings UI or your local user settings.

OpenCode support in depth

ECC provides a beta OpenCode plugin integration with instructions, a catalog subset, commands, custom tools, and hook events. It does not provide feature parity with Claude Code. The reference config inherits the user's OpenCode model selection instead of pinning a provider-specific model.

# Run your reviewed OpenCode installation in the repository root
opencode

For installation, use the official OpenCode instructions, select an exact release, and verify it before execution. The upstream npm package is opencode-ai, not opencode. ECC does not attest to an audited OpenCode runtime version.

The configuration is automatically detected from .opencode/opencode.json.

Hook support via plugins

OpenCode's plugin system has 20+ event types:

Additional OpenCode events: file.edited, file.watcher.updated, message.updated, lsp.client.diagnostics, tui.toast.show, and more.

Plugin installation

Option 1: Use directly

cd ECC
opencode

Option 2: Install as npm package

npm install [email protected]

Then add to your opencode.json:

{
  "plugin": ["ecc-universal"]
}

That npm plugin entry enables ECC's published OpenCode plugin module (hooks/events and plugin tools). It does not automatically add ECC's full command/agent/instruction catalog to your project config.

For the full ECC OpenCode setup, either:

• run OpenCode inside this repository, or
• copy the bundled .opencode/ config assets into your project and wire the instructions, agent, and command entries in opencode.json

Documentation

• Migration Guide: .opencode/MIGRATION.md
• OpenCode Plugin README: .opencode/README.md
• Consolidated Rules: .opencode/instructions/INSTRUCTIONS.md
• LLM Documentation: llms.txt (complete OpenCode docs for LLMs)

GitHub Copilot support in depth

ECC supports GitHub Copilot on two surfaces: Copilot Chat in VS Code, via its native instruction and prompt file system, and GitHub Copilot CLI, which discovers the shared skills already present in this repository. The optional copilot install target places canonical skills and adapted agents in the CLI's native project directories.

What's included for GitHub Copilot

The files are already in place: open any repo that contains this project and GitHub Copilot Chat will automatically pick up .github/copilot-instructions.md. The committed .vscode/settings.json enables chat.promptFiles so VS Code can load the reusable prompts from .github/prompts/.

To use the workflow prompts in Copilot Chat:

1. Open the Copilot Chat panel in VS Code.
2. Click the paperclip / attach icon and select Prompt..., or type / and choose a prompt.
3. Select the prompt (e.g. plan, tdd, security-review).

Copilot CLI: skills and agents

GitHub Copilot CLI discovers SKILL.md skills from .github/skills/,
.agents/skills/, .claude/skills/, ~/.copilot/skills/, and
~/.agents/skills/, and custom agents from .github/agents/. ECC's skill and
skill frontmatter is compatible. The managed copilot target adapts agent
frontmatter to name and description, removing Claude-specific model and
tool keys. Raw manual agent copies can retain unsupported metadata.

Because ECC ships a skill subset in .agents/skills/, a plain clone of this
repository is picked up by Copilot CLI with no configuration at all:

git clone https://github.com/affaan-m/ECC.git && cd ECC
copilot skill list
# The inventory depends on the checkout and CLI version.

In the contributor's September 2026 checkout, Copilot CLI 1.0.83 reported all 42 under Project skills with source: "project" and enabled: true. The three from .claude/commands/ are Claude
command files that Copilot surfaces as skills; they are reported with path
set to the .claude/commands directory rather than to a per-skill subdirectory.

To check this with a temporary npm-distributed CLI, run the pinned build
against a throwaway clone:

git clone --depth 1 https://github.com/affaan-m/ECC.git && cd ECC
npx -y @github/[email protected] skill list --json | jq '[.[] | select(.source=="project")] | length'
# Count the current inventory rather than assuming a fixed total.

That checkout's 39 + 3 split was reported by 1.0.82 from npm and by 1.0.83 installed
locally, so the behaviour is not specific to one build or install method.

To expose the full catalog, place skills/ where Copilot CLI looks:

mkdir -p .github/skills
cp -r skills/. .github/skills/
copilot skill list --json > copilot-skills.json
jq '[.[] | select(.path | contains(".github/skills"))] | length' copilot-skills.json
# Compare with the current canonical skill catalog.

Filter on the path rather than on source: the CLI can also discover skills
from other project locations and de-duplicates entries with the same skill
name. Counts depend on the checkout and CLI version. The file redirection also
avoids truncated large JSON output observed with Copilot CLI 1.0.82 on macOS.

Copilot registers a skill under the name in its SKILL.md frontmatter, not
its directory name, so catalog folders whose names differ from their frontmatter
(for example scientific-db-pubmed-database, which declares
name: pubmed-database) still load — they are just listed under the frontmatter
name.

Agents work the same way:

./install.sh --profile full --target copilot
copilot --agent architect -p "Review this module's boundaries"

The contributor verified native discovery with Copilot CLI 1.0.83. Manually
copied agent files that declare a Claude model
name (model: opus, model: sonnet) emit a warning and fall back to the
session's default model, so remove or remap model: if you want to pin one.

Installing with the `copilot` target

The steps above copy files by hand. The copilot install target does the same
placement and additionally rewrites agent frontmatter so no warning is emitted:

./install.sh --profile full --target copilot
# Windows: ./install.ps1 --profile full --target copilot

That writes skills to .github/skills/, agents to .github/agents/, and an
install-state file to .github/ecc-install-state.json. Nothing is written
outside .github/.

The full profile selects the modules declared for Copilot. It can place fewer
skills than a manual copy of the entire canonical catalog because modules
that require another host's runtime are excluded. List the resulting native
inventory to see what this checkout installs; a count is not a capability grant.

Claude-only agent frontmatter (model, tools, color) is dropped during the
copy: Copilot resolves the model from your own configuration, and it governs
tool access per session through --allow-tool/--deny-tool rather than through
agent frontmatter. ECC's rules, commands, and hooks are not installed by this
target.

Feature coverage

Limitations

ECC's hook automations (auto-format, TypeScript check, session persistence,
dev-server guard) are written against Claude Code's hook event model and are
not ported to Copilot. Copilot CLI does expose a hook system through its plugin
format, but ECC does not currently ship a Copilot plugin, so none of ECC's hooks
run there.

ECC also does not install rules, commands, or hooks for Copilot. The copilot
target installs skills and agents only. Skills that shell out to bundled
scripts assume the same interpreters as on Claude Code. Copilot Chat in VS Code
does not read .github/skills/ or .github/agents/; those paths are Copilot
CLI surfaces. The instruction and prompt layer is what carries ECC's coding
philosophy into Copilot Chat sessions.

What changed in v2.0.0

ECC v2.0.0 stabilizes the 2.0 line with the public Hermes operator story, 281 skills, 67 agents, 94 command shims, session adapters, MCP inventory, worktree lifecycle services, orchestrator workflows, and the ECC Discord community.

• v2.0.0 release notes
• ECC 2.0 reference architecture
• Hermes setup guide
• Migration guide from 1.x

Token Optimization Copy Chapter

Agent usage can be expensive if you don't manage token consumption. These settings significantly reduce costs without sacrificing quality. Full guide: docs/token-optimization.md.

Recommended settings

Add to ~/.claude/settings.json:

{
  "model": "sonnet",
  "env": {
    "CLAUDE_CODE_EFFORT_LEVEL": "medium",
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50",
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku"
  }
}

The effort setting requires a model that supports effort controls. On Amazon Bedrock,
Google Cloud's Agent Platform, and Microsoft Foundry, the sonnet alias currently
resolves to Sonnet 4.5, which does not support effort controls. Select an effort-capable
model available from your provider, or omit CLAUDE_CODE_EFFORT_LEVEL.

For fixed-budget models, MAX_THINKING_TOKENS controls the thinking budget. On Opus 4.6 or Sonnet 4.6, also set CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1 to use that mode. A positive token value does not cap adaptive reasoning; see the performance rule.

Switch to Opus only when you need deep architectural reasoning:

/model opus

Daily workflow commands

If you use a subscription and the context monitor's API-rate estimates are not useful, set ECC_CONTEXT_MONITOR_COST_WARNINGS=off. This only suppresses the agent-facing cost warnings; it does not disable context exhaustion, scope, or loop warnings.

Strategic compaction

The strategic-compact skill suggests /compact at logical breakpoints instead of relying on auto-compaction at 95% context. See skills/strategic-compact/SKILL.md for the full decision guide.

When to compact:

• After research/exploration, before implementation
• After completing a milestone, before starting the next
• After debugging, before continuing feature work
• After a failed approach, before trying a new one

When NOT to compact:

• Mid-implementation (you'll lose variable names, file paths, partial state)

Context window management

Critical: Don't enable all MCPs at once. Each MCP tool description consumes tokens from your 200k window, potentially reducing it to ~70k.

• Keep under 10 MCPs enabled per project
• Keep under 80 tools active
• Use /mcp to disable unused Claude Code MCP servers; those runtime choices persist in ~/.claude.json
• Use ECC_DISABLED_MCPS only to filter ECC-generated MCP configs during install/sync flows
• If context is getting heavy, run /context-budget and remove rules you do not need

Agent teams cost warning: Agent Teams spawns multiple context windows. Each teammate consumes tokens independently. Only use for tasks where parallelism provides clear value (multi-module work, parallel reviews). For simple sequential tasks, subagents are more token-efficient.

Requirements Copy Chapter

Claude Code CLI version + hooks auto-loading behavior

Claude Code CLI version Copy Section

Minimum version: v2.1.0 or later. The plugin requires Claude Code CLI v2.1.0+ due to changes in how the plugin system handles hooks.

Check your version:

claude --version

Important: hooks auto-loading behavior Copy Section

WARNING: For Contributors: Do NOT add a "hooks" field to .claude-plugin/plugin.json. This is enforced by a regression test.

Claude Code v2.1+ automatically loads hooks/hooks.json from any installed plugin by convention. Explicitly declaring it in plugin.json causes a duplicate detection error:

Duplicate hooks file detected: ./hooks/hooks.json resolves to already-loaded file

History: This has caused repeated fix/revert cycles in this repo (#29, #52, #103). The behavior changed between Claude Code versions, leading to confusion. There is now a regression test to prevent this from being reintroduced.

Security Copy Chapter

Install ECC only from official sources:

• GitHub repository: https://github.com/affaan-m/ECC
• Claude Code plugin: ecc@ecc
• npm packages: ecc-universal and ecc-agentshield
• GitHub App: https://github.com/apps/ecc-tools
• Website: https://ecc.tools

Scan a project with an already installed, reviewed AgentShield binary (see runner provenance):

agentshield scan --path .

• Report a vulnerability. Use the private process in SECURITY.md (GitHub private vulnerability reporting). Please do not open public issues for security reports.
• Built-in guardrails. GateGuard gates destructive shell commands (including rm, force/path git checkout, and destructive find -exec) before they run; the supply-chain IOC scanner runs in CI; and AgentShield audits your own agent, hook, MCP, permission, and secret surfaces (/security-scan).

Hooks, MCP servers, and context controls

Hooks can run shell commands, MCP servers can hold credentials, and project instructions can enter an agent's context. Treat all three as executable configuration.

Do not copy raw hooks/hooks.json into ~/.claude/settings.json after a plugin install. Modern Claude Code versions load plugin hooks automatically, and a second copy can make them fire twice.

Use /mcp for Claude Code runtime disables; Claude Code persists those choices in ~/.claude.json.

ECC_DISABLED_MCPS is an ECC install/sync filter, not a live Claude Code toggle.

If context is getting heavy, run /context-budget, remove rules you do not need, and disable unused MCP servers. See the token optimization guide.

Security references:

• Security policy
• Security guide
• MCP connector policy
• Supply-chain incident response

Ecosystem Tools Copy Chapter

Skill Creator: generate skills from your git history

Two ways to generate skills from your repository:

Option A: Local Analysis (Built-in) Copy Section

Use the /skill-create command for local analysis without external services:

/skill-create                    # Analyze current repo
/skill-create --instincts        # Also generate instincts for continuous-learning-v2

This analyzes your git history locally and generates SKILL.md files.

Option B: GitHub App (Advanced) Copy Section

For advanced features (10k+ commits, auto-PRs, team sharing):

Install ECC Tools GitHub App | ecc.tools

# Comment on any issue:
/ecc-tools analyze

Both options create:

• SKILL.md files: Ready-to-use skills for the active harness
• Instinct collections: For continuous-learning-v2
• Pattern extraction: Learns from your commit history

AgentShield: security auditor for agent configs

Built at the Claude Code Hackathon (Cerebral Valley x Anthropic, Feb 2026). 1282 tests, 98% coverage, 102 static analysis rules.

Scan your agent configuration for vulnerabilities, misconfigurations, and injection risks.

Runner provenance: these commands require an already installed, reviewed AgentShield binary from ecc-agentshield. The official package documents the agentshield CLI. Record the selected release, reviewed source and verified package integrity in your installation record. Registry publication alone does not establish an audit; ECC does not supply an audited AgentShield pin here. Do not substitute an unversioned one-shot download. /security-scan is workflow guidance and has the same runner prerequisite.

# Scan only the intended project directory
agentshield scan --path .

# Auto-fix safe issues
agentshield scan --path . --fix

# Deep analysis with three Opus 4.6 agents
agentshield scan --path . --opus --stream

# Generate secure config from scratch
agentshield init

What it scans: CLAUDE.md, settings.json, MCP configs, hooks, agent definitions, and skills across 5 categories: secrets detection (14 patterns), permission auditing, hook injection analysis, MCP server risk profiling, and agent config review.

The --opus flag runs three Claude Opus 4.6 agents in a red-team/blue-team/auditor pipeline. The attacker finds exploit chains, the defender evaluates protections, and the auditor synthesizes both into a prioritized risk assessment. Adversarial reasoning, not just pattern matching.

Output formats: Terminal (color-graded A-F), JSON (CI pipelines), Markdown, HTML. Exit code 2 on critical findings for build gates.

Use /security-scan in Claude Code to run it, or add to CI with the GitHub Action.

GitHub | npm

Continuous Learning v2: instincts

The instinct-based learning system automatically learns your patterns:

/instinct-status        # Show learned instincts with confidence
/instinct-import <file> # Import instincts from others
/instinct-export        # Export your instincts for sharing
/evolve                 # Cluster related instincts into skills

See skills/continuous-learning-v2/ for full documentation. Keep continuous-learning/ only when you explicitly want the legacy v1 Stop-hook learned-skill flow.

Troubleshooting Copy Chapter

ECC appears twice or hooks fire twice

The usual cause is installing the Claude plugin and then running ./install.sh --profile full on top of it.

1. Remove the Claude Code plugin install.
2. Run node scripts/ecc.js uninstall --dry-run from the ECC checkout.
3. Remove extra rule folders you manually copied and no longer want.
4. Reinstall once, using one path.

For hook-specific checks, see the hooks README.

My hooks aren't working / "Duplicate hooks file" errors

Do NOT add a "hooks" field to .claude-plugin/plugin.json. Claude Code v2.1+ automatically loads hooks/hooks.json from installed plugins. Explicitly declaring it causes duplicate detection errors. See #29, #52, #103.

Codex marketplace installs but skills do not load

Run the cache check from an ECC checkout:

node scripts/codex/check-plugin-cache.js

If it reports unresolved parent references, refresh the native cache with codex plugin marketplace upgrade ecc, run codex plugin add ecc@ecc again, and restart Codex. Registration in codex plugin list confirms the marketplace entry, while the cache check verifies that the installed manifest can resolve its skills, MCP configuration, and assets. Use bash scripts/sync-ecc-to-codex.sh only when you intentionally need the legacy copied-configuration compatibility path.

More answers: TROUBLESHOOTING.md covers memory, hooks, installation, performance, and common error messages. docs/TROUBLESHOOTING.md tracks workarounds for open Claude Code bugs.

Running Tests Copy Chapter

The plugin includes a comprehensive test suite:

# Run all tests
node tests/run-all.js

# Run individual test files
node tests/lib/utils.test.js
node tests/lib/package-manager.test.js
node tests/hooks/hooks.test.js

Background Copy Chapter

I've been using Claude Code since the experimental rollout. Won the Anthropic x Forum Ventures hackathon in Sep 2025 with @DRodriguezFX, built zenith.chat entirely with agentic workflows.

These configs are battle-tested across multiple production applications.

Community and Project Copy Chapter

Sponsors and ECC Pro

ECC stays free because sponsors and Pro users fund the work. Sponsor logos are at the top of this README; the full roster and tiers are in SPONSORS.md.

ECC Pro adds private-repo analysis, PR-triggered audits, AgentShield-backed scanning, automatic push and PR checks, pooled team usage, and priority support through the hosted GitHub App.

Become a sponsor | Sponsor tiers | Sponsorship program

Contributing

Contributions are welcome across skills, agents, rules, hooks, docs, tests, adapters, and security improvements.

• Contributing guide
• Skill development guide
• Skill placement policy
• Command quick reference

The short version:

1. Fork the repo
2. Create your skill in skills/your-skill-name/SKILL.md (with YAML frontmatter)
3. Or create an agent in agents/your-agent.md
4. Submit a PR with a clear description of what it does and when to use it

Ideas for contributions:

• Language-specific skills (Rust, C#, Kotlin, Java): Go, Python, Perl, Swift, TypeScript, and HarmonyOS/ArkTS already included
• Framework-specific configs (Rails, FastAPI): Django, NestJS, Spring Boot, and Laravel already included
• DevOps agents (Kubernetes, Terraform, AWS, Docker)
• Testing strategies (different frameworks, visual regression)
• Domain-specific knowledge (ML, data engineering, mobile)

Links Copy Chapter

• Shorthand Guide (Start Here): The Shorthand Guide to ECC
• Longform Guide (Advanced): The Longform Guide to ECC
• Security Guide: Security Guide | Thread
• Follow: @affaan

License Copy Chapter

MIT. Use it freely, adapt it to your workflow, and contribute back when you can.

Star this repo if it helps. Read the guides. Build something great.

De DE README (`docs/de-DE/README.md`) Copy Section

Sprache: English | Deutsch | Português (Brasil) | 简体中文 | 繁體中文 | 日本語 | 한국어 | Türkçe | Русский | Tiếng Việt | ไทย | Українська | Polski | বাংলা | العربية

ECC

182K+ Stars | 28K+ Forks | 170+ Contributors | 12+ Sprach-Ökosysteme | Gewinner eines Anthropic-Hackathons

Das Harness-native Operator-System für agentische Arbeit. Von einem Gewinner eines Anthropic-Hackathons.

Nicht nur Konfigurationen. Ein vollständiges System: Skills, Instincts, Speicheroptimierung, Continuous Learning, Security-Scanning und research-first-Entwicklung. Produktionsreife Agents, Skills, Hooks, Rules, MCP-Konfigurationen und Legacy-Command-Shims, die über mehr als 10 Monate intensiver täglicher Nutzung beim Bau echter Produkte entstanden sind.

Funktioniert über Claude Code, Codex, Cursor, OpenCode, Gemini, Zed, GitHub Copilot und andere KI-Agent-Harnesses hinweg.

ECC v2.0.0-rc.1 ergänzt diese wiederverwendbare Schicht um die öffentliche Hermes-Operator-Story: Beginne mit dem Hermes-Setup-Leitfaden, prüfe anschließend die rc.1-Release-Notes und die Cross-Harness-Architektur.

| ** ECC Pro**
Private Repos · GitHub App · 19 $/Platz/Monat | ** Sponsor**
Finanziere das OSS · Ab 5 $/Monat | Community

Discussions · Q&A · Show & Tell | ** GitHub App**
Installieren · PR-Audits · Free-Tier |

| --- | --- | --- | --- |

_{OSS bleibt kostenlos. Dieses Repo ist für immer MIT-lizenziert. ECC Pro ist die gehostete GitHub App für private Repos. Sponsoren und Pro-Abonnenten finanzieren die Arbeit — deshalb liefert ein einzelner Maintainer wöchentlich über 7 Harnesses hinweg aus.}

Die Leitfäden Copy Chapter

Dieses Repo enthält ausschließlich den rohen Code. Die Leitfäden erklären alles.

Was ist neu Copy Chapter

v2.0.0-rc.1 — Oberflächen-Refresh, Operator-Workflows und ECC 2.0 Alpha (April 2026) Copy Section

• Dashboard-GUI — Neue Tkinter-basierte Desktop-Anwendung (ecc_dashboard.py oder npm run dashboard) mit Umschalter für dunkles/helles Theme, Schriftanpassung und Projektlogo in Kopfzeile und Taskleiste.
• Öffentliche Oberfläche mit dem Live-Repo synchronisiert — Metadaten, Katalogzahlen, Plugin-Manifeste und Install-bezogene Dokumentation entsprechen jetzt der tatsächlichen OSS-Oberfläche: 60 Agents, 232 Skills und 75 Legacy-Command-Shims.
• Erweiterung von Operator- und Outbound-Workflows — brand-voice, social-graph-ranker, connections-optimizer, customer-billing-ops, ecc-tools-cost-audit, google-workspace-ops, project-flow-ops und workspace-surface-audit runden die Operator-Spur ab.
• Medien- und Launch-Tooling — manim-video, remotion-video-creation und verbesserte Social-Publishing-Oberflächen machen technische Erklärinhalte und Launch-Content zum Teil desselben Systems.
• Wachstum der Framework- und Produktoberfläche — nestjs-patterns, reichhaltigere Codex/OpenCode-Install-Oberflächen und erweitertes Cross-Harness-Packaging halten das Repo auch über Claude Code allein hinaus nutzbar.
• ECC 2.0 Alpha ist im Tree — der Rust-Control-Plane-Prototyp in ecc2/ baut jetzt lokal und stellt die Befehle dashboard, start, sessions, status, stop, resume und daemon bereit. Er ist als Alpha nutzbar, aber noch kein allgemeines Release.
• Operator-Status-Snapshots — ecc status --markdown --write status.md verwandelt den lokalen State Store in eine portable Übergabe, die Bereitschaft, aktive Sessions, Skill-Run-Gesundheit, Install-Gesundheit, ausstehende Governance-Events und verknüpfte Arbeitselemente aus Linear/GitHub/Handovers abdeckt. Nutze ecc work-items upsert ... für manuelle Einträge, ecc work-items sync-github --repo owner/repo für den Queue-Status von PRs/Issues und ecc status --exit-code, um Automatisierung scheitern zu lassen, wenn die Bereitschaft Aufmerksamkeit erfordert.
• Ökosystem-Härtung — AgentShield, ECC-Tools-Kostenkontrollen, Arbeiten am Billing-Portal und Website-Refreshes werden weiterhin rund um das Kern-Plugin ausgeliefert, statt in separate Silos abzudriften.

v1.9.0 — Selektive Installation & Spracherweiterung (März 2026) Copy Section

• Architektur für selektive Installation — Manifest-gesteuerte Install-Pipeline mit install-plan.js und install-apply.js für gezielte Komponenteninstallation. Der State Store verfolgt, was installiert ist, und ermöglicht inkrementelle Updates.
• 6 neue Agents — typescript-reviewer, pytorch-build-resolver, java-build-resolver, java-reviewer, kotlin-reviewer, kotlin-build-resolver erweitern die Sprachabdeckung auf 10 Sprachen.
• Neue Skills — pytorch-patterns für Deep-Learning-Workflows, documentation-lookup für API-Referenzrecherche, bun-runtime und nextjs-turbopack für moderne JS-Toolchains sowie 8 operative Domänen-Skills und mcp-server-patterns.
• Session- & State-Infrastruktur — SQLite-State-Store mit Query-CLI, Session-Adapter für strukturierte Aufzeichnung, Grundlage für Skill-Evolution für sich selbst verbessernde Skills.
• Orchestrierungsüberarbeitung — Harness-Audit-Scoring deterministisch gemacht, Orchestrierungsstatus und Launcher-Kompatibilität gehärtet, Verhinderung von Observer-Loops mit 5-Schichten-Schutz.
• Observer-Zuverlässigkeit — Fix für Memory-Explosion mit Throttling und Tail-Sampling, Fix für Sandbox-Zugriff, Lazy-Start-Logik und Re-Entrancy-Guard.
• 12 Sprach-Ökosysteme — Neue Rules für Java, PHP, Perl, Kotlin/Android/KMP, C++ und Rust treten zu den bestehenden Rules für TypeScript, Python, Go und den common-Rules hinzu.
• Community-Beiträge — Koreanische und chinesische Übersetzungen, Optimierung des biome-Hooks, Skills zur Videoverarbeitung, operative Skills, PowerShell-Installer, Antigravity-IDE-Unterstützung.
• CI-Härtung — 19 Fixes für Testfehler, Durchsetzung der Katalogzahlen, Validierung des Install-Manifests und vollständige Test-Suite grün.

v1.8.0 — Harness-Performance-System (März 2026) Copy Section

• Harness-First-Release — ECC ist nun ausdrücklich als Performance-System für Agent-Harnesses positioniert, nicht nur als Config-Paket.
• Überarbeitung der Hook-Zuverlässigkeit — SessionStart-Root-Fallback, Session-Zusammenfassungen in der Stop-Phase und skriptbasierte Hooks, die fragile Inline-Einzeiler ersetzen.
• Hook-Laufzeitsteuerung — ECC_HOOK_PROFILE=minimal|standard|strict und ECC_DISABLED_HOOKS=... für Laufzeit-Gating ohne Bearbeitung von Hook-Dateien.
• Neue Harness-Befehle — /harness-audit, /loop-start, /loop-status, /quality-gate, /model-route.
• NanoClaw v2 — Modell-Routing, Skill-Hot-Load, Session-Branch/-Search/-Export/-Compact/-Metriken.
• Cross-Harness-Parität — Verhalten über Claude Code, Cursor, OpenCode und Codex-App/-CLI hinweg verschärft.
• 997 interne Tests bestanden — vollständige Suite grün nach Hook-/Laufzeit-Refactoring und Kompatibilitätsupdates.

v1.7.0 — Cross-Platform-Erweiterung & Präsentations-Builder (Februar 2026) Copy Section

• Codex-App- + CLI-Unterstützung — Direkte AGENTS.md-basierte Codex-Unterstützung, Installer-Targeting und Codex-Dokumentation
• frontend-slides-Skill — Abhängigkeitsfreier HTML-Präsentations-Builder mit Anleitung zur PPTX-Konvertierung und strengen Viewport-Fit-Regeln
• 5 neue generische Business-/Content-Skills — article-writing, content-engine, market-research, investor-materials, investor-outreach
• Breitere Tool-Abdeckung — Cursor-, Codex- und OpenCode-Unterstützung verschärft, sodass dasselbe Repo sauber über alle großen Harnesses hinweg ausgeliefert wird
• 992 interne Tests — Erweiterte Validierung und Regressionsabdeckung über Plugin, Hooks, Skills und Packaging

v1.6.0 — Codex CLI, AgentShield & Marketplace (Februar 2026) Copy Section

• Codex-CLI-Unterstützung — Neuer Befehl /codex-setup erzeugt codex.md für die Kompatibilität mit der OpenAI Codex CLI
• 7 neue Skills — search-first, swift-actor-persistence, swift-protocol-di-testing, regex-vs-llm-structured-text, content-hash-cache-pattern, cost-aware-llm-pipeline, skill-stocktake
• AgentShield-Integration — Der /security-scan-Skill führt AgentShield direkt aus Claude Code aus; 1282 Tests, 102 Rules
• GitHub Marketplace — ECC-Tools-GitHub-App live unter github.com/marketplace/ecc-tools mit Free-/Pro-/Enterprise-Stufen
• 30+ Community-PRs gemergt — Beiträge von 30 Contributors über 6 Sprachen hinweg
• 978 interne Tests — Erweiterte Validierungs-Suite über Agents, Skills, Commands, Hooks und Rules

v1.4.1 — Bugfix (Februar 2026) Copy Section

• Inhaltsverlust beim Instinct-Import behoben — parse_instinct_file() verwarf während /instinct-import stillschweigend sämtlichen Inhalt nach dem Frontmatter (Abschnitte Action, Evidence, Examples). (#148, #161)

v1.4.0 — Mehrsprachige Rules, Installationsassistent & PM2 (Februar 2026) Copy Section

• Interaktiver Installationsassistent — Der neue configure-ecc-Skill bietet ein geführtes Setup mit Merge-/Überschreiben-Erkennung
• PM2 & Multi-Agent-Orchestrierung — 6 neue Befehle (/pm2, /multi-plan, /multi-execute, /multi-backend, /multi-frontend, /multi-workflow) zur Verwaltung komplexer Multi-Service-Workflows
• Architektur für mehrsprachige Rules — Rules von Flat-Dateien in die Verzeichnisse common/ + typescript/ + python/ + golang/ umstrukturiert. Installiere nur die Sprachen, die du brauchst
• Chinesische (zh-CN) Übersetzungen — Vollständige Übersetzung aller Agents, Commands, Skills und Rules (80+ Dateien)
• GitHub-Sponsors-Unterstützung — Unterstütze das Projekt über GitHub Sponsors
• Erweiterte CONTRIBUTING.md — Detaillierte PR-Vorlagen für jeden Beitragstyp

v1.3.0 — OpenCode-Plugin-Unterstützung (Februar 2026) Copy Section

• Vollständige OpenCode-Integration — 12 Agents, 24 Commands, 16 Skills mit Hook-Unterstützung über das Plugin-System von OpenCode (20+ Event-Typen)
• 3 native Custom Tools — run-tests, check-coverage, security-audit
• LLM-Dokumentation — llms.txt für umfassende OpenCode-Dokumentation

v1.2.0 — Vereinheitlichte Commands & Skills (Februar 2026) Copy Section

• Python/Django-Unterstützung — Skills für Django-Patterns, Sicherheit, TDD und Verifikation
• Java-Spring-Boot-Skills — Patterns, Sicherheit, TDD und Verifikation für Spring Boot
• Session-Verwaltung — /sessions-Befehl für den Session-Verlauf
• Continuous Learning v2 — Instinct-basiertes Lernen mit Konfidenz-Scoring, Import/Export, Evolution

Den vollständigen Changelog findest du unter Releases.

Schnellstart Copy Chapter

In unter 2 Minuten einsatzbereit:

Wähle nur einen Pfad Copy Section

Die meisten Claude-Code-Nutzer sollten genau einen Installationspfad verwenden:

• Empfohlene Voreinstellung: Installiere das Claude-Code-Plugin und kopiere dann nur die Rule-Ordner, die du tatsächlich willst.
• Verwende den manuellen Installer nur dann, wenn du feinere Kontrolle wünschst, den Plugin-Pfad ganz vermeiden willst oder dein Claude-Code-Build Probleme hat, den selbst gehosteten Marketplace-Eintrag aufzulösen.
• Stapele Installationsmethoden nicht. Das häufigste kaputte Setup ist: zuerst /plugin install, danach install.sh --profile full oder npx ecc-universal install --profile full.

Falls du bereits mehrere Installationen übereinandergelegt hast und Dinge doppelt aussehen, springe direkt zu ECC zurücksetzen / deinstallieren.

Low-Context-/No-Hooks-Pfad Copy Section

Falls sich Hooks zu global anfühlen oder du nur ECCs Rules, Agents, Commands und Kern-Workflow-Skills willst, überspringe das Plugin und nutze das minimale manuelle Profil:

./install.sh --profile minimal --target claude

.\install.ps1 --profile minimal --target claude
# oder
npx ecc-universal install --profile minimal --target claude

Dieses Profil schließt hooks-runtime absichtlich aus.

Falls du das normale core-Profil willst, aber Hooks deaktiviert brauchst, verwende:

./install.sh --profile core --without baseline:hooks --target claude

Füge Hooks später nur hinzu, wenn du Laufzeit-Durchsetzung willst:

./install.sh --target claude --modules hooks-runtime

Finde zuerst die richtigen Komponenten Copy Section

Falls du nicht sicher bist, welches ECC-Profil oder welche Komponente du installieren sollst, frage den mitgelieferten Advisor aus jedem beliebigen Projekt:

npx ecc-universal consult "security reviews" --target claude

Er liefert passende Komponenten, verwandte Profile sowie Preview-/Install-Befehle zurück. Verwende den Preview-Befehl vor der Installation, falls du den exakten Dateiplan inspizieren willst.

Halte die Installation für produktive ML-/MLOps-Workflows opt-in und komponentenbezogen:

npx ecc-universal consult "mlops training model deployment" --target claude
npx ecc-universal install --profile minimal --target claude --with capability:machine-learning

Schritt 1: Plugin installieren (empfohlen) Copy Section

NOTE: Das Plugin ist bequem, aber der OSS-Installer unten ist weiterhin der zuverlässigste Pfad, falls dein Claude-Code-Build Probleme hat, selbst gehostete Marketplace-Einträge aufzulösen.

# Marketplace hinzufügen
/plugin marketplace add https://github.com/affaan-m/ECC

# Plugin installieren
/plugin install ecc@ecc

Hinweis zu Benennung + Migration Copy Section

ECC hat jetzt drei öffentliche Bezeichner, und sie sind nicht austauschbar:

• GitHub-Quell-Repo: affaan-m/ECC
• Claude-Marketplace-/Plugin-Bezeichner: ecc@ecc
• npm-Paket: ecc-universal

Das ist beabsichtigt. Anthropic-Marketplace-/Plugin-Installationen werden über einen kanonischen Plugin-Bezeichner gekeyt, daher verwendet ECC ecc@ecc, um Tool-Namen und Slash-Command-Namespaces kurz genug für strenge Desktop-/API-Validatoren zu halten. Ältere Beiträge zeigen möglicherweise noch den früheren langen Marketplace-Bezeichner; behandle diesen lediglich als Legacy-Alias. Das npm-Paket blieb davon getrennt bei ecc-universal, daher verwenden npm-Installationen und Marketplace-Installationen absichtlich unterschiedliche Namen.

Schritt 2: Rules nur installieren, wenn du sie brauchst Copy Section

WARNING: Wichtig: Claude-Code-Plugins können rules nicht automatisch verteilen.

Falls du ECC bereits über /plugin install installiert hast, führe danach nicht ./install.sh --profile full, .\install.ps1 --profile full oder npx ecc-universal install --profile full aus. Das Plugin lädt ECC-Skills, -Commands und -Hooks bereits. Wird der vollständige Installer nach einer Plugin-Installation ausgeführt, kopiert er dieselben Oberflächen in deine Benutzerverzeichnisse und kann doppelte Skills sowie doppeltes Laufzeitverhalten erzeugen.

Kopiere für Plugin-Installationen manuell nur die rules/-Verzeichnisse, die du willst, nach ~/.claude/rules/ecc/. Beginne mit rules/common plus einem Sprach- oder Framework-Paket, das du tatsächlich verwendest. Kopiere nicht jedes Rules-Verzeichnis, es sei denn, du willst diesen gesamten Kontext ausdrücklich in Claude haben.

Verwende den vollständigen Installer nur dann, wenn du eine vollständig manuelle ECC-Installation statt des Plugin-Pfads durchführst.

Falls dein lokales Claude-Setup gelöscht oder zurückgesetzt wurde, bedeutet das nicht, dass du ECC erneut kaufen musst. Beginne mit node scripts/ecc.js list-installed, führe dann node scripts/ecc.js doctor und node scripts/ecc.js repair aus, bevor du irgendetwas neu installierst. Das stellt ECC-verwaltete Dateien üblicherweise wieder her, ohne dein Setup neu aufzubauen. Falls das Problem im Konto- oder Marketplace-Zugriff für ECC Tools liegt, behandle die Konto-/Abrechnungswiederherstellung separat.

# Zuerst das Repo klonen
git clone https://github.com/affaan-m/ECC.git
cd ECC

# Abhängigkeiten installieren (wähle deinen Paketmanager)
npm install        # oder: pnpm install | yarn install | bun install

# Plugin-Installationspfad: nur ECC-Rules in einen ECC-eigenen Namespace kopieren
mkdir -p ~/.claude/rules/ecc
cp -R rules/common ~/.claude/rules/ecc/
cp -R rules/typescript ~/.claude/rules/ecc/

# Vollständig manueller ECC-Installationspfad (nutze diesen statt /plugin install)
# ./install.sh --profile full

# Windows PowerShell

# Plugin-Installationspfad: nur ECC-Rules in einen ECC-eigenen Namespace kopieren
New-Item -ItemType Directory -Force -Path "$HOME/.claude/rules/ecc" | Out-Null
Copy-Item -Recurse rules/common "$HOME/.claude/rules/ecc/"
Copy-Item -Recurse rules/typescript "$HOME/.claude/rules/ecc/"

# Vollständig manueller ECC-Installationspfad (nutze diesen statt /plugin install)
# .\install.ps1 --profile full
# npx ecc-universal install --profile full

Anweisungen zur manuellen Installation findest du in der README im rules/-Ordner. Kopiere Rules manuell stets als ganzes Sprachverzeichnis (zum Beispiel rules/common oder rules/golang), nicht die darin enthaltenen Dateien, damit relative Verweise weiterhin funktionieren und Dateinamen nicht kollidieren.

Vollständig manuelle Installation (Fallback) Copy Section

Verwende dies nur, wenn du den Plugin-Pfad absichtlich überspringst:

./install.sh --profile full

.\install.ps1 --profile full
# oder
npx ecc-universal install --profile full

Wenn du diesen Pfad wählst, höre dort auf. Führe nicht zusätzlich /plugin install aus.

ECC zurücksetzen / deinstallieren Copy Section

Falls sich ECC doppelt, aufdringlich oder kaputt anfühlt, installiere es nicht weiter über sich selbst.

• Plugin-Pfad: Entferne das Plugin aus Claude Code, lösche dann die konkreten Rule-Ordner, die du manuell unter ~/.claude/rules/ecc/ kopiert hast.
• Manueller Installer / CLI-Pfad: Sieh dir die Entfernung vom Repo-Root aus zuerst in der Vorschau an:

node scripts/uninstall.js --dry-run

Entferne anschließend ECC-verwaltete Dateien:

node scripts/uninstall.js

Du kannst auch den Lifecycle-Wrapper verwenden:

node scripts/ecc.js list-installed
node scripts/ecc.js doctor
node scripts/ecc.js repair
node scripts/ecc.js uninstall --dry-run

ECC entfernt nur Dateien, die in seinem Install-State erfasst sind. Es löscht keine fremden Dateien, die es nicht installiert hat.

Falls du Methoden gestapelt hast, räume in dieser Reihenfolge auf:

1. Entferne die Claude-Code-Plugin-Installation.
2. Führe den ECC-Uninstall-Befehl vom Repo-Root aus, um über den Install-State verwaltete Dateien zu entfernen.
3. Lösche alle zusätzlichen Rule-Ordner, die du manuell kopiert hast und nicht mehr willst.
4. Installiere einmal neu, über einen einzigen Pfad.

Schritt 3: Loslegen Copy Section

# Skills sind die primäre Workflow-Oberfläche.
# Bestehende Slash-artige Command-Namen funktionieren weiterhin, während ECC von commands/ wegmigriert.

# Die Plugin-Installation verwendet die kanonische Namespace-Form
/ecc:plan "Benutzerauthentifizierung hinzufügen"

# Die manuelle Installation behält die kürzere Slash-Form bei:
# /plan "Benutzerauthentifizierung hinzufügen"

# Verfügbare Commands prüfen
/plugin list ecc@ecc

Das war's! Du hast nun Zugriff auf 60 Agents, 232 Skills und 75 Legacy-Command-Shims.

Dashboard-GUI Copy Section

Starte das Desktop-Dashboard, um ECC-Komponenten visuell zu erkunden:

npm run dashboard
# oder
python3 ./ecc_dashboard.py

Funktionen:

• Oberfläche mit Reitern: Agents, Skills, Commands, Rules, Settings
• Umschalter für dunkles/helles Theme
• Schriftanpassung (Familie & Größe)
• Projektlogo in Kopfzeile und Taskleiste
• Suche und Filter über alle Komponenten

Multi-Modell-Befehle erfordern zusätzliches Setup Copy Section

WARNING: multi-*-Befehle sind durch die obige Basis-Plugin-/Rules-Installation nicht abgedeckt.

Um /multi-plan, /multi-execute, /multi-backend, /multi-frontend und /multi-workflow zu nutzen, musst du zusätzlich die ccg-workflow-Runtime installieren.

Initialisiere sie mit npx ccg-workflow.

Diese Runtime stellt die externen Abhängigkeiten bereit, die diese Befehle erwarten, darunter:

• ~/.claude/bin/codeagent-wrapper
• ~/.claude/.ccg/prompts/*

Ohne ccg-workflow laufen diese multi-*-Befehle nicht korrekt.

Cross-Platform-Unterstützung Copy Chapter

Dieses Plugin unterstützt nun vollständig Windows, macOS und Linux, neben enger Integration über große IDEs (Cursor, Zed, OpenCode, Antigravity) und CLI-Harnesses hinweg. Alle Hooks und Skripte wurden für maximale Kompatibilität in Node.js neu geschrieben.

Paketmanager-Erkennung Copy Section

Das Plugin erkennt deinen bevorzugten Paketmanager (npm, pnpm, yarn oder bun) automatisch mit folgender Priorität:

1. Umgebungsvariable: CLAUDE_PACKAGE_MANAGER
2. Projektkonfiguration: .claude/package-manager.json
3. package.json: Feld packageManager
4. Lock-Datei: Erkennung aus package-lock.json, yarn.lock, pnpm-lock.yaml oder bun.lockb
5. Globale Konfiguration: ~/.claude/package-manager.json
6. Fallback: Erster verfügbarer Paketmanager

So legst du deinen bevorzugten Paketmanager fest:

# Über Umgebungsvariable
export CLAUDE_PACKAGE_MANAGER=pnpm

# Über globale Konfiguration
node scripts/setup-package-manager.js --global pnpm

# Über Projektkonfiguration
node scripts/setup-package-manager.js --project bun

# Aktuelle Einstellung erkennen
node scripts/setup-package-manager.js --detect

Oder verwende den /setup-pm-Befehl in Claude Code.

Hook-Laufzeitsteuerung Copy Section

Verwende Laufzeit-Flags, um die Strenge anzupassen oder bestimmte Hooks vorübergehend zu deaktivieren:

# Hook-Strenge-Profil (Standard: standard)
export ECC_HOOK_PROFILE=standard

# Komma-getrennte Hook-IDs, die deaktiviert werden sollen
export ECC_DISABLED_HOOKS="pre:bash:tmux-reminder,post:edit:typecheck"

# Zusatzkontext bei SessionStart begrenzen (Standard: 8000 Zeichen)
export ECC_SESSION_START_MAX_CHARS=4000

# Zusatzkontext bei SessionStart für Low-Context-/lokale-Modell-Setups vollständig deaktivieren
export ECC_SESSION_START_CONTEXT=off

# Kontext-/Scope-/Loop-Warnungen behalten, aber API-Rate-Kostenschätzungen unterdrücken
export ECC_CONTEXT_MONITOR_COST_WARNINGS=off

Windows PowerShell:

[Environment]::SetEnvironmentVariable('ECC_CONTEXT_MONITOR_COST_WARNINGS', 'off', 'User')

Was ist enthalten Copy Chapter

Dieses Repo ist ein Claude-Code-Plugin - installiere es direkt oder kopiere Komponenten manuell.

/* Detailed source-code truncated for AI context efficiency. */

Ökosystem-Tools Copy Chapter

Skill Creator Copy Section

Zwei Wege, um Claude-Code-Skills aus deinem Repository zu generieren:

Option A: Lokale Analyse (eingebaut)

Verwende den /skill-create-Befehl für lokale Analyse ohne externe Dienste:

/skill-create                    # Aktuelles Repo analysieren
/skill-create --instincts        # Zusätzlich Instincts für continuous-learning-v2 generieren

Dies analysiert deine Git-Historie lokal und generiert SKILL.md-Dateien.

Option B: GitHub App (fortgeschritten)

Für fortgeschrittene Funktionen (10k+ Commits, Auto-PRs, Team-Sharing):

GitHub App installieren | ecc.tools

# Kommentiere auf einem beliebigen Issue:
/skill-creator analyze

# Oder löst automatisch bei einem Push auf den Default-Branch aus

Beide Optionen erzeugen:

• SKILL.md-Dateien - sofort einsatzbereite Skills für Claude Code
• Instinct-Sammlungen - für continuous-learning-v2
• Musterextraktion - lernt aus deiner Commit-Historie

AgentShield — Security-Auditor Copy Section

Gebaut beim Claude Code Hackathon (Cerebral Valley x Anthropic, Februar 2026). 1282 Tests, 98 % Coverage, 102 statische Analyse-Rules.

Scanne deine Claude-Code-Konfiguration auf Schwachstellen, Fehlkonfigurationen und Injection-Risiken.

# Schneller Scan (keine Installation nötig)
npx ecc-agentshield scan

# Sichere Probleme automatisch beheben
npx ecc-agentshield scan --fix

# Tiefenanalyse mit drei Opus-4.6-Agents
npx ecc-agentshield scan --opus --stream

# Sichere Konfiguration von Grund auf generieren
npx ecc-agentshield init

Was es scannt: CLAUDE.md, settings.json, MCP-Konfigurationen, Hooks, Agent-Definitionen und Skills über 5 Kategorien — Secrets-Erkennung (14 Muster), Berechtigungs-Audit, Analyse von Hook-Injection, Risikoprofilierung von MCP-Servern und Review der Agent-Konfiguration.

Das --opus-Flag führt drei Claude-Opus-4.6-Agents in einer Red-Team-/Blue-Team-/Auditor-Pipeline aus. Der Angreifer findet Exploit-Ketten, der Verteidiger bewertet die Schutzmaßnahmen, und der Auditor synthetisiert beides zu einer priorisierten Risikobewertung. Adversariales Schlussfolgern, nicht nur Mustererkennung.

Ausgabeformate: Terminal (farblich nach A-F abgestuft), JSON (CI-Pipelines), Markdown, HTML. Exit-Code 2 bei kritischen Befunden für Build-Gates.

Verwende /security-scan in Claude Code, um es auszuführen, oder füge es per GitHub Action zur CI hinzu.

GitHub | npm

Continuous Learning v2 Copy Section

Das Instinct-basierte Lernsystem lernt deine Muster automatisch:

/instinct-status        # Gelernte Instincts mit Konfidenz anzeigen
/instinct-import <file> # Instincts von anderen importieren
/instinct-export        # Eigene Instincts zum Teilen exportieren
/evolve                 # Verwandte Instincts zu Skills clustern

Die vollständige Dokumentation findest du unter skills/continuous-learning-v2/.
Behalte continuous-learning/ nur dann, wenn du den Legacy-v1-Stop-Hook-Flow für gelernte Skills ausdrücklich willst.

Voraussetzungen Copy Chapter

Version der Claude Code CLI Copy Section

Mindestversion: v2.1.0 oder neuer

Dieses Plugin erfordert die Claude Code CLI v2.1.0+ aufgrund von Änderungen daran, wie das Plugin-System Hooks verarbeitet.

Prüfe deine Version:

claude --version

Wichtig: Verhalten beim automatischen Laden von Hooks Copy Section

WARNING: Für Contributors: Füge KEIN "hooks"-Feld zu .claude-plugin/plugin.json hinzu. Das wird durch einen Regressionstest erzwungen.

Claude Code v2.1+ lädt automatisch hooks/hooks.json aus jedem installierten Plugin per Konvention. Es explizit in plugin.json zu deklarieren, verursacht einen Fehler durch Duplikaterkennung:

Duplicate hooks file detected: ./hooks/hooks.json resolves to already-loaded file

Historie: Dies hat in diesem Repo wiederholte Fix-/Revert-Zyklen verursacht (#29, #52, #103). Das Verhalten änderte sich zwischen Claude-Code-Versionen, was zu Verwirrung führte. Wir haben jetzt einen Regressionstest, der verhindert, dass dies erneut eingeführt wird.

Installation Copy Chapter

Option 1: Als Plugin installieren (empfohlen) Copy Section

Der einfachste Weg, dieses Repo zu nutzen - als Claude-Code-Plugin installieren:

# Dieses Repo als Marketplace hinzufügen
/plugin marketplace add https://github.com/affaan-m/ECC

# Das Plugin installieren
/plugin install ecc@ecc

Oder füge es direkt zu deiner ~/.claude/settings.json hinzu:

{
  "extraKnownMarketplaces": {
    "ecc": {
      "source": {
        "source": "github",
        "repo": "affaan-m/ECC"
      }
    }
  },
  "enabledPlugins": {
    "ecc@ecc": true
  }
}

Dies gibt dir sofortigen Zugriff auf alle Commands, Agents, Skills und Hooks.

Hinweis: Das Claude-Code-Plugin-System unterstützt das Verteilen von rules über Plugins nicht (Upstream-Einschränkung). Du musst Rules manuell installieren:

bash Copy

# Zuerst das Repo klonen
git clone https://github.com/affaan-m/ECC.git
cd ECC

# Option A: Rules auf Benutzerebene (gilt für alle Projekte)
mkdir -p ~/.claude/rules/ecc
cp -r rules/common ~/.claude/rules/ecc/
cp -r rules/typescript ~/.claude/rules/ecc/   # wähle deinen Stack
cp -r rules/python ~/.claude/rules/ecc/
cp -r rules/golang ~/.claude/rules/ecc/
cp -r rules/php ~/.claude/rules/ecc/

# Option B: Rules auf Projektebene (gilt nur für das aktuelle Projekt)
mkdir -p .claude/rules/ecc
cp -r rules/common .claude/rules/ecc/
cp -r rules/typescript .claude/rules/ecc/     # wähle deinen Stack

Option 2: Manuelle Installation Copy Section

Falls du manuelle Kontrolle darüber bevorzugst, was installiert wird:

# Das Repo klonen
git clone https://github.com/affaan-m/ECC.git
cd ECC

# Agents in deine Claude-Konfiguration kopieren
cp agents/*.md ~/.claude/agents/

# Rules-Verzeichnisse kopieren (common + sprachspezifisch)
mkdir -p ~/.claude/rules/ecc
cp -r rules/common ~/.claude/rules/ecc/
cp -r rules/typescript ~/.claude/rules/ecc/   # wähle deinen Stack
cp -r rules/python ~/.claude/rules/ecc/
cp -r rules/golang ~/.claude/rules/ecc/
cp -r rules/php ~/.claude/rules/ecc/
cp -r rules/arkts ~/.claude/rules/ecc/

# Zuerst Skills kopieren (primäre Workflow-Oberfläche)
# Empfohlen (neue Nutzer): nur Kern-/allgemeine Skills
mkdir -p ~/.claude/skills
cp -r .agents/skills/* ~/.claude/skills/
cp -r skills/search-first ~/.claude/skills/
# Claude Code lädt Skills nur aus direkten Unterverzeichnissen von ~/.claude/skills.
# Manuelle Installationen nicht unter ~/.claude/skills/ecc/ verschachteln.

# Optional: nischen-/framework-spezifische Skills nur bei Bedarf hinzufügen
# for s in django-patterns django-tdd laravel-patterns springboot-patterns quarkus-patterns; do
# cp -r skills/$s ~/.claude/skills/
# done

# Optional: gepflegte Slash-Command-Kompatibilität während der Migration behalten
mkdir -p ~/.claude/commands
cp commands/*.md ~/.claude/commands/

# Ausgemusterte Shims liegen in legacy-command-shims/commands/.
# Kopiere einzelne Dateien von dort nur, wenn du alte Namen wie /tdd noch brauchst.

Hooks installieren

Kopiere die rohe Repo-Datei hooks/hooks.json nicht in ~/.claude/settings.json oder ~/.claude/hooks/hooks.json. Diese Datei ist plugin-/repo-orientiert und dafür gedacht, über den ECC-Installer installiert oder als Plugin geladen zu werden, daher ist rohes Kopieren kein unterstützter manueller Installationspfad.

Verwende den Installer, um nur die Claude-Hook-Runtime zu installieren, damit Command-Pfade korrekt umgeschrieben werden:

# macOS / Linux
bash ./install.sh --target claude --modules hooks-runtime

# Windows PowerShell
pwsh -File .\install.ps1 --target claude --modules hooks-runtime

Das schreibt aufgelöste Hooks nach ~/.claude/hooks/hooks.json und lässt eine bestehende ~/.claude/settings.json unberührt.

Falls du ECC über /plugin install installiert hast, kopiere diese Hooks nicht in settings.json. Claude Code v2.1+ lädt Plugin-hooks/hooks.json bereits automatisch, und sie in settings.json zu duplizieren, verursacht doppelte Ausführung und Cross-Platform-Hook-Konflikte.

Windows-Hinweis: Das Claude-Konfigurationsverzeichnis ist %USERPROFILE%\\.claude, nicht ~/claude.

MCPs konfigurieren

Claude-Plugin-Installationen aktivieren die mitgelieferten MCP-Server-Definitionen von ECC absichtlich nicht automatisch. Das vermeidet überlange Plugin-MCP-Tool-Namen auf strengen Drittanbieter-Gateways und hält gleichzeitig das manuelle MCP-Setup verfügbar.

Verwende den /mcp-Befehl von Claude Code oder das CLI-verwaltete MCP-Setup für Live-Änderungen an Claude-Code-Servern. Verwende /mcp für Laufzeit-Deaktivierungen in Claude Code; Claude Code speichert diese Entscheidungen in ~/.claude.json.

Für repo-lokalen MCP-Zugriff kopiere die gewünschten MCP-Server-Definitionen aus mcp-configs/mcp-servers.json in eine projektbezogene .mcp.json.

Falls du bereits eigene Kopien der von ECC mitgelieferten MCPs betreibst, setze:

export ECC_DISABLED_MCPS="github,context7,exa,playwright,sequential-thinking,memory"

ECC-verwaltete Install- und Codex-Sync-Flows überspringen oder entfernen diese mitgelieferten Server, statt Duplikate erneut hinzuzufügen. ECC_DISABLED_MCPS ist ein ECC-Install-/Sync-Filter, kein Live-Toggle für Claude Code.

Wichtig: Ersetze die YOUR_*_HERE-Platzhalter durch deine tatsächlichen API-Keys.

Kernkonzepte Copy Chapter

Agents Copy Section

Subagents bearbeiten delegierte Aufgaben mit begrenztem Umfang. Beispiel:

---
name: code-reviewer
description: Reviews code for quality, security, and maintainability
tools: ["Read", "Grep", "Glob", "Bash"]
model: opus
---

You are a senior code reviewer...

Skills Copy Section

Skills sind die primäre Workflow-Oberfläche. Sie können direkt aufgerufen, automatisch vorgeschlagen und von Agents wiederverwendet werden. ECC liefert während der Migration weiterhin gepflegte commands/ aus, während ausgemusterte Kurznamen-Shims unter legacy-command-shims/ nur zur ausdrücklichen Opt-in-Nutzung liegen. Neue Workflow-Entwicklung sollte zuerst in skills/ landen.

# TDD Workflow

1. Define interfaces first
2. Write failing tests (RED)
3. Implement minimal code (GREEN)
4. Refactor (IMPROVE)
5. Verify 80%+ coverage

Hooks Copy Section

Hooks feuern bei Tool-Events. Beispiel - Warnung vor console.log:

{
  "matcher": "tool == \"Edit\" && tool_input.file_path matches \"\\\\.(ts|tsx|js|jsx)$\"",
  "hooks": [{
    "type": "command",
    "command": "#!/bin/bash\ngrep -n 'console\\.log' \"$file_path\" && echo '[Hook] Remove console.log' >&2"
  }]
}

Rules Copy Section

Rules sind stets zu befolgende Richtlinien, organisiert in common/ (sprachunabhängig) + sprachspezifische Verzeichnisse:

rules/
  common/          # Universelle Prinzipien (immer installieren)
  typescript/      # TS/JS-spezifische Patterns und Tools
  python/          # Python-spezifische Patterns und Tools
  golang/          # Go-spezifische Patterns und Tools
  swift/           # Swift-spezifische Patterns und Tools
  php/             # PHP-spezifische Patterns und Tools
  arkts/           # HarmonyOS / ArkTS-Patterns und -Beschränkungen

Details zu Installation und Struktur findest du in rules/README.md.

Welchen Agent sollte ich verwenden? Copy Chapter

Nicht sicher, wo du anfangen sollst? Verwende diese Kurzreferenz. Skills sind die kanonische Workflow-Oberfläche; gepflegte Slash-Einträge bleiben für command-first-Workflows verfügbar.

Häufige Workflows Copy Section

Die Slash-Formen unten werden dort gezeigt, wo sie Teil der gepflegten Command-Oberfläche bleiben. Ausgemusterte Kurznamen-Shims wie /tdd und /eval liegen in legacy-command-shims/ nur zur ausdrücklichen Opt-in-Nutzung.

Ein neues Feature beginnen:

/ecc:plan "Add user authentication with OAuth"
                                              → planner erstellt Implementierungs-Blueprint
tdd-workflow skill                            → tdd-guide erzwingt write-tests-first
/code-review                                  → code-reviewer prüft deine Arbeit

Einen Bug beheben:

tdd-workflow skill                            → tdd-guide: schreibe einen fehlschlagenden Test, der ihn reproduziert
                                              → implementiere den Fix, verifiziere, dass der Test besteht
/code-review                                  → code-reviewer: fängt Regressionen ab

Vorbereitung für die Produktion:

/security-scan                                → security-reviewer: OWASP-Top-10-Audit
e2e-testing skill                             → e2e-runner: Tests kritischer Benutzerflüsse
/test-coverage                                → 80 %+ Coverage verifizieren

FAQ Copy Chapter

Wie prüfe ich, welche Agents/Commands installiert sind?

/plugin list ecc@ecc

Dies zeigt alle verfügbaren Agents, Commands und Skills aus dem Plugin.

Meine Hooks funktionieren nicht / ich sehe den Fehler "Duplicate hooks file"

Das ist das häufigste Problem. Füge KEIN "hooks"-Feld zu .claude-plugin/plugin.json hinzu. Claude Code v2.1+ lädt hooks/hooks.json aus installierten Plugins automatisch. Es explizit zu deklarieren, verursacht Fehler durch Duplikaterkennung. Siehe #29, #52, #103.

Kann ich ECC mit Claude Code an einem benutzerdefinierten API-Endpoint oder Modell-Gateway verwenden?

Ja. ECC hat keine Anthropic-gehosteten Transporteinstellungen fest verdrahtet. Es läuft lokal über die normale CLI-/Plugin-Oberfläche von Claude Code, daher funktioniert es mit:

• Anthropic-gehostetem Claude Code
• Offiziellen Claude-Code-Gateway-Setups mit ANTHROPIC_BASE_URL und ANTHROPIC_AUTH_TOKEN
• Kompatiblen benutzerdefinierten Endpoints, die die von Claude Code erwartete Anthropic-API sprechen

Minimalbeispiel:

export ANTHROPIC_BASE_URL=https://your-gateway.example.com
export ANTHROPIC_AUTH_TOKEN=your-token
claude

Falls dein Gateway Modellnamen umbildet, konfiguriere das in Claude Code statt in ECC. ECCs Hooks, Skills, Commands und Rules sind modellanbieter-agnostisch, sobald die claude-CLI bereits funktioniert.

Offizielle Referenzen:

• Claude-Code-LLM-Gateway-Dokumentation
• Claude-Code-Modellkonfigurations-Dokumentation

Mein Kontextfenster schrumpft / Claude geht der Kontext aus

Zu viele MCP-Server fressen deinen Kontext. Jede MCP-Tool-Beschreibung verbraucht Token aus deinem 200k-Fenster und reduziert es möglicherweise auf ~70k. Der SessionStart-Kontext ist standardmäßig auf 8000 Zeichen begrenzt; senke ihn mit ECC_SESSION_START_MAX_CHARS=4000 oder deaktiviere ihn mit ECC_SESSION_START_CONTEXT=off für Setups mit lokalem Modell oder wenig Kontext.

Lösung: Deaktiviere ungenutzte MCPs aus Claude Code mit /mcp. Claude Code schreibt diese Laufzeitentscheidungen nach ~/.claude.json; .claude/settings.json und .claude/settings.local.json sind keine zuverlässigen Toggles für bereits geladene MCP-Server.

Halte unter 10 MCPs aktiviert und unter 80 Tools aktiv.

Kann ich nur einige Komponenten verwenden (z. B. nur Agents)?

Ja. Verwende Option 2 (manuelle Installation) und kopiere nur, was du brauchst:

# Nur Agents
cp agents/*.md ~/.claude/agents/

# Nur Rules
mkdir -p ~/.claude/rules/ecc/
cp -r rules/common ~/.claude/rules/ecc/

Jede Komponente ist vollständig unabhängig.

Funktioniert das mit Cursor / OpenCode / Codex / Antigravity / GitHub Copilot?

Ja. ECC ist Cross-Platform:

• Cursor: Vorübersetzte Konfigurationen in .cursor/. Siehe Cursor-IDE-Unterstützung.
• Gemini CLI: Experimentelle projektlokale Unterstützung über .gemini/GEMINI.md und gemeinsam genutzte Installer-Verdrahtung.
• OpenCode: Vollständige Plugin-Unterstützung in .opencode/. Siehe OpenCode-Unterstützung.
• Codex: Erstklassige Unterstützung sowohl für die macOS-App als auch die CLI, mit Adapter-Drift-Guards und SessionStart-Fallback. Siehe PR #257.
• GitHub Copilot (VS Code): Instruction- und Prompt-Schicht über .github/copilot-instructions.md, .vscode/settings.json und .github/prompts/. Siehe GitHub-Copilot-Unterstützung.
• Antigravity: Eng integriertes Setup für Workflows, Skills und abgeflachte Rules in .agents/. Siehe Antigravity-Leitfaden.
• JoyCode / CodeBuddy: Projektlokale Adapter für selektive Installation von Commands, Agents, Skills und abgeflachten Rules. Siehe JoyCode-Adapter-Leitfaden.
• Qwen CLI: Adapter für selektive Installation im Home-Verzeichnis für Commands, Agents, Skills, Rules und Qwen-Konfiguration. Siehe Qwen-CLI-Adapter-Leitfaden.
• Zed: Projektlokaler Adapter für selektive Installation von .zed/settings.json, abgeflachten Rules, Commands, Agents und Skills.
• Nicht-native Harnesses: Manueller Fallback-Pfad für Grok und ähnliche Oberflächen. Siehe Leitfaden zur manuellen Anpassung.
• Claude Code: Nativ — dies ist das primäre Ziel.

Wie steuere ich einen neuen Skill oder Agent bei?

Siehe CONTRIBUTING.md. Die Kurzfassung:

1. Forke das Repo
2. Erstelle deinen Skill in skills/your-skill-name/SKILL.md (mit YAML-Frontmatter)
3. Oder erstelle einen Agent in agents/your-agent.md
4. Reiche einen PR mit einer klaren Beschreibung ein, was er tut und wann er zu verwenden ist

Tests ausführen Copy Chapter

Das Plugin enthält eine umfassende Test-Suite:

# Alle Tests ausführen
node tests/run-all.js

# Einzelne Testdateien ausführen
node tests/lib/utils.test.js
node tests/lib/package-manager.test.js
node tests/hooks/hooks.test.js

Beitragen Copy Chapter

Beiträge sind willkommen und erwünscht.

Dieses Repo soll eine Community-Ressource sein. Falls du Folgendes hast:

• Nützliche Agents oder Skills
• Clevere Hooks
• Bessere MCP-Konfigurationen
• Verbesserte Rules

Bitte trage bei! Richtlinien findest du in CONTRIBUTING.md.

Ideen für Beiträge Copy Section

• Sprachspezifische Skills (Rust, C#, Kotlin, Java) — Go, Python, Perl, Swift, TypeScript und HarmonyOS/ArkTS sind bereits enthalten
• Framework-spezifische Konfigurationen (Rails, FastAPI) — Django, NestJS, Spring Boot und Laravel sind bereits enthalten
• DevOps-Agents (Kubernetes, Terraform, AWS, Docker)
• Teststrategien (verschiedene Frameworks, visuelle Regression)
• Domänenspezifisches Wissen (ML, Data Engineering, Mobile)

Hinweise zum Community-Ökosystem Copy Section

Diese werden nicht mit ECC mitgeliefert und nicht von diesem Repo auditiert, aber sie sind wissenswert, falls du das breitere Claude-Code-Skills-Ökosystem erkundest:

• claude-seo — SEO-fokussierte Skill- und Agent-Sammlung
• claude-ads — Sammlung von Ad-Audit- und Paid-Growth-Workflows
• claude-cybersecurity — sicherheitsorientierte Skill- und Agent-Sammlung

Cursor-IDE-Unterstützung Copy Chapter

ECC bietet Cursor-IDE-Unterstützung mit Hooks, Rules, Agents, Skills, Commands und MCP-Konfigurationen, die an Cursors Projektlayout angepasst sind.

Schnellstart (Cursor) Copy Section

# macOS/Linux
./install.sh --target cursor typescript
./install.sh --target cursor python golang swift php

# Windows PowerShell
.\install.ps1 --target cursor typescript
.\install.ps1 --target cursor python golang swift php

Was ist enthalten Copy Section

Hinweise zum Laden in Cursor Copy Section

ECC installiert keine Root-AGENTS.md in .cursor/. Cursor behandelt verschachtelte AGENTS.md-Dateien als Verzeichniskontext, daher würde das Kopieren von ECCs Repo-Identität in ein Host-Projekt dieses Projekt verunreinigen.

Das Cursor-native Ladeverhalten kann je nach Cursor-Build variieren. ECC installiert Agents als .cursor/agents/ecc-*.md; falls dein Cursor-Build keine Projekt-Agents bereitstellt, funktionieren diese Dateien weiterhin als explizite Referenzdefinitionen statt als versteckter globaler Prompt-Kontext.

Hook-Architektur (DRY-Adapter-Muster) Copy Section

Cursor hat mehr Hook-Events als Claude Code (20 vs. 8). Das Modul .cursor/hooks/adapter.js transformiert Cursors stdin-JSON in das Format von Claude Code und erlaubt so die Wiederverwendung bestehender scripts/hooks/*.js ohne Duplizierung.

Cursor stdin JSON → adapter.js → transforms → scripts/hooks/*.js
                                              (shared with Claude Code)

Wichtige Hooks:

• beforeShellExecution — Blockiert Dev-Server außerhalb von tmux (exit 2), git-push-Review
• afterFileEdit — Auto-Formatierung + TypeScript-Prüfung + console.log-Warnung
• beforeSubmitPrompt — Erkennt Secrets (sk-, ghp_, AKIA-Muster) in Prompts
• beforeTabFileRead — Blockiert, dass Tab .env-, .key-, .pem-Dateien liest (exit 2)
• beforeMCPExecution / afterMCPExecution — MCP-Audit-Logging

Rules-Format Copy Section

Cursor-Rules verwenden YAML-Frontmatter mit description, globs und alwaysApply:

---
description: "TypeScript coding style extending common rules"
globs: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"]
alwaysApply: false
---

Codex-macOS-App- + CLI-Unterstützung Copy Chapter

ECC bietet erstklassige Codex-Unterstützung sowohl für die macOS-App als auch die CLI, mit einer Referenzkonfiguration, einem Codex-spezifischen AGENTS.md-Zusatz und gemeinsam genutzten Skills.

Schnellstart (Codex-App + CLI) Copy Section

# Codex CLI im Repo ausführen — AGENTS.md und .codex/ werden automatisch erkannt
codex

# Automatisches Setup: ECC-Assets (AGENTS.md, Skills, MCP-Server) nach ~/.codex synchronisieren
npm install && bash scripts/sync-ecc-to-codex.sh
# oder: pnpm install && bash scripts/sync-ecc-to-codex.sh
# oder: yarn install && bash scripts/sync-ecc-to-codex.sh
# oder: bun install && bash scripts/sync-ecc-to-codex.sh

# Oder manuell: die Referenzkonfiguration in dein Home-Verzeichnis kopieren
cp .codex/config.toml ~/.codex/config.toml

Das Sync-Skript merged ECC-MCP-Server sicher in deine bestehende ~/.codex/config.toml mit einer add-only-Strategie — es entfernt oder verändert deine bestehenden Server nie. Führe es mit --dry-run aus, um Änderungen in der Vorschau zu sehen, oder mit --update-mcp, um ein erzwungenes Refresh der ECC-Server auf die neueste empfohlene Konfiguration zu erzwingen.

Für Context7 verwendet ECC den kanonischen Codex-Abschnittsnamen [mcp_servers.context7], startet aber weiterhin das Paket @upstash/context7-mcp. Falls du bereits einen veralteten [mcp_servers.context7-mcp]-Eintrag hast, migriert --update-mcp ihn auf den kanonischen Abschnittsnamen.

Codex-macOS-App:

• Öffne dieses Repository als deinen Workspace.
• Die Root-AGENTS.md wird automatisch erkannt.
• .codex/config.toml und .codex/agents/*.toml funktionieren am besten, wenn sie projektlokal gehalten werden.
• Die Referenz-.codex/config.toml pinnt model oder model_provider absichtlich nicht, sodass Codex seine eigene aktuelle Voreinstellung verwendet, sofern du sie nicht überschreibst.
• Optional: Kopiere .codex/config.toml nach ~/.codex/config.toml für globale Voreinstellungen; halte die Multi-Agent-Rollendateien projektlokal, sofern du nicht auch .codex/agents/ kopierst.

Was ist enthalten Copy Section

Skills Copy Section

Skills unter .agents/skills/ werden von Codex automatisch geladen:

Kanonische Anthropic-Skills wie claude-api, frontend-design und skill-creator werden hier absichtlich nicht erneut mitgeliefert. Installiere diese aus anthropics/skills, wenn du die offiziellen Versionen willst.

Wesentliche Einschränkung Copy Section

Codex bietet noch keine Claude-artige Parität bei der Hook-Ausführung. Die ECC-Durchsetzung dort ist instruction-basiert über AGENTS.md, optionale model_instructions_file-Overrides sowie Sandbox-/Approval-Einstellungen.

Multi-Agent-Unterstützung Copy Section

Aktuelle Codex-Builds unterstützen stabile Multi-Agent-Workflows.

• Aktiviere features.multi_agent = true in .codex/config.toml
• Definiere Rollen unter [agents.<name>]
• Verweise jede Rolle auf eine Datei unter .codex/agents/
• Verwende /agent in der CLI, um Kind-Agents zu inspizieren oder zu steuern

ECC liefert drei Beispiel-Rollenkonfigurationen aus:

Zed-Unterstützung Copy Chapter

ECC bietet Zed-Projektunterstützung über einen konservativen .zed-Adapter für projektlokale Einstellungen, abgeflachte Rules, Agents, Commands und Skills.

./install.sh --profile minimal --target zed

.\install.ps1 --profile minimal --target zed

Der Adapter schreibt ECC-verwaltete Dateien unter .zed/ und hält BYOK-/OpenRouter-Credentials aus dem Repo heraus. Konfiguriere das Zed-Konto oder API-Keys über Zeds eigene Einstellungs-UI oder deine lokalen Benutzereinstellungen.

OpenCode-Unterstützung Copy Chapter

ECC bietet vollständige OpenCode-Unterstützung einschließlich Plugins und Hooks.

Schnellstart Copy Section

# OpenCode installieren
npm install opencode

# Im Repository-Root ausführen
opencode

Die Konfiguration wird automatisch aus .opencode/opencode.json erkannt.

Feature-Parität Copy Section

Hook-Unterstützung über Plugins Copy Section

Das Plugin-System von OpenCode ist AUSGEFEILTER als das von Claude Code mit 20+ Event-Typen:

Zusätzliche OpenCode-Events: file.edited, file.watcher.updated, message.updated, lsp.client.diagnostics, tui.toast.show und mehr.

Gepflegte Slash-Einträge Copy Section

Plugin-Installation Copy Section

Option 1: Direkt verwenden

cd ECC
opencode

Option 2: Als npm-Paket installieren

npm install ecc-universal

Füge es dann zu deiner opencode.json hinzu:

{
  "plugin": ["ecc-universal"]
}

Dieser npm-Plugin-Eintrag aktiviert ECCs veröffentlichtes OpenCode-Plugin-Modul (Hooks/Events und Plugin-Tools).
Er fügt nicht automatisch ECCs vollständigen Command-/Agent-/Instruction-Katalog zu deiner Projektkonfiguration hinzu.

Für das vollständige ECC-OpenCode-Setup entweder:

• OpenCode innerhalb dieses Repositorys ausführen, oder
• die mitgelieferten .opencode/-Konfigurations-Assets in dein Projekt kopieren und die instructions-, agent- und command-Einträge in opencode.json verdrahten

Dokumentation Copy Section

• Migrationsleitfaden: .opencode/MIGRATION.md
• OpenCode-Plugin-README: .opencode/README.md
• Konsolidierte Rules: .opencode/instructions/INSTRUCTIONS.md
• LLM-Dokumentation: llms.txt (vollständige OpenCode-Dokumentation für LLMs)

GitHub-Copilot-Unterstützung Copy Chapter

ECC bietet GitHub-Copilot-Unterstützung für VS Code über das native Instruction- und Prompt-Datei-System von Copilot Chat — kein zusätzliches Tooling erforderlich.

Was ist enthalten Copy Section

Schnellstart (GitHub Copilot) Copy Section

Die Dateien sind bereits vorhanden — öffne ein beliebiges Repo, das dieses Projekt enthält, und GitHub Copilot Chat nimmt .github/copilot-instructions.md automatisch auf.
Die eingecheckte .vscode/settings.json aktiviert chat.promptFiles, sodass VS Code die wiederverwendbaren Prompts aus .github/prompts/ laden kann.

So verwendest du die Workflow-Prompts in Copilot Chat:

1. Öffne das Copilot-Chat-Panel in VS Code.
2. Klicke auf das Büroklammer-/Anhängen-Symbol und wähle Prompt..., oder tippe / und wähle einen Prompt.
3. Wähle den Prompt aus (z. B. plan, tdd, security-review).

Wie es funktioniert Copy Section

GitHub Copilot in VS Code liest zwei Dateitypen automatisch:

• .github/copilot-instructions.md — Instructions auf Repository-Ebene, die in jede Copilot-Chat-Anfrage injiziert werden. Enthält ECCs Kern-Coding-Standards, Sicherheits-Checkliste, Testanforderungen und Git-Workflow.
• .github/prompts/*.prompt.md — wiederverwendbare Prompt-Dateien, die Nutzer bei Bedarf aufrufen. Jeder Prompt führt Copilot durch einen bestimmten ECC-Workflow wie Planung, TDD, Security-Review, Build-Fix oder Refactor.

Die .vscode/settings.json fügt aufgabenspezifische Instruction-Overlays hinzu, sodass Copilot für Codegenerierung, Testgenerierung und Commit-Nachrichten den richtigen Kontext erhält.

Feature-Abdeckung Copy Section

Einschränkungen Copy Section

GitHub Copilot hat kein Hook-System und keine Subagent-API, daher sind ECCs Hook-Automatisierungen (Auto-Formatierung, TypeScript-Prüfung, Session-Persistenz, Dev-Server-Guard) sowie die Agent-Delegation nicht verfügbar. Die Instruction- und Prompt-Schicht bringt dennoch die vollständige ECC-Coding-Philosophie — Standards, Sicherheit, TDD und Workflow — in jede Copilot-Chat-Session.

Cross-Tool-Feature-Parität Copy Chapter

ECC ist das erste Plugin, das jedes große KI-Coding-Tool ausreizt. So vergleicht sich jeder Harness:

Wesentliche architektonische Entscheidungen:

• AGENTS.md im Root ist die universelle Cross-Tool-Datei (gelesen von Claude Code, Cursor, Codex und OpenCode — GitHub Copilot verwendet stattdessen .github/copilot-instructions.md)
• Das DRY-Adapter-Muster lässt Cursor die Hook-Skripte von Claude Code ohne Duplizierung wiederverwenden
• Das Skills-Format (SKILL.md mit YAML-Frontmatter) funktioniert über Claude Code, Codex und OpenCode hinweg
• Codex' fehlende Hooks werden durch AGENTS.md, optionale model_instructions_file-Overrides und Sandbox-Berechtigungen kompensiert

Hintergrund Copy Chapter

Ich nutze Claude Code seit dem experimentellen Rollout. Habe im September 2025 den Anthropic-x-Forum-Ventures-Hackathon mit @DRodriguezFX gewonnen — zenith.chat wurde vollständig mit Claude Code gebaut.

Diese Konfigurationen sind über mehrere produktive Anwendungen hinweg im Praxiseinsatz erprobt.

Token-Optimierung Copy Chapter

Die Nutzung von Claude Code kann teuer werden, wenn du den Token-Verbrauch nicht steuerst. Diese Einstellungen senken die Kosten erheblich, ohne die Qualität zu opfern.

Empfohlene Einstellungen Copy Section

Füge zu ~/.claude/settings.json hinzu:

{
  "model": "sonnet",
  "env": {
    "MAX_THINKING_TOKENS": "10000",
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50"
  }
}

Wechsle nur dann zu Opus, wenn du tiefes architektonisches Schlussfolgern brauchst:

/model opus

Befehle für den Arbeitsalltag Copy Section

Falls du ein Claude-Abonnement nutzt und die API-Rate-Schätzungen des Kontext-Monitors nicht nützlich sind, setze ECC_CONTEXT_MONITOR_COST_WARNINGS=off. Das unterdrückt nur die agentenseitigen Kostenwarnungen; es deaktiviert keine Warnungen zu Kontexterschöpfung, Scope oder Loops.

Strategische Compaction Copy Section

Der strategic-compact-Skill (in diesem Plugin enthalten) schlägt /compact an logischen Bruchstellen vor, statt sich auf die Auto-Compaction bei 95 % Kontext zu verlassen. Den vollständigen Entscheidungsleitfaden findest du in skills/strategic-compact/SKILL.md.

Wann kompaktieren:

• Nach Recherche/Erkundung, vor der Implementierung
• Nach Abschluss eines Meilensteins, vor Beginn des nächsten
• Nach dem Debugging, vor der Fortsetzung der Feature-Arbeit
• Nach einem gescheiterten Ansatz, vor dem Versuch eines neuen

Wann NICHT kompaktieren:

• Mitten in der Implementierung (du verlierst Variablennamen, Dateipfade, partiellen Zustand)

Kontextfenster-Verwaltung Copy Section

Kritisch: Aktiviere nicht alle MCPs auf einmal. Jede MCP-Tool-Beschreibung verbraucht Token aus deinem 200k-Fenster und reduziert es möglicherweise auf ~70k.

• Halte unter 10 MCPs pro Projekt aktiviert
• Halte unter 80 Tools aktiv
• Verwende /mcp, um ungenutzte Claude-Code-MCP-Server zu deaktivieren; diese Laufzeitentscheidungen bleiben in ~/.claude.json erhalten
• Verwende ECC_DISABLED_MCPS nur, um ECC-generierte MCP-Konfigurationen während der Install-/Sync-Flows zu filtern

Kostenwarnung zu Agent-Teams Copy Section

Agent-Teams erzeugen mehrere Kontextfenster. Jeder Teammate verbraucht Token unabhängig. Verwende sie nur für Aufgaben, bei denen Parallelität einen klaren Mehrwert bietet (Arbeit über mehrere Module, parallele Reviews). Für einfache sequentielle Aufgaben sind Subagents token-effizienter.

WARNING: Wichtige Hinweise Copy Chapter

Token-Optimierung Copy Section

Erreichst du die Tageslimits? Siehe den Token-Optimierungs-Leitfaden für empfohlene Einstellungen und Workflow-Tipps.

Schnelle Gewinne:

// ~/.claude/settings.json
{
  "model": "sonnet",
  "env": {
    "MAX_THINKING_TOKENS": "10000",
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50",
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku"
  }
}

Verwende /clear zwischen voneinander unabhängigen Aufgaben, /compact an logischen Bruchstellen und /cost, um die Ausgaben zu überwachen.

Anpassung Copy Section

Diese Konfigurationen funktionieren für meinen Workflow. Du solltest:

1. Mit dem beginnen, was dich anspricht
2. Für deinen Stack anpassen
3. Entfernen, was du nicht nutzt
4. Eigene Patterns hinzufügen

Community-Projekte Copy Chapter

Projekte, die auf ECC aufbauen oder davon inspiriert sind:

Etwas mit ECC gebaut? Öffne einen PR, um es hier hinzuzufügen.

Sponsoren Copy Chapter

Dieses Projekt ist kostenlos und Open Source. Sponsoren helfen, es gepflegt und wachsend zu halten.

Sponsor werden | Sponsor-Stufen | Sponsoring-Programm

Star-Verlauf Copy Chapter

Links Copy Chapter

• Kurzleitfaden (Hier starten): The Shorthand Guide to ECC
• Langleitfaden (fortgeschritten): The Longform Guide to ECC
• Security-Leitfaden: Security-Leitfaden | Thread
• Folgen: @affaanmustafa

Lizenz Copy Chapter

MIT - Frei verwenden, nach Bedarf anpassen, zurückgeben, wenn du kannst.

Vergib einen Star für dieses Repo, falls es hilft. Lies beide Leitfäden. Bau etwas Großartiges.

Es README (`docs/es/README.md`) Copy Section

Idioma: English | Português (Brasil) | 简体中文 | 繁體中文 | 日本語 | 한국어 | Türkçe | Русский | Tiếng Việt | ไทย | Deutsch | Español | Українська | Polski | বাংলা | العربية

ECC

182K+ estrellas | 28K+ forks | 170+ contribuidores | 12+ ecosistemas de lenguajes | Flujos de trabajo de agentes multi-harness

El sistema operativo nativo del harness para trabajo agentivo. Construido a partir de flujos de trabajo de ingeniería multi-harness del mundo real.

No son solo configuraciones. Es un sistema completo: skills, instintos, optimización de memoria, aprendizaje continuo, análisis de seguridad y desarrollo orientado a la investigación. Agentes listos para producción, skills, hooks, reglas, configuraciones de MCP y comandos legados, evolucionados durante más de 10 meses de uso diario intensivo construyendo productos reales.

Funciona en Codex, Claude Code, Cursor, OpenCode, Gemini, Zed, GitHub Copilot y otros harnesses de agentes de IA.

ECC v2.0.0-rc.1 añade la historia pública del operador Hermes sobre esa capa reutilizable: comienza con la guía de configuración de Hermes, luego revisa las notas de la versión rc.1 y la arquitectura multi-harness.

| ** ECC Pro**
Repos privados · GitHub App · $19/asiento/mes | ** Patrocinar**
Financia el OSS · Desde $5/mes | Comunidad

Discusiones · Preguntas · Showcase | ** GitHub App**
Instalar · Auditorías de PR · Tier gratuito |

| --- | --- | --- | --- |

_{El OSS es gratis para siempre. Este repositorio tiene licencia MIT permanente. ECC Pro es la GitHub App alojada para repositorios privados. Los patrocinadores y los suscriptores Pro financian el trabajo — por eso un solo mantenedor publica semanalmente en 7 harnesses.}

Las Guías Copy Chapter

Este repositorio contiene solo el código. Las guías explican todo.

Novedades Copy Chapter

v2.0.0-rc.1 — Actualización de Superficie, Flujos de Trabajo de Operador y Alpha de ECC 2.0 (Abr 2026) Copy Section

• Dashboard GUI — Nueva aplicación de escritorio basada en Tkinter (ecc_dashboard.py o npm run dashboard) con alternancia de tema oscuro/claro, personalización de fuente y logo del proyecto en el encabezado y la barra de tareas.
• Superficie pública sincronizada con el repo en vivo — metadatos, conteos del catálogo, manifiestos de plugins y documentación de instalación ahora coinciden con la superficie OSS real: 63 agentes, 249 skills y 79 shims de comandos legados.
• Expansión de flujos de trabajo de operador y salida — brand-voice, social-graph-ranker, connections-optimizer, customer-billing-ops, ecc-tools-cost-audit, google-workspace-ops, project-flow-ops y workspace-surface-audit completan el carril de operador.
• Herramientas de medios y lanzamiento — manim-video, remotion-video-creation y superficies de publicación social actualizadas integran la creación de contenido técnico y de lanzamiento en el mismo sistema.
• Crecimiento de frameworks y productos — nestjs-patterns, superficies de instalación más ricas para Codex/OpenCode y empaquetado cross-harness expandido mantienen el repo utilizable más allá de Claude Code.
• Pack de skills de mercados de predicción Itô — la skill consolidada ito-baskets (índice de cestas de solo lectura, comparación, briefs de mercado y hojas de planificación no ejecutables; reemplaza a las antiguas ito-market-intelligence, ito-basket-compare, ito-trade-planner y ito-data-atlas-agent), junto con prediction-market-oracle-research y prediction-market-risk-review, añaden flujos de trabajo públicos de mercado/cesta no asesorados, manteniendo el acceso a la API de Itô separado de la facturación de ECC Tools.
• Pack de skills de optimización — parallel-execution-optimizer, benchmark-optimization-loop, data-throughput-accelerator, latency-critical-systems y recursive-decision-ledger convierten los prompts de velocidad/recursión repetidos en flujos de trabajo acotados de benchmark, rendimiento y decisiones.
• ECC 2.0 alpha incluido en el árbol — el prototipo del plano de control en Rust en ecc2/ ya compila localmente y expone los comandos dashboard, start, sessions, status, stop, resume y daemon. Está disponible como alpha, aún no como versión general.
• Instantáneas de estado del operador — ecc status --markdown --write status.md convierte el almacén de estado local en un informe portátil de transferencia que cubre disponibilidad, sesiones activas, estado de ejecución de skills, estado de la instalación, eventos de gobernanza pendientes y elementos de trabajo vinculados de Linear/GitHub/transferencias. Usa ecc work-items upsert ... para entradas manuales, ecc work-items sync-github --repo owner/repo para el estado de la cola de PRs/issues, y ecc status --exit-code para hacer fallar la automatización cuando la disponibilidad requiere atención.
• Hardening del ecosistema — AgentShield, controles de costos de ECC Tools, trabajo en el portal de facturación y actualizaciones del sitio web continúan publicándose junto al plugin principal en lugar de desviarse hacia silos separados.

v1.9.0 — Instalación Selectiva y Expansión de Lenguajes (Mar 2026) Copy Section

• Arquitectura de instalación selectiva — Pipeline de instalación basado en manifiestos con install-plan.js e install-apply.js para instalación de componentes específicos. El almacén de estado rastrea lo instalado y permite actualizaciones incrementales.
• 6 nuevos agentes — typescript-reviewer, pytorch-build-resolver, java-build-resolver, java-reviewer, kotlin-reviewer, kotlin-build-resolver amplían la cobertura de lenguajes a 10 idiomas de programación.
• Nuevas skills — pytorch-patterns para flujos de trabajo de aprendizaje profundo, documentation-lookup para investigación de referencias de API, bun-runtime y nextjs-turbopack para toolchains modernas de JS, además de 8 skills de dominio operacional y mcp-server-patterns.
• Infraestructura de sesiones y estado — Almacén de estado SQLite con CLI de consultas, adaptadores de sesión para grabación estructurada, base para la evolución de skills auto-mejorables.
• Revisión de orquestación — Puntuación de auditoría del harness hecha determinista, estado de orquestación y compatibilidad del lanzador reforzados, prevención de bucles de observador con guardia de 5 capas.
• Confiabilidad del observador — Corrección de explosión de memoria con throttling y muestreo de cola, corrección de acceso a sandbox, lógica de inicio diferido y guardia de reentrada.
• 12 ecosistemas de lenguajes — Nuevas reglas para Java, PHP, Perl, Kotlin/Android/KMP, C++ y Rust se suman a TypeScript, Python, Go y reglas comunes existentes.
• Contribuciones de la comunidad — Traducciones al coreano y chino, optimización de hooks de biome, skills de procesamiento de video, skills operacionales, instalador de PowerShell, soporte para Antigravity IDE.
• Hardening de CI — 19 correcciones de fallos en pruebas, aplicación de conteos del catálogo, validación del manifiesto de instalación y suite de pruebas completa en verde.

v1.8.0 — Sistema de Rendimiento del Harness (Mar 2026) Copy Section

• Primera versión centrada en el harness — ECC ahora se enmarca explícitamente como un sistema de rendimiento del harness de agentes, no solo un paquete de configuración.
• Revisión de la confiabilidad de hooks — Fallback de raíz en SessionStart, resúmenes de sesión en la fase Stop y hooks basados en scripts que reemplazan frágiles one-liners en línea.
• Controles de ejecución de hooks — ECC_HOOK_PROFILE=minimal|standard|strict y ECC_DISABLED_HOOKS=... para control en tiempo de ejecución sin editar los archivos de hooks.
• Nuevos comandos del harness — /harness-audit, /loop-start, /loop-status, /quality-gate, /model-route.
• NanoClaw v2 — enrutamiento de modelos, carga en caliente de skills, rama/búsqueda/exportación/compactación/métricas de sesión.
• Paridad cross-harness — comportamiento ajustado entre Claude Code, Cursor, OpenCode y Codex app/CLI.
• 997 pruebas internas pasando — suite completa en verde tras la refactorización de hooks/runtime y actualizaciones de compatibilidad.

v1.7.0 — Expansión Multiplataforma y Constructor de Presentaciones (Feb 2026) Copy Section

• Soporte para Codex app + CLI — Soporte directo de Codex basado en AGENTS.md, targeting del instalador y documentación de Codex
• Skill frontend-slides — Constructor de presentaciones HTML sin dependencias con guía de conversión a PPTX y reglas estrictas de ajuste al viewport
• 5 nuevas skills genéricas de negocio/contenido — article-writing, content-engine, market-research, investor-materials, investor-outreach
• Mayor cobertura de herramientas — Soporte para Cursor, Codex y OpenCode reforzado para que el mismo repo funcione limpiamente en todos los harnesses principales
• 992 pruebas internas — Validación y cobertura de regresión ampliadas en plugin, hooks, skills y empaquetado

v1.6.0 — Codex CLI, AgentShield y Marketplace (Feb 2026) Copy Section

• Soporte para Codex CLI — Nuevo comando /codex-setup que genera codex.md para compatibilidad con OpenAI Codex CLI
• 7 nuevas skills — search-first, swift-actor-persistence, swift-protocol-di-testing, regex-vs-llm-structured-text, content-hash-cache-pattern, cost-aware-llm-pipeline, skill-stocktake
• Integración de AgentShield — La skill /security-scan ejecuta AgentShield directamente desde Claude Code; 1282 pruebas, 102 reglas
• GitHub Marketplace — La GitHub App ECC Tools disponible en github.com/marketplace/ecc-tools con niveles gratuito/pro/empresarial
• Más de 30 PRs de la comunidad fusionados — Contribuciones de 30 colaboradores en 6 lenguajes
• 978 pruebas internas — Suite de validación ampliada en agentes, skills, comandos, hooks y reglas

v1.4.1 — Corrección de Errores (Feb 2026) Copy Section

• Corrección de pérdida de contenido en importación de instintos — parse_instinct_file() descartaba silenciosamente todo el contenido tras el frontmatter (secciones Action, Evidence, Examples) durante /instinct-import. (#148, #161)

v1.4.0 — Reglas Multi-Lenguaje, Asistente de Instalación y PM2 (Feb 2026) Copy Section

• Asistente de instalación interactivo — La nueva skill configure-ecc proporciona configuración guiada con detección de fusión/sobrescritura
• PM2 y orquestación multi-agente — 6 nuevos comandos (/pm2, /multi-plan, /multi-execute, /multi-backend, /multi-frontend, /multi-workflow) para gestionar flujos de trabajo complejos multi-servicio
• Arquitectura de reglas multi-lenguaje — Reglas reestructuradas de archivos planos en directorios common/ + typescript/ + python/ + golang/. Instala solo los lenguajes que necesitas
• Traducciones al chino (zh-CN) — Traducción completa de todos los agentes, comandos, skills y reglas (más de 80 archivos)
• Soporte de GitHub Sponsors — Patrocina el proyecto a través de GitHub Sponsors
• CONTRIBUTING.md mejorado — Plantillas detalladas de PR para cada tipo de contribución

v1.3.0 — Soporte para Plugin de OpenCode (Feb 2026) Copy Section

• Integración completa con OpenCode — 12 agentes, 24 comandos, 16 skills con soporte de hooks mediante el sistema de plugins de OpenCode (más de 20 tipos de eventos)
• 3 herramientas personalizadas nativas — run-tests, check-coverage, security-audit
• Documentación para LLM — llms.txt con documentación completa de OpenCode

v1.2.0 — Comandos y Skills Unificados (Feb 2026) Copy Section

• Soporte para Python/Django — Skills de patrones de Django, seguridad, TDD y verificación
• Skills para Java Spring Boot — Patrones, seguridad, TDD y verificación para Spring Boot
• Gestión de sesiones — Comando /sessions para historial de sesiones
• Aprendizaje continuo v2 — Aprendizaje basado en instintos con puntuación de confianza, importación/exportación y evolución

Consulta el changelog completo en Releases.

Inicio Rápido Copy Chapter

Empieza a trabajar en menos de 2 minutos:

Elige solo un camino Copy Section

La mayoría de los usuarios de Claude Code deben usar exactamente un método de instalación:

• Opción recomendada por defecto: instala el plugin de Claude Code, luego copia solo las carpetas de reglas que realmente necesites.
• Usa el instalador manual solo si quieres un control más granular, deseas evitar completamente la ruta del plugin o tu build de Claude Code tiene problemas para resolver la entrada del marketplace autoalojado.
• No combines métodos de instalación. La configuración rota más común es: /plugin install primero, luego install.sh --profile full o npx ecc-universal install --profile full después.

Si ya combinaste múltiples instalaciones y hay duplicados, salta directamente a Restablecer / Desinstalar ECC.

Ruta sin contexto / sin hooks Copy Section

Si los hooks te parecen demasiado globales o solo quieres las reglas, agentes, comandos y skills principales de ECC, omite el plugin y usa el perfil manual mínimo:

./install.sh --profile minimal --target claude

.\install.ps1 --profile minimal --target claude
# o
npx ecc-universal install --profile minimal --target claude

Este perfil excluye intencionalmente hooks-runtime.

Si quieres el perfil core normal pero necesitas desactivar los hooks, usa:

./install.sh --profile core --without baseline:hooks --target claude

Añade hooks después solo si quieres aplicación en tiempo de ejecución:

./install.sh --target claude --modules hooks-runtime

Encuentra primero los componentes correctos Copy Section

Si no estás seguro de qué perfil o componente de ECC instalar, consulta al asesor empaquetado desde cualquier proyecto:

npx ecc-universal consult "security reviews" --target claude

Devuelve los componentes coincidentes, los perfiles relacionados y los comandos de vista previa/instalación. Usa el comando de vista previa antes de instalar si quieres inspeccionar el plan de archivos exacto.

Para flujos de trabajo de ML/MLOps en producción, mantén la instalación opt-in y con alcance de componentes:

npx ecc-universal consult "mlops training model deployment" --target claude
npx ecc-universal install --profile minimal --target claude --with capability:machine-learning

Paso 1: Instalar el Plugin (Recomendado) Copy Section

NOTA: El plugin es conveniente, pero el instalador OSS de abajo sigue siendo la ruta más confiable si tu build de Claude Code tiene problemas para resolver entradas del marketplace autoalojado.

# Agregar marketplace
/plugin marketplace add https://github.com/affaan-m/ECC

# Instalar plugin
/plugin install ecc@ecc

Nota de Nombres y Migración Copy Section

ECC tiene tres identificadores públicos que no son intercambiables:

• Repositorio fuente de GitHub: affaan-m/ECC
• Identificador de marketplace/plugin de Claude: ecc@ecc
• Paquete npm: ecc-universal

Esto es intencional. Las instalaciones del marketplace/plugin de Anthropic se identifican por un identificador de plugin canónico, por lo que ECC usa ecc@ecc para mantener los nombres de herramientas y los espacios de nombres de comandos slash lo suficientemente cortos para los validadores estrictos de Desktop/API. Las publicaciones antiguas pueden mostrar el anterior identificador largo del marketplace; trátalo solo como un alias heredado. Por su parte, el paquete npm se mantuvo en ecc-universal, por lo que las instalaciones de npm y las del marketplace usan intencionalmente nombres diferentes.

Paso 2: Instalar Reglas Solo Si Las Necesitas Copy Section

ADVERTENCIA: Importante: Los plugins de Claude Code no pueden distribuir rules automáticamente.

Si ya instalaste ECC mediante /plugin install, no ejecutes ./install.sh --profile full, .\install.ps1 --profile full, ni npx ecc-universal install --profile full después. El plugin ya carga las skills, comandos y hooks de ECC. Ejecutar el instalador completo tras una instalación del plugin copia esas mismas superficies en tus directorios de usuario y puede crear skills duplicadas más comportamiento duplicado en tiempo de ejecución.

Para instalaciones de plugin, copia manualmente solo los directorios rules/ que quieras bajo ~/.claude/rules/ecc/. Empieza con rules/common más un pack de lenguaje o framework que uses realmente. No copies todos los directorios de reglas a menos que quieras explícitamente todo ese contexto en Claude.

Usa el instalador completo solo cuando hagas una instalación completamente manual de ECC en lugar de la ruta del plugin.

Si tu configuración local de Claude fue eliminada o restablecida, eso no significa que necesites volver a comprar ECC. Empieza con node scripts/ecc.js list-installed, luego ejecuta node scripts/ecc.js doctor y node scripts/ecc.js repair antes de reinstalar cualquier cosa. Eso generalmente restaura los archivos gestionados por ECC sin reconstruir tu configuración. Si el problema es el acceso a la cuenta o al marketplace para ECC Tools, gestiona la recuperación de la facturación/cuenta por separado.

# Clonar el repo primero
git clone https://github.com/affaan-m/ECC.git
cd ECC

# Instalar dependencias (elige tu gestor de paquetes)
npm install        # o: pnpm install | yarn install | bun install

# Ruta de plugin: copiar solo las reglas de ECC en un espacio de nombres propio
mkdir -p ~/.claude/rules/ecc
cp -R rules/common ~/.claude/rules/ecc/
cp -R rules/typescript ~/.claude/rules/ecc/

# Ruta de instalación completamente manual (usa esto en lugar de /plugin install)
# ./install.sh --profile full

# Windows PowerShell

# Ruta de plugin: copiar solo las reglas de ECC en un espacio de nombres propio
New-Item -ItemType Directory -Force -Path "$HOME/.claude/rules/ecc" | Out-Null
Copy-Item -Recurse rules/common "$HOME/.claude/rules/ecc/"
Copy-Item -Recurse rules/typescript "$HOME/.claude/rules/ecc/"

# Ruta de instalación completamente manual (usa esto en lugar de /plugin install)
# .\install.ps1 --profile full
# npx ecc-universal install --profile full

Para instrucciones de instalación manual consulta el README en la carpeta rules/. Al copiar reglas manualmente, copia el directorio completo del lenguaje (por ejemplo rules/common o rules/golang), no los archivos dentro de él, para que las referencias relativas sigan funcionando y los nombres de archivo no colisionen.

Instalación completamente manual (Alternativa) Copy Section

Usa esto solo si estás omitiendo intencionalmente la ruta del plugin:

./install.sh --profile full

.\install.ps1 --profile full
# o
npx ecc-universal install --profile full

Si eliges esta ruta, detente aquí. No ejecutes también /plugin install.

Restablecer / Desinstalar ECC Copy Section

Si ECC parece duplicado, intrusivo o roto, no lo reinstales encima de sí mismo.

• Ruta del plugin: elimina el plugin de Claude Code, luego borra las carpetas de reglas específicas que copiaste manualmente bajo ~/.claude/rules/ecc/.
• Ruta del instalador manual / CLI: desde la raíz del repo, previsualiza la eliminación primero:

node scripts/uninstall.js --dry-run

Luego elimina los archivos gestionados por ECC:

node scripts/uninstall.js

También puedes usar el wrapper del ciclo de vida:

node scripts/ecc.js list-installed
node scripts/ecc.js doctor
node scripts/ecc.js repair
node scripts/ecc.js uninstall --dry-run

ECC solo elimina los archivos registrados en su estado de instalación. No borrará archivos no relacionados que no haya instalado.

Si combinaste métodos, limpia en este orden:

1. Elimina la instalación del plugin de Claude Code.
2. Ejecuta el comando de desinstalación de ECC desde la raíz del repo para eliminar los archivos gestionados por el estado de instalación.
3. Borra las carpetas de reglas adicionales que copiaste manualmente y ya no necesites.
4. Reinstala una vez, usando un único método.

Paso 3: Empezar a Usar Copy Section

# Las skills son la superficie principal de flujo de trabajo.
# Los nombres de comandos estilo slash existentes siguen funcionando mientras ECC migra fuera de commands/.

# La instalación por plugin usa la forma canónica con espacio de nombres
/ecc:plan "Añadir autenticación de usuario"

# La instalación manual mantiene la forma slash más corta:
# /plan "Añadir autenticación de usuario"

# Ver comandos disponibles
/plugin list ecc@ecc

¡Listo! Ahora tienes acceso a 63 agentes, 249 skills y 79 shims de comandos legados.

Dashboard GUI Copy Section

Lanza el dashboard de escritorio para explorar visualmente los componentes de ECC:

npm run dashboard
# o
python3 ./ecc_dashboard.py

Características:

• Interfaz con pestañas: Agentes, Skills, Comandos, Reglas, Configuración
• Alternancia de tema oscuro/claro
• Personalización de fuente (familia y tamaño)
• Logo del proyecto en el encabezado y la barra de tareas
• Búsqueda y filtrado en todos los componentes

Los comandos multi-modelo requieren configuración adicional Copy Section

ADVERTENCIA: Los comandos multi-* no están cubiertos por la instalación base del plugin/reglas anterior.

Para usar /multi-plan, /multi-execute, /multi-backend, /multi-frontend y /multi-workflow, también debes instalar el runtime ccg-workflow.

Inicialízalo con npx ccg-workflow.

Ese runtime proporciona las dependencias externas que esperan estos comandos, incluyendo:

• ~/.claude/bin/codeagent-wrapper
• ~/.claude/.ccg/prompts/*

Sin ccg-workflow, estos comandos multi-* no funcionarán correctamente.

Soporte Multiplataforma Copy Chapter

Este plugin ahora es totalmente compatible con Windows, macOS y Linux, junto con una integración estrecha en los principales IDEs (Cursor, Zed, OpenCode, Antigravity) y harnesses de CLI. Todos los hooks y scripts han sido reescritos en Node.js para máxima compatibilidad.

Detección del Gestor de Paquetes Copy Section

El plugin detecta automáticamente tu gestor de paquetes preferido (npm, pnpm, yarn o bun) con la siguiente prioridad:

1. Variable de entorno: CLAUDE_PACKAGE_MANAGER
2. Configuración del proyecto: .claude/package-manager.json
3. package.json: campo packageManager
4. Archivo de bloqueo: Detección desde package-lock.json, yarn.lock, pnpm-lock.yaml o bun.lockb
5. Configuración global: ~/.claude/package-manager.json
6. Alternativa: Primer gestor de paquetes disponible

Para establecer tu gestor de paquetes preferido:

# Mediante variable de entorno
export CLAUDE_PACKAGE_MANAGER=pnpm

# Mediante configuración global
node scripts/setup-package-manager.js --global pnpm

# Mediante configuración del proyecto
node scripts/setup-package-manager.js --project bun

# Detectar configuración actual
node scripts/setup-package-manager.js --detect

O usa el comando /setup-pm en Claude Code.

Controles de Ejecución de Hooks Copy Section

Usa flags de ejecución para ajustar la estrictez o deshabilitar hooks específicos temporalmente:

# Perfil de estrictez del hook (por defecto: standard)
export ECC_HOOK_PROFILE=standard

# IDs de hooks separados por coma para deshabilitar
export ECC_DISABLED_HOOKS="pre:bash:tmux-reminder,post:edit:typecheck"

# Limitar el contexto adicional de SessionStart (por defecto: 8000 caracteres)
export ECC_SESSION_START_MAX_CHARS=4000

# Deshabilitar completamente el contexto adicional de SessionStart para configuraciones de bajo contexto/modelo local
export ECC_SESSION_START_CONTEXT=off

# Mantener advertencias de contexto/alcance/bucle pero suprimir estimaciones de costo por tasa de API
export ECC_CONTEXT_MONITOR_COST_WARNINGS=off

Windows PowerShell:

[Environment]::SetEnvironmentVariable('ECC_CONTEXT_MONITOR_COST_WARNINGS', 'off', 'User')

Qué Incluye Copy Chapter

Este repo es un plugin de Claude Code — instálalo directamente o copia componentes manualmente.

/* Detailed source-code truncated for AI context efficiency. */

Herramientas del Ecosistema Copy Chapter

Creador de Skills Copy Section

Dos formas de generar skills de Claude Code desde tu repositorio:

Opción A: Análisis Local (Integrado)

Usa el comando /skill-create para análisis local sin servicios externos:

/skill-create                    # Analizar el repo actual
/skill-create --instincts        # También generar instintos para continuous-learning-v2

Esto analiza tu historial de git localmente y genera archivos SKILL.md.

Opción B: GitHub App (Avanzado)

Para características avanzadas (más de 10k commits, PRs automáticos, compartir en equipo):

Instalar GitHub App | ecc.tools

# Comenta en cualquier issue:
/skill-creator analyze

# O se activa automáticamente al hacer push a la rama por defecto

Ambas opciones crean:

• Archivos SKILL.md - Skills listas para usar en Claude Code
• Colecciones de instintos - Para continuous-learning-v2
• Extracción de patrones - Aprende de tu historial de commits

AgentShield — Auditor de Seguridad Copy Section

Construido en el Claude Code Hackathon (Cerebral Valley x Anthropic, Feb 2026). 1282 pruebas, 98% de cobertura, 102 reglas de análisis estático.

Analiza tu configuración de Claude Code en busca de vulnerabilidades, configuraciones incorrectas y riesgos de inyección.

# Análisis rápido (sin instalación necesaria)
npx ecc-agentshield scan

# Corrección automática de problemas seguros
npx ecc-agentshield scan --fix

# Análisis profundo con tres agentes Opus 4.6
npx ecc-agentshield scan --opus --stream

# Generar configuración segura desde cero
npx ecc-agentshield init

Qué analiza: CLAUDE.md, settings.json, configuraciones de MCP, hooks, definiciones de agentes y skills en 5 categorías — detección de secretos (14 patrones), auditoría de permisos, análisis de inyección en hooks, perfilado de riesgo de servidores MCP y revisión de configuración de agentes.

El flag --opus ejecuta tres agentes Claude Opus 4.6 en un pipeline red-team/blue-team/auditor. El atacante encuentra cadenas de exploits, el defensor evalúa las protecciones y el auditor sintetiza ambos en una evaluación de riesgo priorizada. Razonamiento adversarial, no solo coincidencia de patrones.

Formatos de salida: Terminal (color graduado A-F), JSON (pipelines de CI), Markdown, HTML. Código de salida 2 en hallazgos críticos para puertas de build.

Usa /security-scan en Claude Code para ejecutarlo, o añádelo a CI con la GitHub Action.

GitHub | npm

Aprendizaje Continuo v2 Copy Section

El sistema de aprendizaje basado en instintos aprende tus patrones automáticamente:

/instinct-status        # Ver instintos aprendidos con confianza
/instinct-import <file> # Importar instintos de otros
/instinct-export        # Exportar tus instintos para compartir
/evolve                 # Agrupar instintos relacionados en skills

Consulta skills/continuous-learning-v2/ para la documentación completa.
Mantén continuous-learning/ solo cuando quieras explícitamente el flujo legado v1 de skills aprendidas con hook Stop.

Requisitos Copy Chapter

Versión del CLI de Claude Code Copy Section

Versión mínima: v2.1.0 o posterior

Este plugin requiere Claude Code CLI v2.1.0+ debido a cambios en cómo el sistema de plugins gestiona los hooks.

Comprueba tu versión:

claude --version

Importante: Comportamiento de Carga Automática de Hooks Copy Section

ADVERTENCIA: Para Contribuidores: NO añadas un campo "hooks" a .claude-plugin/plugin.json. Esto está reforzado por una prueba de regresión.

Claude Code v2.1+ carga automáticamente hooks/hooks.json de cualquier plugin instalado por convención. Declararlo explícitamente en plugin.json provoca un error de detección de duplicados:

Duplicate hooks file detected: ./hooks/hooks.json resolves to already-loaded file

Historial: Esto ha causado ciclos repetidos de corrección/reversión en este repo (#29, #52, #103). El comportamiento cambió entre versiones de Claude Code, generando confusión. Ahora tenemos una prueba de regresión para prevenir que se reintroduzca.

Instalación Copy Chapter

Opción 1: Instalar como Plugin (Recomendado) Copy Section

La forma más fácil de usar este repo — instálalo como plugin de Claude Code:

# Añadir este repo como marketplace
/plugin marketplace add https://github.com/affaan-m/ECC

# Instalar el plugin
/plugin install ecc@ecc

O añade directamente a tu ~/.claude/settings.json:

{
  "extraKnownMarketplaces": {
    "ecc": {
      "source": {
        "source": "github",
        "repo": "affaan-m/ECC"
      }
    }
  },
  "enabledPlugins": {
    "ecc@ecc": true
  }
}

Esto te da acceso instantáneo a todos los comandos, agentes, skills y hooks.

Nota: El sistema de plugins de Claude Code no permite distribuir rules mediante plugins (limitación upstream). Necesitas instalar las reglas manualmente:

bash Copy

# Clonar el repo primero
git clone https://github.com/affaan-m/ECC.git
cd ECC

# Opción A: Reglas a nivel de usuario (se aplican a todos los proyectos)
mkdir -p ~/.claude/rules/ecc
cp -r rules/common ~/.claude/rules/ecc/
cp -r rules/typescript ~/.claude/rules/ecc/   # elige tu stack
cp -r rules/python ~/.claude/rules/ecc/
cp -r rules/golang ~/.claude/rules/ecc/
cp -r rules/php ~/.claude/rules/ecc/

# Opción B: Reglas a nivel de proyecto (se aplican solo al proyecto actual)
mkdir -p .claude/rules/ecc
cp -r rules/common .claude/rules/ecc/
cp -r rules/typescript .claude/rules/ecc/     # elige tu stack

Opción 2: Instalación Manual Copy Section

Si prefieres control manual sobre lo que se instala:

# Clonar el repo
git clone https://github.com/affaan-m/ECC.git
cd ECC

# Copiar agentes a tu configuración de Claude
cp agents/*.md ~/.claude/agents/

# Copiar directorios de reglas (common + específicos del lenguaje)
mkdir -p ~/.claude/rules/ecc
cp -r rules/common ~/.claude/rules/ecc/
cp -r rules/typescript ~/.claude/rules/ecc/   # elige tu stack
cp -r rules/python ~/.claude/rules/ecc/
cp -r rules/golang ~/.claude/rules/ecc/
cp -r rules/php ~/.claude/rules/ecc/
cp -r rules/arkts ~/.claude/rules/ecc/

# Instalar skills con el instalador consciente de migraciones.
# Conserva skills del usuario, informa conflictos y evita sobrescribirlos.
node scripts/install-apply.js --target claude --modules workflow-quality

# Opcional: instalar skills concretas solo cuando las necesites.
node scripts/install-apply.js --target claude --skills search-first
# node scripts/install-apply.js --target claude --skills django-patterns,django-tdd

# Opcional: mantener compatibilidad con entradas slash durante la migración
mkdir -p ~/.claude/commands
cp commands/*.md ~/.claude/commands/

# Los shims retirados están en legacy-command-shims/commands/.
# Copia archivos individuales de ahí solo si todavía necesitas nombres viejos como /tdd.

Instalar hooks

No copies el hooks/hooks.json del repo directamente en ~/.claude/settings.json ni en ~/.claude/hooks/hooks.json. Ese archivo está orientado al plugin/repo y está pensado para instalarse mediante el instalador de ECC o cargarse como plugin, por lo que la copia directa no es una ruta de instalación manual soportada.

Usa el instalador para instalar solo el runtime de hooks de Claude de forma que las rutas de comandos se reescriban correctamente:

# macOS / Linux
bash ./install.sh --target claude --modules hooks-runtime

# Windows PowerShell
pwsh -File .\install.ps1 --target claude --modules hooks-runtime

Eso escribe los hooks resueltos en ~/.claude/hooks/hooks.json y deja intacto cualquier ~/.claude/settings.json existente.

Si instalaste ECC mediante /plugin install, no copies esos hooks en settings.json. Claude Code v2.1+ ya carga automáticamente el hooks/hooks.json del plugin, y duplicarlos en settings.json provoca ejecución duplicada y conflictos de hooks multiplataforma.

Nota para Windows: el directorio de configuración de Claude es %USERPROFILE%\\.claude, no ~/claude.

Configurar MCPs

Las instalaciones de plugin de Claude intencionalmente no habilitan automáticamente las definiciones de servidores MCP empaquetadas en ECC. Esto evita nombres de herramientas MCP demasiado largos en puertas de acceso estrictas de terceros mientras mantiene la configuración manual de MCP disponible.

Usa el comando /mcp de Claude Code o la configuración de MCP gestionada por CLI para cambios en tiempo de ejecución de servidores MCP de Claude Code. Usa /mcp para deshabilitar en el runtime de Claude Code; Claude Code persiste esas opciones en ~/.claude.json.

Para acceso a MCP local del repo, copia las definiciones de servidor MCP deseadas de mcp-configs/mcp-servers.json en un .mcp.json con alcance de proyecto.

Si ya ejecutas tus propias copias de los MCPs empaquetados en ECC, establece:

export ECC_DISABLED_MCPS="github,context7,exa,playwright,sequential-thinking,memory"

Los flujos de instalación y sincronización de Codex gestionados por ECC omitirán o eliminarán esos servidores empaquetados en lugar de volver a añadir duplicados. ECC_DISABLED_MCPS es un filtro de instalación/sincronización de ECC, no un interruptor en tiempo de ejecución de Claude Code.

Importante: Reemplaza los marcadores YOUR_*_HERE con tus claves de API reales.

Conceptos Clave Copy Chapter

Agentes Copy Section

Los subagentes manejan tareas delegadas con alcance limitado. Ejemplo:

---
name: code-reviewer
description: Reviews code for quality, security, and maintainability
tools: ["Read", "Grep", "Glob", "Bash"]
model: opus
---

You are a senior code reviewer...

Skills Copy Section

Las skills son la superficie principal de flujo de trabajo. Pueden invocarse directamente, sugerirse automáticamente y ser reutilizadas por agentes. ECC sigue enviando commands/ mantenidas durante la migración, mientras que los shims de nombres cortos retirados están en legacy-command-shims/ solo para opt-in explícito. El nuevo desarrollo de flujos de trabajo debe aterrizar primero en skills/.

# Flujo de Trabajo TDD

1. Define las interfaces primero
2. Escribe pruebas que fallen (ROJO)
3. Implementa el código mínimo (VERDE)
4. Refactoriza (MEJORAR)
5. Verifica 80%+ de cobertura

Hooks Copy Section

Los hooks se disparan en eventos de herramientas. Ejemplo — advertir sobre console.log:

{
  "matcher": "tool == \"Edit\" && tool_input.file_path matches \"\\\\.(ts|tsx|js|jsx)$\"",
  "hooks": [{
    "type": "command",
    "command": "#!/bin/bash\ngrep -n 'console\\.log' \"$file_path\" && echo '[Hook] Remove console.log' >&2"
  }]
}

Reglas Copy Section

Las reglas son directrices de cumplimiento obligatorio, organizadas en common/ (agnóstico al lenguaje) + directorios específicos por lenguaje:

rules/
  common/          # Principios universales (siempre instalar)
  typescript/      # Patrones y herramientas específicos de TS/JS
  python/          # Patrones y herramientas específicos de Python
  golang/          # Patrones y herramientas específicos de Go
  swift/           # Patrones y herramientas específicos de Swift
  php/             # Patrones y herramientas específicos de PHP
  arkts/           # Patrones y restricciones de HarmonyOS / ArkTS

Consulta rules/README.md para detalles de instalación y estructura.

¿Qué Agente Debo Usar? Copy Chapter

¿No sabes por dónde empezar? Usa esta referencia rápida. Las skills son la superficie canónica de flujo de trabajo; las entradas slash mantenidas siguen disponibles para flujos de trabajo orientados a comandos.

Flujos de Trabajo Comunes Copy Section

Las formas slash a continuación se muestran donde siguen siendo parte de la superficie de comandos mantenida. Los shims de nombres cortos retirados como /tdd y /eval están en legacy-command-shims/ solo para opt-in explícito.

Empezando una nueva feature:

/ecc:plan "Añadir autenticación de usuario con OAuth"
                                              → planner crea el blueprint de implementación
skill tdd-workflow                            → tdd-guide refuerza escribir pruebas primero
/code-review                                  → code-reviewer verifica tu trabajo

Corrigiendo un bug:

skill tdd-workflow                            → tdd-guide: escribe una prueba que falle y lo reproduzca
                                              → implementa la corrección, verifica que la prueba pase
/code-review                                  → code-reviewer: detecta regresiones

Preparando para producción:

/security-scan                                → security-reviewer: auditoría OWASP Top 10
skill e2e-testing                             → e2e-runner: pruebas de flujos de usuario críticos
/test-coverage                                → verificar 80%+ de cobertura

Preguntas Frecuentes Copy Chapter

¿Cómo veo qué agentes/comandos están instalados?

/plugin list ecc@ecc

Muestra todos los agentes, comandos y skills disponibles del plugin.

Mis hooks no funcionan / Veo errores de "Duplicate hooks file"

Este es el problema más común. NO añadas un campo "hooks" a .claude-plugin/plugin.json. Claude Code v2.1+ carga automáticamente hooks/hooks.json de los plugins instalados. Declararlo explícitamente provoca errores de detección de duplicados. Consulta #29, #52, #103.

¿Puedo usar ECC con Claude Code en un endpoint de API personalizado o un gateway de modelos?

Sí. ECC no tiene configuraciones de transporte alojadas en Anthropic. Se ejecuta localmente a través de la superficie CLI/plugin normal de Claude Code, por lo que funciona con:

• Claude Code alojado en Anthropic
• Configuraciones de gateway oficial de Claude Code usando ANTHROPIC_BASE_URL y ANTHROPIC_AUTH_TOKEN
• Endpoints personalizados compatibles que hablen la API de Anthropic que espera Claude Code

Ejemplo mínimo:

export ANTHROPIC_BASE_URL=https://your-gateway.example.com
export ANTHROPIC_AUTH_TOKEN=your-token
claude

Si tu gateway reasigna nombres de modelos, configúralo en Claude Code en lugar de en ECC. Los hooks, skills, comandos y reglas de ECC son agnósticos al proveedor de modelos una vez que el CLI claude ya funciona.

Referencias oficiales:

• Documentación del gateway LLM de Claude Code
• Documentación de configuración de modelos de Claude Code

Mi ventana de contexto se está reduciendo / Claude se queda sin contexto

Demasiados servidores MCP consumen tu contexto. Cada descripción de herramienta MCP consume tokens de tu ventana de 200k, potencialmente reduciéndola a ~70k. El contexto de SessionStart está limitado a 8000 caracteres por defecto; redúcelo con ECC_SESSION_START_MAX_CHARS=4000 o desactívalo con ECC_SESSION_START_CONTEXT=off para configuraciones de bajo contexto o modelo local.

Solución: Deshabilita los MCPs no utilizados desde Claude Code con /mcp. Claude Code escribe esas opciones en tiempo de ejecución en ~/.claude.json; .claude/settings.json y .claude/settings.local.json no son interruptores confiables para servidores MCP ya cargados.

Mantén menos de 10 MCPs habilitados y menos de 80 herramientas activas.

¿Puedo usar solo algunos componentes (por ejemplo, solo los agentes)?

Sí. Usa la Opción 2 (instalación manual) y copia solo lo que necesites:

# Solo agentes
cp agents/*.md ~/.claude/agents/

# Solo reglas
mkdir -p ~/.claude/rules/ecc/
cp -r rules/common ~/.claude/rules/ecc/

Cada componente es completamente independiente.

¿Funciona con Cursor / OpenCode / Codex / Antigravity / GitHub Copilot?

Sí. ECC es multiplataforma:

• Cursor: Configuraciones pre-traducidas en .cursor/. Consulta Soporte para Cursor IDE.
• Gemini CLI: Soporte experimental local al proyecto mediante .gemini/GEMINI.md y conexiones compartidas del instalador.
• OpenCode: Soporte completo del plugin en .opencode/. Consulta Soporte para OpenCode.
• Codex: Soporte de primera clase para la app macOS y CLI, con guardias de deriva del adaptador y fallback de SessionStart. Consulta PR #257.
• GitHub Copilot (VS Code): Capa de instrucciones y prompts mediante .github/copilot-instructions.md, .vscode/settings.json y .github/prompts/. Consulta Soporte para GitHub Copilot.
• Antigravity: Configuración estrechamente integrada para flujos de trabajo, skills y reglas aplanadas en .agents/. Consulta la Guía de Antigravity.
• JoyCode / CodeBuddy: Adaptadores de instalación selectiva locales al proyecto para comandos, agentes, skills y reglas aplanadas. Consulta la Guía del Adaptador JoyCode.
• Qwen CLI: Adaptador de instalación selectiva en el directorio home para comandos, agentes, skills, reglas y configuración de Qwen. Consulta la Guía del Adaptador Qwen CLI.
• Zed: Adaptador de instalación selectiva local al proyecto para .zed/settings.json, reglas aplanadas, comandos, agentes y skills.
• Harnesses no nativos: Ruta de respaldo manual para Grok e interfaces similares. Consulta la Guía de Adaptación Manual.
• Claude Code: Nativo — este es el objetivo principal.

¿Cómo contribuyo con una nueva skill o agente?

Consulta CONTRIBUTING.md. La versión corta:

1. Haz fork del repo
2. Crea tu skill en skills/tu-nombre-de-skill/SKILL.md (con frontmatter YAML)
3. O crea un agente en agents/tu-agente.md
4. Envía un PR con una descripción clara de qué hace y cuándo usarlo

Ejecutar Pruebas Copy Chapter

El plugin incluye una suite de pruebas completa:

# Ejecutar todas las pruebas
node tests/run-all.js

# Ejecutar archivos de prueba individuales
node tests/lib/utils.test.js
node tests/lib/package-manager.test.js
node tests/hooks/hooks.test.js

Contribuir Copy Chapter

Las contribuciones son bienvenidas y fomentadas.

Este repo está pensado para ser un recurso comunitario. Si tienes:

• Agentes o skills útiles
• Hooks ingeniosos
• Mejores configuraciones de MCP
• Reglas mejoradas

¡Contribuye! Consulta CONTRIBUTING.md para las directrices.

Ideas para Contribuciones Copy Section

• Skills específicas de lenguaje (Rust, C#, Kotlin, Java) — Go, Python, Perl, Swift, TypeScript y HarmonyOS/ArkTS ya están incluidos
• Configs específicas de frameworks (Rails, FastAPI) — Django, NestJS, Spring Boot y Laravel ya están incluidos
• Agentes de DevOps (Kubernetes, Terraform, AWS, Docker)
• Estrategias de prueba (diferentes frameworks, regresión visual)
• Conocimiento de dominio específico (ML, ingeniería de datos, móvil)

Notas del Ecosistema Comunitario Copy Section

Estos no están empaquetados con ECC y no son auditados por este repo, pero vale la pena conocerlos si estás explorando el ecosistema más amplio de skills de Claude Code:

• claude-seo — Colección de skills y agentes centrados en SEO
• claude-ads — Colección de flujos de trabajo de auditoría de anuncios y crecimiento de pago
• claude-cybersecurity — Colección de skills y agentes orientados a seguridad

Soporte para Cursor IDE Copy Chapter

ECC proporciona soporte para Cursor IDE con hooks, reglas, agentes, skills, comandos y configuraciones de MCP adaptados para el diseño de proyecto de Cursor.

Inicio Rápido (Cursor) Copy Section

# macOS/Linux
./install.sh --target cursor typescript
./install.sh --target cursor python golang swift php

# Windows PowerShell
.\install.ps1 --target cursor typescript
.\install.ps1 --target cursor python golang swift php

Qué Incluye Copy Section

Notas de Carga en Cursor Copy Section

ECC no instala el AGENTS.md raíz en .cursor/. Cursor trata los archivos AGENTS.md anidados como contexto de directorio, por lo que copiar la identidad del repo de ECC en un proyecto host contaminaría ese proyecto.

El comportamiento de carga nativo de Cursor puede variar según la versión. ECC instala agentes como .cursor/agents/ecc-*.md; si tu versión de Cursor no expone los agentes del proyecto, esos archivos siguen funcionando como definiciones de referencia explícitas en lugar de contexto de prompt global oculto.

Arquitectura de Hooks (Patrón de Adaptador DRY) Copy Section

Cursor tiene más eventos de hook que Claude Code (20 vs 8). El módulo .cursor/hooks/adapter.js transforma el JSON de stdin de Cursor al formato de Claude Code, permitiendo reutilizar los scripts/hooks/*.js existentes sin duplicación.

JSON de stdin de Cursor → adapter.js → transforma → scripts/hooks/*.js
                                                    (compartido con Claude Code)

Hooks clave:

• beforeShellExecution — Bloquea servidores de desarrollo fuera de tmux (exit 2), revisión de git push
• afterFileEdit — Auto-formato + verificación de TypeScript + advertencia de console.log
• beforeSubmitPrompt — Detecta secretos (sk-, ghp_, patrones AKIA) en prompts
• beforeTabFileRead — Bloquea a Tab de leer archivos .env, .key, .pem (exit 2)
• beforeMCPExecution / afterMCPExecution — Registro de auditoría de MCP

Formato de Reglas Copy Section

Las reglas de Cursor usan frontmatter YAML con description, globs y alwaysApply:

---
description: "TypeScript coding style extending common rules"
globs: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"]
alwaysApply: false
---

Soporte para Codex macOS App + CLI Copy Chapter

ECC proporciona soporte de primera clase para Codex tanto para la app macOS como para el CLI, con una configuración de referencia, un suplemento AGENTS.md específico de Codex y skills compartidas.

Inicio Rápido (Codex App + CLI) Copy Section

# Ejecutar Codex CLI en el repo — AGENTS.md y .codex/ se detectan automáticamente
codex

# Configuración automática: sincronizar activos de ECC (AGENTS.md, skills, servidores MCP) en ~/.codex
npm install && bash scripts/sync-ecc-to-codex.sh

# O manualmente: copiar la configuración de referencia a tu directorio home
cp .codex/config.toml ~/.codex/config.toml

El script de sincronización fusiona de forma segura los servidores MCP de ECC en tu ~/.codex/config.toml existente usando una estrategia solo de adición — nunca elimina ni modifica tus servidores existentes. Ejecuta con --dry-run para previsualizar los cambios, o --update-mcp para forzar la actualización de los servidores ECC a la configuración recomendada más reciente.

Qué Incluye Copy Section

Soporte para OpenCode Copy Chapter

ECC proporciona soporte completo para OpenCode incluyendo plugins y hooks.

Inicio Rápido Copy Section

# Instalar OpenCode
npm install opencode

# Ejecutar en la raíz del repositorio
opencode

La configuración se detecta automáticamente desde .opencode/opencode.json.

Paridad de Características Copy Section

Soporte para GitHub Copilot Copy Chapter

ECC proporciona soporte para GitHub Copilot para VS Code mediante el sistema nativo de archivos de instrucciones y prompts de Copilot Chat — sin herramientas adicionales necesarias.

Qué Incluye Copy Section

Inicio Rápido (GitHub Copilot) Copy Section

Los archivos ya están en su lugar — abre cualquier repo que contenga este proyecto y GitHub Copilot Chat recogerá automáticamente .github/copilot-instructions.md.
El .vscode/settings.json confirmado habilita chat.promptFiles para que VS Code pueda cargar los prompts reutilizables de .github/prompts/.

Para usar los prompts de flujo de trabajo en Copilot Chat:

1. Abre el panel de Copilot Chat en VS Code.
2. Haz clic en el icono de clip / adjuntar y selecciona Prompt..., o escribe / y elige un prompt.
3. Selecciona el prompt (por ejemplo, plan, tdd, security-review).

Compatibilidad Cross-Tool Copy Chapter

ECC es el primer plugin que maximiza todas las principales herramientas de codificación con IA. Así se compara cada harness:

Antecedentes Copy Chapter

He estado usando Claude Code desde el lanzamiento experimental. Gané el hackathon de Anthropic x Forum Ventures en sep 2025 con @DRodriguezFX — construí zenith.chat completamente usando Claude Code.

Estas configuraciones han sido probadas en múltiples aplicaciones de producción.

Optimización de Tokens Copy Chapter

El uso de Claude Code puede ser costoso si no gestionas el consumo de tokens. Estas configuraciones reducen significativamente los costos sin sacrificar calidad.

Configuración Recomendada Copy Section

Añade a ~/.claude/settings.json:

{
  "model": "sonnet",
  "env": {
    "MAX_THINKING_TOKENS": "10000",
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50"
  }
}

Cambia a Opus solo cuando necesites razonamiento arquitectónico profundo:

/model opus

Comandos del Flujo de Trabajo Diario Copy Section

Compactación Estratégica Copy Section

La skill strategic-compact (incluida en este plugin) sugiere /compact en puntos de quiebre lógicos en lugar de depender de la auto-compactación al 95% del contexto.

Cuándo compactar:

• Después de investigación/exploración, antes de la implementación
• Después de completar un hito, antes de empezar el siguiente
• Después de depurar, antes de continuar con el trabajo de features
• Después de un enfoque fallido, antes de probar uno nuevo

Cuándo NO compactar:

• A mitad de la implementación (perderás nombres de variables, rutas de archivos, estado parcial)

ADVERTENCIA: Notas Importantes Copy Chapter

Optimización de Tokens Copy Section

¿Alcanzando los límites diarios? Consulta la Guía de Optimización de Tokens para configuraciones recomendadas y consejos de flujo de trabajo.

Ganancias rápidas:

// ~/.claude/settings.json
{
  "model": "sonnet",
  "env": {
    "MAX_THINKING_TOKENS": "10000",
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50",
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku"
  }
}

Personalización Copy Section

Estas configuraciones funcionan para mi flujo de trabajo. Deberías:

1. Empezar con lo que resuene
2. Modificar para tu stack
3. Eliminar lo que no uses
4. Añadir tus propios patrones

Proyectos de la Comunidad Copy Chapter

Proyectos construidos sobre o inspirados en ECC:

¿Construiste algo con ECC? Abre un PR para añadirlo aquí.

Patrocinadores Copy Chapter

Este proyecto es gratuito y de código abierto. Los patrocinadores ayudan a mantenerlo y hacerlo crecer.

Conviértete en Patrocinador | Niveles de Patrocinio | Programa de Patrocinio

Historial de Estrellas Copy Chapter

Enlaces Copy Chapter

• Guía Resumida (Empieza aquí): La Guía Resumida de ECC
• Guía Extensa (Avanzado): La Guía Extensa de ECC
• Guía de Seguridad: Guía de Seguridad | Hilo
• Seguir: @affaanmustafa

Licencia Copy Chapter

MIT - Úsalo libremente, modifícalo según tus necesidades, contribuye de vuelta si puedes.

Dale una estrella al repo si te ayuda. Lee las dos guías. Construye algo grandioso.

Ja JP README (`docs/ja-JP/README.md`) Copy Section

[!WARNING]
公式ソースからのみインストールしてください。 ECC は検証済みのチャネルからのみインストールしてください。GitHub リポジトリ github.com/affaan-m/ECC、npm パッケージ ecc-universal と ecc-agentshield、GitHub App、plugin スラッグ ecc@ecc、そしてプロジェクト公式サイト ecc.tools です。第三者による再アップロードや非公式ミラーはプロジェクトが保守・レビューしておらず、マルウェアを含む可能性があります。

Claude Code でインストール Copy Chapter

ガイド付きセットアップまたはネイティブ plugin コマンドを使用してください。どちらも同じ ecc@ecc plugin をインストールします。どちらか一方を選び、その上にフルの手動 Claude インストールを重ねないでください。

_{OSS は今後も無料です。 このリポジトリは永久に MIT ライセンスです。ECC Pro はプライベートリポジトリ向けのホスト型 GitHub App です。スポンサーと Pro 購読者がこの活動を支えています。だからこそ、たった一人のメンテナーが 7 つのハーネスに対して毎週リリースを続けられるのです。}

ECC

あなたのエージェントはコードを書けますが、ECC はそこに協調的なエンジニアリングシステムとツールボックスを与えます。構築の前に計画し、テストで変更を検証し、新しいコンテキストから自分の作業をレビューし、重要なことを記憶し、繰り返し成功したことを再利用可能な skills とワークフローに変えていきます。

plan -> test -> implement -> review -> verify -> remember -> improve

このプロセスをプロンプトのたびに組み立て直すのではなく、一度インストールしてエージェントの働き方の一部にします。

コンテキストウィンドウを最適化し、それ以外はすべて永続化する。

ECC は MIT ライセンスのオープンソースです。現時点では Claude Code で最もよく機能し、サポート対象の Codex 同期パスを備え、Cursor、OpenCode、Gemini、Zed、GitHub Copilot、Antigravity、Qwen、その他のハーネス向けには機能が限定されたアダプターを提供しています。機能の同等性を前提にする前に、サポート状況マトリクスを確認してください。

68 の agents、293 の skills、94 のレガシー command シムに加えて、hooks、rules、メモリ、継続的学習、AgentShield セキュリティスキャンを利用できます。agents は計画、レビュー、ビルド修復、セキュリティ、アーキテクチャ、ドメイン作業に特化しています。

ECC のインストール Copy Chapter

[!IMPORTANT]
ECC 2.2 には Claude Code、Codex、Kimi Code 向けのガイド付きパッケージセットアップが含まれています。
ユニバーサルパッケージには Node.js 18 以降が必要です。Claude plugin のセットアップには、
さらに Git と Claude Code 2.1 以降が PATH 上にあることが必要です。

推奨: ユニバーサルガイド付きセットアップ Copy Section

Claude Code plugin のセットアップ、更新、スコープ変更、hook プロファイルの変更には次を使います。

npx [email protected] setup

npm がバージョンまたはキャッシュのエラーを報告した場合は、再試行する前にレジストリのバージョンを確認してください。

npm view ecc-universal version

ECC 2.2 は、モダンなパッケージランナーでも同じガイド付きセットアップをサポートしています。

これらの例では、このリポジトリのリリースバージョンに対応する公開済みの ECC 2.2.1 リリースを指定しています。バージョンのピン留めはセキュリティ監査でも整合性チェックでもありません。パッケージのコードを実行する前にリリースのソースとレジストリの整合性を確認し、未リリースの変更にはレビュー済みのチェックアウトを使用してください。

Yarn Classic 1 には yarn dlx がありません。npx を使うか、パッケージをグローバルにインストールするか、一時的なワンショット実行のために Yarn をアップグレードしてください。

ウィザードは変更を加える前に公式マーケットプレイスとすべてのネイティブ Claude インストールスコープを棚卸しし、その後、選択したスコープに ecc@ecc をインストール、更新、または安全に移動します。ECC を更新したいとき、スコープを変えたいとき、hook プロファイルを変えたいときは、いつでも同じコマンドを再実行してください。このセットアップウィザードが現在設定するのは Claude Code plugin です。Codex や Kimi Code には、下記のマルチハーネスウィザードを使用してください。

複数のコーディングエージェントを一つのレビュー済みフローで設定するには、マルチハーネスウィザードを使用します。

npx [email protected] install --guided

Claude Code、Codex、Kimi Code の任意の組み合わせを選択でき、各インストールチャネルと配置先を表示し、最初の書き込み前にすべての選択をプリフライトし、最後に一度だけ確認を求めます。

自動化のためには、プロバイダー固有の選択をすべて明示してください。

npx [email protected] install --guided \
  --harness claude --harness codex --harness kimi \
  --claude-scope local --claude-hooks standard \
  --profile core --yes

ネイティブのガイド付き Codex パスと管理された Kimi パスを、書き込みなしで先に検証するには次を実行します。

npx [email protected] install --guided --harness codex --dry-run
npx [email protected] install --profile core --target kimi --dry-run

2.2 エイリアスを通じて、追加のパッケージ名コマンドも利用できます。

npx [email protected] consult "security reviews" --target claude
npx [email protected] install --profile minimal --target claude --with capability:machine-learning
npx [email protected] doctor --target kimi

npx ecc-install --profile minimal --target claude は使用しないでください。ecc-install は ecc-universal 内のバイナリ名であり、個別に公開された npm パッケージではありません。

ECC は cursor、antigravity、gemini、opencode、codebuddy、joycode、qwen、zed、hermes、openclaw 向けの高度な管理アダプターも提供しています。これらのターゲットは、各アダプターがガイド付きの衝突、更新、修復、アンインストールのライフサイクルマトリクスを通過するまで、ドキュメント化された ecc install --target ... パスを引き続き使用します。どちらのウィザードも、検出されたすべてのハーネスに黙ってインストールすることはありません。

パスは一つだけ選ぶ（ハーネスごと） Copy Section

ECC は Claude Code、Codex、その他のハーネスで同時に使用できます。ハーネスごとに一つのインストール方法を選んでください。

• 推奨デフォルト: 上記のガイド付き Claude plugin セットアップを実行する
• Claude Code でもサポート: ネイティブ plugin コマンドを使用する
• リリース 2.2 で利用可能: Claude Code、Codex、Kimi Code 向けのガイド付きパッケージセットアップ
• 動作します: Claude Code plugin + Codex ネイティブ plugin
• 動作します: Claude Code plugin + レガシー Codex 同期フロー
• 避けてください: Claude Code plugin + フル Claude 手動インストール
• 避けてください: Codex 同期 + Codex マーケットプレイス plugin

インストール方法を重ねないでください。 同じハーネスに ECC を二度インストールすると、skills、commands、hooks、設定が重複することがあります。複数のハーネスにそれぞれ一度ずつインストールする分には問題ありません。

すでに複数のインストールを重ねてしまい、重複しているように見える場合は、ECC のリセット / アンインストールに直接進んでください。

インストールで困っていますか？ 短いインストールまたはランタイムの問題フォームを開くか、ecc feedback を実行してください。ECC が診断情報を自動でアップロードすることはありません。

Claude Code の詳細 Copy Section

代わりに、Claude Code 内で Claude Code のネイティブ plugin コマンドを実行することもできます。

/plugin marketplace add https://github.com/affaan-m/ECC
/plugin install ecc@ecc

ネイティブパスは ECC の skills、agents、commands、および plugin 管理の hooks をインストールします。この方法を選んだ場合は、そこで止めてください。Claude Code にフルの手動インストールを追加で実行しないでください。

これらの組み込みコマンドは Claude Code が所有しており、マーケットプレイス、plugin、または競合するスコープがすでに存在する場合のエラーも同様です。ECC はそのパーサーに介入できません。いずれかのネイティブコマンドが既存のインストールやスコープの競合を報告した場合は、2.2 のガイド付きセットアップを使用するか、競合している Claude plugin スコープを解決してから再試行してください。その上に手動インストールを重ねないでください。

ECC のインストール後は、/ecc:configure-ecc が名前空間付きの Claude 内再設定 skill になります。これは同じ安全なセットアップフローに委譲しますが、plugin のインストール後にのみ利用可能で、初回インストール時に Claude Code 組み込みの /plugin コマンドを置き換えることはできません。

Claude Code plugins は rules を配布できないため、本当に必要な rule パックだけを追加してください。

git clone https://github.com/affaan-m/ECC.git
cd ECC
mkdir -p ~/.claude/rules/ecc
cp -R rules/common ~/.claude/rules/ecc/
cp -R rules/typescript ~/.claude/rules/ecc/  # 使用しているスタックに置き換えてください

rules/common と、実際に使用している言語またはフレームワークのパックを一つ入れるところから始めてください。plugin をインストールした場合は、その後で ./install.sh --profile full を実行しないでください。

settings.json 派ですか？マーケットプレイスを宣言的に追加する

~/.claude/settings.json に直接追加します。

{
  "extraKnownMarketplaces": {
    "ecc": {
      "source": {
        "source": "github",
        "repo": "affaan-m/ECC"
      }
    }
  },
  "enabledPlugins": {
    "ecc@ecc": true
  }
}

これにより、上記の二つの /plugin コマンドと同じ結果が得られます。

命名と移行に関する注記（ecc@ecc、affaan-m/ECC、ecc-universal）

ECC には三つの公開識別子があり、これらは互いに置き換えられません。

• GitHub ソースリポジトリ: affaan-m/ECC
• Claude マーケットプレイス/plugin 識別子: ecc@ecc
• npm パッケージ: ecc-universal

これは意図的なものです。Anthropic のマーケットプレイス/plugin インストールは正規の plugin 識別子をキーとするため、ECC は厳格な Desktop/API バリデーターに対してツール名とスラッシュコマンドの名前空間を十分に短く保つために ecc@ecc を使用しています。古い投稿には以前の長いマーケットプレイス識別子が残っている場合がありますが、それはレガシーエイリアスとしてのみ扱ってください。一方、npm パッケージは ecc-universal のままなので、npm インストールとマーケットプレイスインストールは意図的に異なる名前を使用しています。

npm リリースはコミットごとではなくバージョンタグごとに切られるため、ecc-universal は main へのすべてのプッシュではなく、リリース（2.1、2.2、...）を追跡します。最新の開発版が必要な場合は git からインストールしてください。

ローカルの Claude セットアップが消去またはリセットされた場合でも、何かを買い直す必要があるわけではありません。まず node scripts/ecc.js list-installed から始め、次に node scripts/ecc.js doctor と node scripts/ecc.js repair を実行してから再インストールしてください。通常はこれで、セットアップを組み直すことなく ECC 管理のファイルが復元されます。

Codex App と CLI Copy Section

現在の Codex リリースでは、ECC をネイティブのリポジトリマーケットプレイス plugin としてインストールできます。マーケットプレイスエントリはリポジトリルートを使用するため、Codex のキャッシュはマニフェストとともに、参照されるすべての skills、MCP 設定、hook ランタイム、スクリプト、アセットを受け取ります。

codex plugin marketplace add affaan-m/ECC
codex plugin add ecc@ecc
codex plugin list --json
node scripts/codex/check-plugin-cache.js

どちらの add コマンドも冪等です。後で更新するには、codex plugin marketplace upgrade ecc に続けて codex plugin add ecc@ecc を実行します。Codex はアクティブな CODEX_HOME に一つの有効化された plugin 状態を保存し、Claude の user、project、local スコープは提供しません。そのネイティブ hooks は明示的な信頼の決定を必要とし、Claude の四つの ECC hook プロファイルは使用しません。Codex 内では、ガイド付きのプロバイダー対応フローとして $configure-ecc を呼び出してください。

従来の scripts/sync-ecc-to-codex.sh パスは、~/.codex にコピーおよびマージされた設定を意図的に必要とするユーザー向けの非推奨互換オプションであり、ネイティブ plugin には不要です。新しい同期の実行では所有権マニフェストを書き出すため、クリーンアップ時に変更されたユーザーファイルを保護できます。まず Codex を一度実行して ~/.codex/config.toml が存在する状態にしてから、次を実行します。

git clone https://github.com/affaan-m/ECC.git
cd ECC
npm install
bash scripts/sync-ecc-to-codex.sh

Codex の会話やネイティブ plugin キャッシュに触れずに、そのレガシーレイヤーを確認または削除するには次を実行します。

node scripts/ecc.js uninstall --legacy-codex-sync --dry-run
node scripts/ecc.js uninstall --legacy-codex-sync

マニフェスト以前のインストールは保守的に扱われます。ECC はマークされた AGENTS.md ブロックを削除しますが、所有を証明できないコピー済みファイルは保持し、レビュー用に報告します。

プロジェクトローカルのセットアップとして、ECC リポジトリを Codex で直接開くこともできます。Codex はグローバル同期なしで、ルートの AGENTS.md と .codex/ 内の信頼済みプロジェクト設定を読み取ります。同期フローの上にネイティブマーケットプレイス plugin を追加しないでください。

リポジトリのナビゲーション、サーフェスの所有権、PR 差分パケットのガイダンスについては、Codex ECC Navigation Map を参照してください。ネイティブライフサイクルの詳細は .codex plugin notes を参照してください。

その他のエージェントとエディター Copy Section

Cursor、OpenCode、Gemini、Zed、Antigravity、Qwen、Hermes、OpenClaw、Kimi、CodeBuddy、JoyCode、Copilot

ECC を一度クローンし、使用しているハーネスに合ったターゲットを選択します。

git clone https://github.com/affaan-m/ECC.git
cd ECC

GitHub Copilot のサポートはすでにこのリポジトリに含まれています。.github/copilot-instructions.md が指示レイヤーを提供し、.github/prompts/ には再利用可能な /plan、/tdd、/security-review、/build-fix、/refactor のプロンプトが含まれ、.vscode/settings.json が chat.promptFiles を有効にします。

ネイティブの ECC ターゲットがないハーネスには、手動適用ガイドを使用してください。hooks やネイティブの skill 検出が利用できるふりをせずに、少数の ECC skills とワークフロー指示をチャット型ツールに持ち込む方法を説明しています。

Cursor は agent 定義を .cursor/agents/ecc-*.md 配下にインストールします。Cursor ネイティブのロード動作は Cursor のビルドによって異なる場合があります。ECC はルートの AGENTS.md を .cursor/ にインストールしません。このアダプターは Cursor のコンテキストをネイティブの rules と agent サーフェスに限定します。

ハーネスごとの詳細な注記（機能の同等性、hook アダプター、制限事項）は、下記のプラットフォームサポートにあります。

高度なインストールオプション Copy Chapter

hook ランタイムなしの低コンテキストインストール

低コンテキスト / hooks なしパス Copy Section

ランタイム hooks なしで ECC の rules、agents、commands、プラットフォーム設定、コアワークフローを使いたい場合はこちらを使用します。

npx [email protected] install --profile minimal --target claude

ソースチェックアウトからの同等のコマンドは次のとおりです。

./install.sh --profile minimal --target claude

Windows:

.\install.ps1 --profile minimal --target claude

このプロファイルは意図的に hooks-runtime を除外しています。

Claude の手動インストールでは、Claude Code が検出できるように各 skill を ~/.claude/skills/<skill-name>/（claude-project の場合は .claude/skills/<skill-name>/）の直下に配置します。古い ECC 手動インストールをアップグレードする場合、インストーラーは ECC のインストール状態に記録されたネストされた skills/ecc/ ファイルのみを移行します。フラットな skill ディレクトリがユーザー所有の場合、ECC はそれを保持して競合の警告を表示し、ユーザーファイルを上書きする代わりに、古い管理コピーを安全なアンインストールのために追跡し続けます。

hooks を無効にした通常の core プロファイルの場合:

./install.sh --profile core --without baseline:hooks --target claude
./install.sh --profile core --no-hooks --target claude

hook ランタイムが必要になった場合にのみ、後から追加します。

./install.sh --target claude --modules hooks-runtime --enable-hooks

プロファイルまたはモジュールによって hook ランタイムが実体化されるインストールでは、
明示的な決定が必要です。--enable-hooks も --no-hooks も指定されていない場合、
インストーラーは hooks でできることを表示し、何も書き込まずに停止します。ガイド付き
インストーラー（ecc install --guided）はこの選択を対話的に尋ねます。

必要なコンポーネントだけを選ぶ

まず適切なコンポーネントを見つける Copy Section

同梱のアドバイザーに、あなたの作業に合うコンポーネントを尋ねてください。

node scripts/ecc.js consult "security reviews" --target claude

一致するコンポーネント、関連するプロファイル、プレビュー/インストールコマンドが返されます。正確なファイル計画を確認したい場合は、インストール前にプレビューコマンドを使用してください。

明示的に skills や capability を指定してインストールすることもできます。

./install.sh --target claude --skills tdd-workflow,security-review
node scripts/ecc.js install --profile minimal --target claude --with capability:machine-learning

コンポーネントごとの手動コピーも可能です。各コンポーネントは完全に独立しています。

# agents のみ
cp agents/*.md ~/.claude/agents/

# rules ディレクトリ（common + 言語固有）
mkdir -p ~/.claude/rules/ecc
cp -r rules/common ~/.claude/rules/ecc/
cp -r rules/typescript ~/.claude/rules/ecc/   # 使用しているスタックを選択

# コア/汎用 skills のみ（Claude Code は ~/.claude/skills の直下から skills をロードします。
# 手動インストールを ~/.claude/skills/ecc/ 配下にネストしないでください）
mkdir -p ~/.claude/skills
cp -r .agents/skills/* ~/.claude/skills/
cp -r skills/search-first ~/.claude/skills/

# オプション: 移行期間中に維持されるスラッシュコマンド互換
mkdir -p ~/.claude/commands
cp commands/*.md ~/.claude/commands/

廃止されたシムは legacy-command-shims/ にあります。/tdd などの古い名前がまだ必要な場合にのみ、そこから個別のファイルをコピーしてください。

グローバル rules の代わりにプロジェクトローカル rules を使う

ECC の標準をすべての Claude Code セッションではなく一つのリポジトリにだけ適用したい場合は、プロジェクトローカル rules を使用します。

cd your-project
mkdir -p .claude/rules/ecc
cp -R /path/to/ECC/rules/common .claude/rules/ecc/
cp -R /path/to/ECC/rules/typescript .claude/rules/ecc/

rules は常時ロードされるコンテキストなので、common と実際に使用しているスタックのパック一つから始めてください。rules を手動でコピーする際は、相対参照が機能し続け、ファイル名が衝突しないように、中のファイルではなく言語ディレクトリ全体（たとえば rules/common や rules/golang）をコピーしてください。

完全手動の Claude インストール

plugin パスを意図的にスキップする場合にのみ使用してください。

git clone https://github.com/affaan-m/ECC.git
cd ECC
./install.sh --profile full

Windows:

git clone https://github.com/affaan-m/ECC.git
cd ECC
.\install.ps1 --profile full

このパスを選んだ場合は、そこで止めてください。/plugin install を追加で実行しないでください。

厳選した手動インストールの場合、Claude は ~/.claude/skills/ の直下の子として skills を検出します。~/.claude/skills/ecc/ 配下にネストしないでください。

hooks のインストール

リポジトリの生の hooks/hooks.json を ~/.claude/settings.json や ~/.claude/hooks/hooks.json にコピーしないでください。そのファイルは plugin/リポジトリ向けのものです。hook コマンドのパスが正しく書き換えられるよう、インストーラーを使用してください。

bash ./install.sh --target claude --modules hooks-runtime --enable-hooks

これにより hook スクリプトが ~/.claude/ 配下にインストールされ、解決済みの
hook エントリが ~/.claude/settings.json に登録されます。既存のユーザー設定と hooks は
保持されます。ECC 所有のエントリは安定した ID で追跡されるため、冪等な更新と
安全なアンインストールが可能です。

/plugin install で ECC をインストールした場合は、それらの hooks を settings.json にコピーしないでください。Claude Code v2.1+ はすでに plugin の hooks/hooks.json を自動ロードしており、settings.json に重複させると二重実行やクロスプラットフォームの hook 競合が発生します。

Windows では、Claude の設定ルートは %USERPROFILE%\.claude です。hook ランタイムは次のようにインストールしてください。

pwsh -File .\install.ps1 --target claude --modules hooks-runtime --enable-hooks

MCP の設定

Claude plugin インストールは、ECC に同梱された MCP サーバー定義を意図的に自動有効化しません。これにより、厳格なサードパーティゲートウェイでの plugin MCP ツール名の長すぎる問題を回避しつつ、手動での MCP セットアップは引き続き可能です。

稼働中の Claude Code サーバー変更には、Claude Code の /mcp コマンドまたは CLI 管理の MCP セットアップを使用してください。Claude Code はそれらの選択を ~/.claude.json に永続化します。リポジトリローカルの MCP アクセスには、mcp-configs/mcp-servers.json から必要な MCP サーバー定義をプロジェクトスコープの .mcp.json にコピーしてください。

ECC が同梱するデフォルトコネクターはちょうど一つ（chrome-devtools）だけです。それ以外はすべて CLI/REST API をラップする skill か、オプトインのカタログエントリです。このルールと、以前の六つのデフォルトを廃止した 2026年6月の監査は docs/MCP-CONNECTOR-POLICY.md にあります。

ECC 同梱の MCP を自分でも別途実行している場合は、次を設定してください。

export ECC_DISABLED_MCPS="chrome-devtools"

ECC 管理のインストールおよび Codex 同期フローは、重複を再追加する代わりに、それらの同梱サーバーをスキップまたは削除します。ECC_DISABLED_MCPS は ECC のインストール/同期フィルターであり、稼働中の Claude Code のトグルではありません。

重要: YOUR_*_HERE プレースホルダーを実際の API キーに置き換えてください。

マルチモデル commands には追加のセットアップが必要

multi-* commands は、基本の plugin/rules インストールには含まれていません。

/multi-plan、/multi-execute、/multi-backend、/multi-frontend、/multi-workflow を使用するには、ccg-workflow ランタイムもインストールする必要があります。上流の CCG インストールガイドを使って正確なリリースを選択・レビューし、そのインストール済みランタイムを初期化してください。ECC は CCG を同梱しておらず、互換性があり監査済みの CCG リリースを保証するものでもありません。このガイドは、特定されていないレジストリバージョンをブートストラップしません。

このランタイムは、これらの commands が期待する外部依存関係を提供します。たとえば次のものです。

• ~/.claude/bin/codeagent-wrapper
• ~/.claude/.ccg/prompts/*

ccg-workflow がない場合、これらの multi-* commands は正しく動作しません。

リセット、修復、またはアンインストール

ECC のリセット / アンインストール Copy Section

ユニバーサルパッケージからインストールした場合は、インストール時に使用したのと同じ
プロジェクトディレクトリから次のコマンドを実行してください。

npx [email protected] list-installed
npx [email protected] doctor
npx [email protected] repair
npx [email protected] uninstall --dry-run
npx [email protected] uninstall