Files
ECC/.opencode
MohammadAminDHM 76f8ea4bd3 fix(opencode): address round-2 review findings on the hooks surface
- R2-1: the V2 execute.after adapter passed { result: ... } as the tool
  output; skill-run-tracker derives outcomes from error fields on the
  response itself, so failed skills recorded as successes. The adapter
  now forwards the raw event.result ?? event.output. Covered by a T05
  assertion that an is_error skill event records outcome failure and a
  clean event still records success.
- R2-2: cmd.exe expands %VAR% and honors embedded quotes even inside
  double quotes, so escaping " was unsafe. spawnCommand now refuses
  arguments carrying ", %, CR or LF (nothing spawns; the rejection
  surfaces through the formatter's catch) and emits the canonical /s
  form with one outer quote pair around the whole command. T01 asserts
  the outer pair, strips it before inspecting the inner quoting, and
  covers two refusal payloads.
- R2-3: repo review rules ban console.log; the client-less log fallback
  and the startup line now use console.info (identical stdout behavior).
- R2-4: declined installs recorded before the barrel split retained the
  old module/factory stub in plugins/index.ts, and a later selective
  install (e.g. commands-core) has no operation rewriting it, so the
  strict deactivation gate failed the install after all writes landed.
  The strict branch now migrates such retained files in place only when
  ownership is proven twice (managed-recorded contentSha256 matches disk
  AND disk equals an exact historical disabled-stub payload), written
  through writeFileNoFollow with that digest as expectedContent;
  anything else keeps failing closed. The preflight branch accepts an
  already-inactive recorded config under the same digest-verified
  condition, since selective installs legitimately plan no .opencode
  writes. New lifecycle test covers both the migration (install ok,
  doctor clean, ownership retained) and the refusal path (mis-recorded
  digest never grants a rewrite).
2026-11-03 20:13:58 +03:30
..

OpenCode ECC Plugin

WARNING: This README is specific to OpenCode usage. If you installed ECC via npm (e.g. npm install opencode-ecc), refer to the root README instead.

ECC plugin for OpenCode - agents, commands, hooks, and skills.

Installation

Installation Overview

There are two ways to use ECC:

  1. npm package (recommended for most users) Install via npm/bun/yarn and use the ecc-install CLI to set up rules and agents.

  2. Direct clone / plugin mode Clone the repository and run OpenCode directly inside it.

Choose the method that matches your workflow below.

Option 1: npm Package

npm install ecc-universal

Add to your opencode.json:

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

This loads the ECC OpenCode plugin module from npm:

  • hook/event integrations
  • bundled custom tools exported by the plugin

It does not auto-register the full ECC command/agent/instruction catalog in your project config. For the full OpenCode setup, either:

  • run OpenCode inside this repository, or
  • copy the relevant .opencode/commands/, .opencode/prompts/, .opencode/instructions/, and the instructions, agent, and command config entries into your own project

After installation, the ecc-install CLI is also available:

npx ecc-universal install typescript

Option 2: Direct Use

Clone and run OpenCode in the repository:

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

If you also want to apply the ECC home install (node scripts/install-apply.js --target opencode --profile full), build the plugin first so the compiled payload at .opencode/dist/ exists:

node scripts/build-opencode.js   # or: npm run build:opencode
node scripts/install-apply.js --target opencode --profile full

Without .opencode/dist/index.js, OpenCode will detect the slash commands but silently skip plugin hooks and tools. The installer now fails fast with a pointer to this command if the build step is missing.

Features

Agents (26)

Agent Description
build Primary coding agent for development work
planner Implementation planning
architect System design
code-reviewer Code review
security-reviewer Security analysis
tdd-guide Test-driven development
build-error-resolver Build error fixes
e2e-runner E2E testing
doc-updater Documentation
refactor-cleaner Dead code cleanup
go-reviewer Go code review
go-build-resolver Go build errors
database-reviewer Database optimization
docs-lookup Documentation lookup via Context7
harness-optimizer Harness config tuning
java-reviewer Java code review
java-build-resolver Java build errors
kotlin-reviewer Kotlin code review
kotlin-build-resolver Kotlin build errors
loop-operator Autonomous loop execution
php-reviewer PHP code review
python-reviewer Python code review
rust-reviewer Rust code review
rust-build-resolver Rust build errors
cpp-reviewer C++ code review
cpp-build-resolver C++ build errors

