Claude代码智能体系统

Install dependencies (pick your package manager)

npm install # or: pnpm install | yarn install | bun install

Multi-model commands require additional setup

WARNING: multi-* commands are not covered by the base plugin/rules install above. To use /multi-plan, /multi-execute, /multi-backend, /multi-frontend, and /multi-workflow, you must also install the ccg-workflow runtime. Initialize it with npx ccg-workflow. 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.

---

Requirements

v1.9.0 — Selective Install & Language Expansion (Mar 2026)

• Selective install architecture — Manifest-driven install pipeline with install-plan.js and install-apply.js for targeted component installation. State store tracks what's installed and enables incremental updates.
• 6 new agents — typescript-reviewer, pytorch-build-resolver, java-build-resolver, java-reviewer, kotlin-reviewer, kotlin-build-resolver expand language coverage to 10 languages.
• New skills — pytorch-patterns for deep learning workflows, documentation-lookup for API reference research, bun-runtime and nextjs-turbopack for modern JS toolchains, plus 8 operational domain skills and mcp-server-patterns.
• Session & state infrastructure — SQLite state store with query CLI, session adapters for structured recording, skill evolution foundation for self-improving skills.
• Orchestration overhaul — Harness audit scoring made deterministic, orchestration status and launcher compatibility hardened, observer loop prevention with 5-layer guard.
• Observer reliability — Memory explosion fix with throttling and tail sampling, sandbox access fix, lazy-start logic, and re-entrancy guard.
• 12 language ecosystems — New rules for Java, PHP, Perl, Kotlin/Android/KMP, C++, and Rust join existing TypeScript, Python, Go, and common rules.
• Community contributions — Korean and Chinese translations, biome hook optimization, video processing skills, operational skills, PowerShell installer, Antigravity IDE support.
• CI hardening — 19 test failure fixes, catalog count enforcement, install manifest validation, and full test suite green.

v1.7.0 — Cross-Platform Expansion & Presentation Builder (Feb 2026)

• Codex app + CLI support — Direct AGENTS.md-based Codex support, installer targeting, and Codex docs
• frontend-slides skill — Zero-dependency HTML presentation builder with PPTX conversion guidance and strict viewport-fit rules
• 5 new generic business/content skills — article-writing, content-engine, market-research, investor-materials, investor-outreach
• Broader tool coverage — Cursor, Codex, and OpenCode support tightened so the same repo ships cleanly across all major harnesses
• 992 internal tests — Expanded validation and regression coverage across plugin, hooks, skills, and packaging

v1.4.0 — Multi-Language Rules, Installation Wizard & PM2 (Feb 2026)

• Interactive installation wizard — New configure-ecc skill provides guided setup with merge/overwrite detection
• PM2 & multi-agent orchestration — 6 new commands (/pm2, /multi-plan, /multi-execute, /multi-backend, /multi-frontend, /multi-workflow) for managing complex multi-service workflows
• Multi-language rules architecture — Rules restructured from flat files into common/ + typescript/ + python/ + golang/ directories. Install only the languages you need
• Chinese (zh-CN) translations — Complete translation of all agents, commands, skills, and rules (80+ files)
• GitHub Sponsors support — Sponsor the project via GitHub Sponsors
• Enhanced CONTRIBUTING.md — Detailed PR templates for each contribution type

Step 1: Install the Plugin (Recommended)

NOTE: The plugin is convenient, but the OSS installer below is still the most reliable path if your Claude Code build has trouble resolving self-hosted marketplace entries.

```bash

Install plugin

/plugin install ecc@ecc ```

Step 2: Install Rules Only If You Need Them

WARNING: Important: Claude Code plugins cannot distribute rules automatically. If you already installed ECC via /plugin install, do not run ./install.sh --profile full, .\install.ps1 --profile full, or npx ecc-install --profile full afterward. The plugin already loads ECC skills, commands, and hooks. Running the full installer after a plugin install copies those same surfaces into your user directories and can create duplicate skills plus duplicate runtime behavior. For plugin installs, manually copy only the rules/ directories you want under ~/.claude/rules/ecc/. Start with rules/common plus one language or framework pack you actually use. Do not copy every rules directory unless you explicitly want all of that context in Claude. Use the full installer only when you are doing a fully manual ECC install instead of the plugin path. If your local Claude setup was wiped or reset, that does not mean you need to repurchase ECC. Start with node scripts/ecc.js list-installed, then run node scripts/ecc.js doctor and node scripts/ecc.js repair before reinstalling anything. That usually restores ECC-managed files without rebuilding your setup. If the problem is account or marketplace access for ECC Tools, handle billing/account recovery separately.

```bash

Plugin install path: copy only ECC rules into an ECC-owned namespace

mkdir -p ~/.claude/rules/ecc cp -R rules/common ~/.claude/rules/ecc/ cp -R rules/typescript ~/.claude/rules/ecc/

Fully manual ECC install path (use this instead of /plugin install)

./install.sh --profile full

Plugin install path: copy only ECC rules into an ECC-owned namespace

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/"

Fully manual ECC install path (use this instead of /plugin install)

.\install.ps1 --profile full

npx ecc-install --profile full

```

For manual install instructions see the README in the rules/ folder. 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 install (Fallback)

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

./install.sh --profile full

```powershell .\install.ps1 --profile full

Reset / Uninstall ECC

If ECC feels duplicated, intrusive, or broken, do not keep reinstalling it on top of itself.

• Plugin path: remove the plugin from Claude Code, then delete the specific rule folders you manually copied under ~/.claude/rules/ecc/.
• Manual installer / CLI path: from the repo root, preview removal first:

node scripts/uninstall.js --dry-run

Then remove ECC-managed files:

node scripts/uninstall.js

You can also use the lifecycle wrapper:

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

ECC only removes files recorded in its install-state. It will not delete unrelated files it did not install.

If you stacked methods, clean up in this order:

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

Plugin install uses the canonical namespaced form

/ecc:plan "Add user authentication"

Manual install keeps the shorter slash form:

Disable SessionStart additional context entirely for low-context/local-model setups

export ECC_SESSION_START_CONTEXT=off

Quick scan (no install needed)

npx ecc-agentshield scan

Installation

Option 1: Install as Plugin (Recommended)

The easiest way to use this repo - install as a Claude Code plugin:

```bash

Install the plugin

/plugin install ecc@ecc

Or add directly to your `~/.claude/settings.json`:

This gives you instant access to all commands, agents, skills, and hooks.