Commands (26)

Command Description
/plan Create implementation plan
/tdd TDD workflow
/code-review Review code changes
/security Security review
/build-fix Fix build errors
/e2e E2E tests
/refactor-clean Remove dead code
/orchestrate Multi-agent workflow
/learn Extract patterns
/checkpoint Save progress
/verify Verification loop
/eval Evaluation
/update-docs Update docs
/update-codemaps Update codemaps
/test-coverage Coverage analysis
/setup-pm Package manager
/go-review Go code review
/go-test Go TDD
/go-build Go build fix
/skill-create Generate skills
/instinct-status View instincts
/instinct-import Import instincts
/instinct-export Export instincts
/evolve Cluster instincts
/promote Promote project instincts
/projects List known projects

Plugin Hooks

Hook Event Purpose
Prettier file.edited Auto-format JS/TS
TypeScript tool.execute.after Check for type errors
console.log file.edited Warn about debug statements
Notification session.idle Desktop notification (cross-platform)
Security tool.execute.before Check for secrets
Git Push Reminder tool.execute.before Remind to review before pushing
Doc File Warning tool.execute.before Warn about unnecessary documentation
Long Command Reminder tool.execute.before Remind about long-running commands
Session Context session.created Load project context
Console Log Audit session.idle Audit edited files for console.log
File Watcher file.watcher.updated Track file system changes
Todo Progress todo.updated Log task completion progress
Shell Environment shell.env Inject environment variables
Session Compacting experimental.session.compacting Preserve context across compaction
Permission Auto-Approve permission.ask Auto-approve safe operations

Custom Tools

Tool Description
run-tests Run test suite with options
check-coverage Analyze test coverage
security-audit Security vulnerability scan
format-code Detect formatter and return command
lint-check Detect linter and return command
git-summary Generate git summary with branch, status, and diff
changed-files List files changed in session as a navigable tree
dependency-analyzer Analyze dependencies for outdated, vulnerable, and unused packages

Hook Event Mapping

OpenCode's plugin system maps to Claude Code hooks:

Claude Code OpenCode
PreToolUse tool.execute.before
PostToolUse tool.execute.after
Stop session.idle
SessionStart session.created
SessionEnd session.deleted

OpenCode has 20+ additional events not available in Claude Code.

Hook Runtime Controls

OpenCode plugin hooks honor the same runtime controls used by Claude Code/Cursor:

export ECC_HOOK_PROFILE=standard
export ECC_DISABLED_HOOKS="pre:bash:tmux-reminder,post:edit:typecheck"
  • ECC_HOOK_PROFILE: minimal, standard (default), strict
  • ECC_DISABLED_HOOKS: comma-separated hook IDs to disable

Skills

The default OpenCode config loads 11 curated ECC skills via the instructions array:

  • coding-standards
  • backend-patterns
  • frontend-patterns
  • frontend-slides
  • security-review
  • tdd-workflow
  • strategic-compact
  • eval-harness
  • verification-loop
  • api-design
  • e2e-testing

Additional specialized skills are shipped in skills/ but not loaded by default to keep OpenCode sessions lean:

  • article-writing
  • content-engine
  • market-research
  • investor-materials
  • investor-outreach

Configuration

Full configuration in opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "instructions": [
    "skills/tdd-workflow/SKILL.md",
    "skills/security-review/SKILL.md"
  ],
  "agent": { /* 12 agents */ },
  "command": { /* 24 commands */ }
}

The reference config intentionally leaves model selection to OpenCode. Connect a provider and select a model in OpenCode; ECC's primary agent uses that global selection, and its subagents inherit the invoking primary agent's model.

License

MIT

Home-target installations keep plugins/index.ts inert even with hooks enabled. OpenCode 2.x loads plugins by scanning every root-level file in a plugins directory; it does not accept configured file paths — an entry like "./plugins/ecc-hooks.ts" in the plugin array logs "configured plugin path must be a directory" and is skipped, so the config ships without any plugin entry and plugins/ecc-hooks.ts is discovered from the directory. The barrel stays a distinct-id stub (ecc-hooks-entry) because re-exporting the real definition from index.ts would register the id ecc-hooks twice — once per discovered entry — and OpenCode marks every entry after the first as failed (Duplicate plugin ID). The source and published package barrel remain available for module imports; the package ./plugins subpath maps to the live dist/plugins/ecc-hooks.js entry point.