> **Note:** The Claude Code plugin system does not support distributing `rules` via plugins ([upstream limitation](https://code.claude.com/docs/en/plugins-reference)). You need to install rules manually:
>
> 

---

Option 2: Manual Installation

If you prefer manual control over what's installed:

```bash

The Guides

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

Shorthand Guide Setup, foundations, philosophy. Read this first.	Longform Guide Token optimization, memory persistence, evals, parallelization.	Security Guide Attack vectors, sandboxing, sanitization, CVEs, AgentShield.

---

Quick Start

Get up and running in under 2 minutes:

Quick Start (Cursor)

```bash

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 in Claude Code.

Generate secure config from scratch

npx ecc-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

Copy agents to your Claude config

cp agents/*.md ~/.claude/agents/

Optional: add niche/framework-specific skills only when needed

Optional: keep maintained slash-command compatibility during migration

mkdir -p ~/.claude/commands cp commands/*.md ~/.claude/commands/

Keep context/scope/loop warnings but suppress API-rate cost estimates

export ECC_CONTEXT_MONITOR_COST_WARNINGS=off

Windows PowerShell:

---

Claude Code CLI Version

Minimum version: v2.1.0 or later

This plugin requires Claude Code CLI v2.1.0+ due to changes in how the plugin system handles hooks.

Check your version:

claude --version

v2.0.0-rc.1 — Surface Refresh, Operator Workflows, and ECC 2.0 Alpha (Apr 2026)

• Dashboard GUI — New Tkinter-based desktop application (ecc_dashboard.py or npm run dashboard) with dark/light theme toggle, font customization, and project logo in header and taskbar.
• Public surface synced to the live repo — metadata, catalog counts, plugin manifests, and install-facing docs now match the actual OSS surface: 60 agents, 232 skills, and 75 legacy command shims.
• Operator and outbound workflow expansion — brand-voice, social-graph-ranker, connections-optimizer, customer-billing-ops, ecc-tools-cost-audit, google-workspace-ops, project-flow-ops, and workspace-surface-audit round out the operator lane.
• Media and launch tooling — manim-video, remotion-video-creation, and upgraded social publishing surfaces make technical explainers and launch content part of the same system.
• Framework and product surface growth — nestjs-patterns, richer Codex/OpenCode install surfaces, and expanded cross-harness packaging keep the repo usable beyond Claude Code alone.
• ECC 2.0 alpha is in-tree — the Rust control-plane prototype in ecc2/ now builds locally and exposes dashboard, start, sessions, status, stop, resume, and daemon commands. It is usable as an alpha, not yet a general release.
• Operator status snapshots — ecc status --markdown --write status.md turns the local state store into a portable handoff covering readiness, active sessions, skill-run health, install health, pending governance events, and linked work items from Linear/GitHub/handoffs. Use ecc work-items upsert ... for manual entries, ecc work-items sync-github --repo owner/repo for PR/issue queue state, and ecc status --exit-code to fail automation when readiness needs attention.
• Ecosystem hardening — AgentShield, ECC Tools cost controls, billing portal work, and website refreshes continue to ship around the core plugin instead of drifting into separate silos.

v1.3.0 — OpenCode Plugin Support (Feb 2026)

• Full OpenCode integration — 12 agents, 24 commands, 16 skills with hook support via OpenCode's plugin system (20+ event types)
• 3 native custom tools — run-tests, check-coverage, security-audit
• LLM documentation — llms.txt for comprehensive OpenCode docs

Find the right components first

If you are not sure which ECC profile or component to install, ask the packaged advisor from any project:

npx ecc 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.

For production ML/MLOps workflows, keep the install opt-in and component-scoped:

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

Skills are the primary workflow surface.

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:

```bash

Copy skills first (primary workflow surface)

TDD Workflow

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

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

---

FAQ

<details> <summary><b>How do I check which agents/commands are installed?</b></summary>

/plugin list ecc@ecc

This shows all available agents, commands, and skills from the plugin. </details>

<details> <summary><b>My hooks aren't working / I see "Duplicate hooks file" errors</b></summary>

This is the most common issue. 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. </details>

<details> <summary><b>Can I use ECC with Claude Code on a custom API endpoint or model gateway?</b></summary>

Yes. ECC does not hardcode Anthropic-hosted transport settings. It runs locally through Claude Code's normal CLI/plugin surface, so it works with:

• Anthropic-hosted Claude Code
• Official Claude Code gateway setups using ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN
• Compatible custom endpoints that speak the Anthropic API Claude Code expects

Minimal 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.

Official references: - Claude Code LLM gateway docs - Claude Code model configuration docs

</details>

<details> <summary><b>My context window is shrinking / Claude is running out of context</b></summary>

Too many MCP servers eat your context. Each MCP tool description consumes tokens from your 200k window, potentially reducing it to ~70k. SessionStart context is capped at 8000 characters by default; lower it with ECC_SESSION_START_MAX_CHARS=4000 or disable it with ECC_SESSION_START_CONTEXT=off for local-model or low-context setups.

Fix: Disable unused MCPs from Claude Code with /mcp. Claude Code writes those runtime choices to ~/.claude.json; .claude/settings.json and .claude/settings.local.json are not reliable toggles for already-loaded MCP servers.

Keep under 10 MCPs enabled and under 80 tools active. </details>

<details> <summary><b>Can I use only some components (e.g., just agents)?</b></summary>

Yes. Use Option 2 (manual installation) and copy only what you need:

```bash