convez.ai
PluginAutomaçãoAvançado
affaan-m

ECC — Sistema Operacional para Agentes de IA

affaan-m/ECC

Sistema operacional nativo para workflows de agentes IA multi-plataforma

Ver no GitHub
ExcelentePluginScore · de 0 a 100

MCP Server que implementa um sistema completo de otimização para agentes de IA, incluindo gerenciamento de skills, instintos, memória, segurança e desenvolvimento orientado por pesquisa. Funciona com Claude Code, Codex, Cursor e outras plataformas de IA, oferecendo workflows de produção com hooks, regras, configurações MCP e integração multi-plataforma.

Instalação

$npx convez-ai affaan-m/ECC

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
306 mil
Forks
45 mil
Acompanhando
1,5 mil
Saúde
100%
Último commit
há 2 dias
Versão
v2.2.3
Issues abertas
164
Contribuidores
236

Casos de uso

  • Otimizar performance e memória de agentes de código
  • Gerenciar skills e instintos em múltiplos harnesses de IA
  • Implementar segurança e scanning contínuo para agentes
  • Unificar workflows entre Cursor, Claude Code, Codex e GitHub Copilot
  • Desenvolvimento research-first com aprendizado contínuo

Veredito

Sistema maduro e bem-estabelecido (210K+ stars) que resolve problemas reais de coordenação e otimização de agentes IA em produção. Exige expertise técnica significativa para aproveitamento completo, mas oferece valor expressivo para equipes trabalhando com múltiplos harnesses de IA.

README em português

Language: English | Português (Brasil) | 简体中文 | 繁體中文 | 日本語 | 한국어 | Türkçe | Русский | Tiếng Việt | ไทย | Deutsch | Español

ECC — o sistema operacional de harness para agentes

Stars Forks Contributors npm ecc-universal npm ecc-agentshield GitHub App Install License Shell TypeScript Python Go Java Perl Markdown

211.9K+ estrelas | 32.5K+ forks | 230+ contribuidores | 12+ ecossistemas de linguagem | Fluxos de trabalho cross-harness para agentes


Idioma / 语言 / 語言 / Dil / Язык / Ngôn ngữ / Idioma

English | Português (Brasil) | 简体中文 | 繁體中文 | 日本語 | 한국어 | Türkçe | Русский | Tiếng Việt | ไทย | Deutsch | Español


O sistema operacional nativo de harness para trabalho com agentes. Construído a partir de fluxos de engenharia multi-harness do mundo real.

Não apenas configurações. Um sistema completo: habilidades, instintos, otimização de memória, aprendizado contínuo, varredura de segurança e desenvolvimento focado em pesquisa. Agentes prontos para produção, skills, hooks, regras, configurações MCP e shims de comandos legados evoluídos ao longo de mais de 10 meses de uso diário intenso construindo produtos reais.

Funciona através do Codex, Claude Code, Cursor, OpenCode, Gemini, Zed, GitHub Copilot e outros harnesses de agentes de IA.

A ECC v2.0.0 adiciona a história pública da operadora Hermes por cima dessa camada reutilizável: comece com o guia de configuração do Hermes, depois revise as notas de lançamento 2.0.0 e a arquitetura cross-harness.


OSS continua gratuito. Este repositório é licenciado MIT para sempre. ECC Pro é o aplicativo GitHub hospedado para repositórios privados. Patrocinadores e assinantes do plano Pro financiam o trabalho — por isso um único mantenedor lança semanalmente em 7 harnesses.

Patrocinadores empresariais

Patrocinadores da comunidade: Mike Morgan · @jasonwu513 · @1anter · @massimotodaro · @meadmccabe

Torne-se um Patrocinador · Níveis de Patrocínio · Programa de Patrocínio

Este repositório contém apenas o código-fonte bruto. Os guias explicam tudo.

TópicoO que você aprenderá
Otimização de TokensSeleção do modelo, redução do prompt do sistema e processos em segundo plano
Persistência de MemóriaHooks que salvam/carregam o contexto automaticamente entre sessões
Aprendizado ContínuoExtração automática de padrões das sessões para habilidades reutilizáveis
Loops de VerificaçãoCheckpoints vs avaliações contínuas, tipos de avaliador e métricas pass@k
ParalelizaçãoGit worktrees, método cascata e quando escalar instâncias
Orquestração de SubagentesO problema do contexto, padrão de recuperação iterativa

Novidades

v2.0.0 — Sistema Operacional Agent Harness (Jun 2026)

Graduação estável da linha 2.0: 261 habilidades, o substrato do painel de controle (adaptadores de sessão + inventário MCP), serviço worktree-lifecycle, a família orch-* de orquestradores e o lançamento da comunidade ECC Discord. Notas completas: docs/releases/2.0.0/release-notes.md.

v2.0.0-rc.1 — Atualização da Interface, Workflows do Operador e ECC 2.0 Alpha (Abr 2026)

  • Dashboard GUI — Novo aplicativo desktop baseado em Tkinter (ecc_dashboard.py ou npm run dashboard) com alternância de tema escuro/claro, personalização de fontes e logo do projeto no cabeçalho e barra de tarefas.
  • Interface pública sincronizada ao repositório vivo — metadados, contagens do catálogo, manifestos de plugins e docs voltadas para instalação agora correspondem à superfície OSS real: 64 agentes, 262 habilidades e 84 shims de comando legados.
  • Expansão de operadores e workflows outbound — brand-voice, social-graph-ranker, connections-optimizer, customer-billing-ops, ecc-tools-cost-audit, google-workspace-ops, project-flow-ops e workspace-surface-audit completam a faixa do operador.
  • Ferramentas de mídia e lançamento — manim-video, remotion-video-creation e superfícies aprimoradas para publicação social tornam explicadores técnicos e conteúdo de lançamento parte do mesmo sistema.
  • Crescimento da superfície do framework e produto — nestjs-patterns, superfícies de instalação Codex/OpenCode mais ricas e empacotamento cruzado entre harnesses mantêm o repositório utilizável além do Claude Code sozinho.
  • Pacote de habilidades Itô prediction-market — ito-market-intelligence, ito-basket-compare, ito-trade-planner, ito-data-atlas-agent, prediction-market-oracle-research e prediction-market-risk-review adicionam workflows públicos, não consultivos para mercado/cesta enquanto mantêm o acesso à API Itô vivo segregado das faturas ECC Tools.
  • Pacote de habilidades Otimização — parallel-execution-optimizer, benchmark-optimization-loop, data-throughput-accelerator, latency-critical-systems e recursive-decision-ledger transformam prompts repetidos de velocidade/recursão em workflows limitados de benchmark, throughput e decision-ledger.
  • ECC 2.0 alpha está in-tree — o protótipo do plano de controle Rust em ecc2/ agora compila localmente e expõe comandos dashboard, start, sessions, status, stop, resume e daemon. É utilizável como alpha, não ainda uma release geral.
  • Snapshots de status dos operadores — ecc status --markdown --write status.md transforma o store local de estado em um handoff portátil cobrindo prontidão, sessões ativas, saúde da execução de habilidades, saúde da instalação, eventos pendentes de governança e itens vinculados do Linear/GitHub/handoffs. Use ecc work-items upsert ... para entradas manuais, ecc work-items sync-github --repo owner/repo para estado da fila PR/issue e ecc status --exit-code para falhar automação quando a prontidão precisa de atenção.
  • Endurecimento do ecossistema — AgentShield, controles de custo ECC Tools, portal de faturamento e atualizações do site continuam sendo lançados em torno do plugin central ao invés de se dispersar em silos separados.

v1.9.0 — Instalação Seletiva e Expansão de Idiomas (Mar 2026)

  • Arquitetura de instalação seletiva — Pipeline de instalação impulsionado por manifesto com install-plan.js e install-apply.js para instalação direcionada de componentes. O repositório de estado rastreia o que está instalado e permite atualizações incrementais.
  • 6 novos agentes — typescript-reviewer, pytorch-build-resolver, java-build-resolver, java-reviewer, kotlin-reviewer, kotlin-build-resolver expandem a cobertura linguística para 10 idiomas.
  • Novas habilidades (skills) — pytorch-patterns para fluxos de trabalho de deep learning, documentation-lookup para pesquisa em referências de API, bun-runtime e nextjs-turbopack para toolchains modernas de JS, além de 8 habilidades operacionais de domínio e mcp-server-patterns.
  • Infraestrutura de sessão e estado — Repositório SQLite com CLI de consulta, adaptadores de sessão para gravação estruturada e fundação para evolução de skills em auto-melhoria.
  • Revisão da orquestração — Pontuação de auditoria do Harness tornou-se determinística; compatibilidade entre status de orquestração e launcher reforçada; prevenção de loop de observador com guarda de 5 camadas.
  • Confiabilidade do Observador — Correção para explosão de memória com throttling e amostragem final, correção de acesso ao sandbox, lógica de inicialização preguiçosa (lazy-start) e guarda contra reentrância.
  • 12 ecossistemas linguísticos — Novas regras para Java, PHP, Perl, Kotlin/Android/KMP, C++ e Rust se juntam às existentes TypeScript, Python, Go e regras comuns.
  • Contribuições da comunidade — Traduções em coreano e chinês, otimização de hook do biome, habilidades de processamento de vídeo, habilidades operacionais, instalador PowerShell e suporte ao IDE Antigravity.
  • Endurecimento do CI (Integração Contínua) — Correções para 19 falhas de teste, enforcement da contagem do catálogo, validação do manifesto de instalação e suíte completa verde no teste.

v1.8.0 — Sistema de Performance do Harness (Mar 2026)

  • Lançamento focado em Harness — ECC é agora explicitamente enquadrado como um sistema de performance de agente harness, não apenas um pacote de configuração.
  • Revisão da confiabilidade dos hooks — Fallback raiz SessionStart, resumos de sessão na fase Stop e hooks baseados em script substituindo frágeis one-liners inline.
  • Controles de runtime do hook — ECC_HOOK_PROFILE=minimal|standard|strict e ECC_DISABLED_HOOKS=... para gating no tempo de execução sem editar arquivos de hook.
  • Novos comandos harness — /harness-audit, /loop-start, /loop-status, /quality-gate, /model-route.
  • NanoClaw v2 — roteamento de modelo, hot-load de skills, branch/busca/exportar/compactar/métricas da sessão.
  • Paridade cross-harness — comportamento apertado entre Claude Code, Cursor, OpenCode e app/CLI do Codex.
  • 997 testes internos passando — suíte completa verde após refatoração de hook/runtime e atualizações de compatibilidade.

v1.7.0 — Expansão Cross-Platform & Construtor de Apresentações (Fev 2026)

  • Suporte ao app + CLI do Codex — Suporte direto baseado em AGENTS.md, instalação direcionada e docs do Codex
  • Habilidade frontend-slides — Construtor HTML de apresentações sem dependências com orientação para conversão PPTX e regras estritas de viewport-fit.
  • 5 novas habilidades genéricas de negócio/conteúdo — article-writing, content-engine, market-research, investor-materials, investor-outreach
  • Cobertura mais ampla de ferramentas — Suporte apertado para Cursor, Codex e OpenCode para que o mesmo repositório seja distribuído limpo em todos os principais harnesses.
  • 992 testes internos — Validação expandida e cobertura de regressão através de plugins, hooks, skills e empacotamento.

v1.6.0 — CLI do Codex, AgentShield & Marketplace (Fev 2026)

  • Suporte à CLI do Codex — Novo comando /codex-setup gera codex.md para compatibilidade com a CLI OpenAI Codex
  • 7 novas habilidades — search-first, swift-actor-persistence, swift-protocol-di-testing, regex-vs-llm-structured-text, content-hash-cache-pattern, cost-aware-llm-pipeline, skill-stocktake
  • Integração AgentShield — A habilidade /security-scan executa o AgentShield diretamente do Claude Code; 1282 testes, 102 regras.
  • GitHub Marketplace — App GitHub ECC Tools disponível em github.com/marketplace/ecc-tools com tiers free/pro/enterprise.
  • +30 PRs da comunidade fundidos — Contribuições de 30 contribuidores através de 6 idiomas.
  • 978 testes internos — Suíte expandida de validação através de agentes, skills, comandos, hooks e regras.

v1.4.1 — Correção de Bug (Fev 2026)

  • Corrigida perda de conteúdo na importação do instinct — parse_instinct_file() estava silenciosamente descartando todo o conteúdo após a frontmatter (seções Action, Evidence, Examples) durante /instinct-import. (#148, #161)

v1.4.0 — Regras Multilíngues, Assistente de Instalação & PM2 (Fev 2026)

  • Assistente de instalação interativo — A nova habilidade configure-ecc oferece configuração guiada com detecção de mesclagem/sobrescrita
  • Orquestração PM2 e multi-agente — 6 novos comandos (/pm2, /multi-plan, /multi-execute, /multi-backend, /multi-frontend, /multi-workflow) para gerenciar fluxos de trabalho complexos com múltiplos serviços
  • Arquitetura de regras multilíngues — Regras reestruturadas de arquivos planos em diretórios common/ + typescript/ + python/ + golang/. Instale apenas as linguagens que precisar
  • Traduções para chinês (zh-CN) — Tradução completa de todos os agentes, comandos, habilidades e regras (+80 arquivos)
  • Suporte a GitHub Sponsors — Apoie o projeto via GitHub Sponsors
  • Contributing.md aprimorado — Modelos detalhados de PR para cada tipo de contribuição

v1.3.0 — Suporte ao Plugin OpenCode (Fev 2026)

  • Integração completa com OpenCode — 12 agentes, 24 comandos e 16 habilidades com suporte a hooks via sistema de plugins do OpenCode (+20 tipos de eventos)
  • 3 ferramentas nativas personalizadas — run-tests, check-coverage, security-audit
  • Documentação LLM — llms.txt para documentação completa do OpenCode

v1.2.0 — Comandos e Habilidades Unificados (Fev 2026)

  • Suporte a Python/Django — Padrões Django, segurança, TDD e habilidades de verificação
  • Habilidades Java Spring Boot — Padrões, segurança, TDD e verificação para Spring Boot
  • Gerenciamento de sessão — Comando /sessions para histórico de sessões
  • Aprendizado contínuo v2 — Aprendizado baseado em instinto com pontuação de confiança, import/export e evolução

Veja o changelog completo em Releases.


Início Rápido

Coloque-se para rodar em menos de 2 minutos:

Escolha apenas um caminho

A maioria dos usuários do Claude Code deve usar exatamente um caminho de instalação:

  • Padrão recomendado: instale o plugin do Claude Code, depois copie apenas os diretórios de regras que você realmente deseja.
  • Use o instalador manual apenas se quiser controle mais granular, evitar totalmente a rota do plugin ou sua build do Claude Code tiver problemas ao resolver entradas da marketplace auto-hospedada.
  • Não empilhe métodos de instalação. A configuração quebrada mais comum é: /plugin install primeiro, depois install.sh --profile full ou npx ecc-install --profile full em seguida.

Se você já camadas múltiplas instalações e as coisas parecem duplicadas, pule direto para Resetar / Desinstalar ECC.

Caminho de baixo contexto / sem hooks

Se os hooks parecerem muito globais ou você quiser apenas as regras, agentes, comandos e habilidades de fluxo central do ECC, pule o plugin e use o perfil manual mínimo:

./install.sh --profile minimal --target claude
.\install.ps1 --profile minimal --target claude
# or
npx ecc-install --profile minimal --target claude

Este perfil intencionalmente exclui hooks-runtime.

Se quiser o perfil central normal mas precisa dos hooks desligados, use:

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

Adicione os hooks depois apenas se quiser enforcement em tempo de execução:

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

Encontre os componentes certos primeiro

Se não tiver certeza qual perfil ou componente do ECC instalar, pergunte ao conselheiro embutido de qualquer projeto:

npx ecc consult "security reviews" --target claude

Ele retorna componentes correspondentes, perfis relacionados e comandos de preview/installação. Use o comando de preview antes da instalação se quiser inspecionar o plano de arquivos exato.

Para fluxos de trabalho ML/MLOps em produção, mantenha a instalação opt-in e com escopo de componente:

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

Passo 1: Instale o Plugin (Recomendado)

NOTA: O plugin é conveniente, mas o instalador OSS abaixo ainda é o caminho mais confiável se sua build do Claude Code tiver problemas ao resolver entradas da marketplace auto-hospedada.

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

# Install plugin
/plugin install ecc@ecc

Nota sobre Nomes + Migração

O ECC agora tem três identificadores públicos e eles não são intercambiáveis:

  • Repositório fonte GitHub: affaan-m/ECC
  • Identificador de plugin/marketplace do Claude: ecc@ecc
  • Pacote npm: ecc-universal

Isso é intencional. Instalações de marketplace/plugin da Anthropic são chaveadas por um identificador de plugin canônico, então o ECC usa ecc@ecc para manter os nomes das ferramentas e namespaces de comandos com barra curtos o suficiente para validadores Desktop/API estritos. Posts mais antigos ainda podem mostrar o antigo identificador longo da marketplace; trate isso como apenas um alias legado. Separadamente, o pacote npm permaneceu em ecc-universal, então instalações via npm e marketplace intencionalmente usam nomes diferentes.

Passo 2: Instale as Regras Apenas se Necessário

AVISO: Importante: Os plugins do Claude Code não podem distribuir rules automaticamente.

Se você já instalou o ECC via /plugin install, não execute ./install.sh --profile full, .\install.ps1 --profile full, ou npx ecc-install --profile full em seguida. O plugin já carrega as habilidades, comandos e hooks do ECC. Executar o instalador completo após a instalação de um plugin copia essas mesmas superfícies para seus diretórios de usuário e pode criar habilidades duplicadas além de comportamentos de execução redundantes.

Para instalações via plugin, copie manualmente apenas os diretórios rules/ que desejar sob ~/.claude/rules/ecc/. Comece com rules/common mais um pacote de linguagem ou framework que você realmente utiliza. Não copie todos os diretórios de regras a menos que explicitamente deseja todo esse contexto no Claude.

Use o instalador completo apenas quando estiver fazendo uma instalação manual completa do ECC em vez da rota do plugin.

Se sua configuração local do Claude foi limpa ou reiniciada, isso não significa que você precisa re-comprar o ECC. Comece com node scripts/ecc.js list-installed, depois execute node scripts/ecc.js doctor e node scripts/ecc.js repair antes de reinstalar qualquer coisa. Isso geralmente restaura os arquivos gerenciados pelo ECC sem reconstruir sua configuração. Se o problema for acesso à conta ou marketplace para as Ferramentas do ECC, trate a faturação/recuperação da conta separadamente.

# Clone the repo first
git clone https://github.com/affaan-m/ECC.git
cd ECC

# Install dependencies (pick your package manager)
npm install        # or: pnpm install | yarn install | bun install

# 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
# Windows PowerShell

# 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

Para instruções de instalação manual veja o README no diretório rules/. Ao copiar regras manualmente, copie todo o diretório de linguagem (por exemplo rules/common ou rules/golang), não os arquivos dentro dele, para que referências relativas continuem funcionando e nomes de arquivo não colidam.

Instalação manual completa (Fallback)

Use isso apenas se estiver intencionalmente pulando a rota do plugin:

./install.sh --profile full
.\install.ps1 --profile full
# or
npx ecc-install --profile full

Se escolher este caminho, pare por aqui. Não execute também /plugin install.

Reset / Desinstalar ECC

Se o ECC parecer duplicado, intrusivo ou quebrado, não continue reinstalando-o sobre si mesmo.

  • Rota do plugin: remova o plugin do Claude Code e depois apague os diretórios de regras específicos que copiou manualmente sob ~/.claude/rules/ecc/.
  • Rota instalador manual / CLI: a partir da raiz do repositório, visualize a remoção primeiro:
node scripts/uninstall.js --dry-run

Depois remova os arquivos gerenciados pelo ECC:

node scripts/uninstall.js

Você também pode usar o wrapper de 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

O ECC remove apenas os arquivos registrados em seu estado de instalação. Ele não apagará arquivos relacionados que ele não instalou. Se empilharam métodos, limpe nesta ordem:

  1. Remova a instalação do plugin do Claude Code.
  2. Execute o comando de desinstalação do ECC a partir da raiz do repositório para remover os arquivos gerenciados pelo estado de instalação.
  3. Apague quaisquer diretórios extras de regras que copiou manualmente e não deseja mais.
  4. Reinstale uma vez, usando um único caminho.

Passo 3: Comece a Usar

# Skills are the primary workflow surface.
# Existing slash-style command names still work while ECC migrates off commands/.

# Plugin install uses the canonical namespaced form
/ecc:plan "Add user authentication"

# Manual install keeps the shorter slash form:
# /plan "Add user authentication"

# Check available commands
/plugin list ecc@ecc

É só isso! Agora você tem acesso a 64 agentes, 262 habilidades e 84 shims de comandos legados.

Dashboard GUI

Inicie o dashboard desktop para explorar visualmente os componentes do ECC:

npm run dashboard
# or
python3 ./ecc_dashboard.py

Recursos:

  • Interface com abas: Agentes, Habilidades, Comandos, Regras, Configurações
  • Alternância de tema Escuro/Claro
  • Personalização da fonte (família e tamanho)
  • Logotipo do projeto no cabeçalho e barra de tarefas
  • Pesquisa e filtro em todos os componentes

Comandos multi-modelo requerem configuração adicional

AVISO: comandos multi-* não são cobertos pela instalação base de plugin/regras acima.

Para usar /multi-plan, /multi-execute, /multi-backend, /multi-frontend e /multi-workflow, você também deve instalar o runtime ccg-workflow.

Inicialize-o com npx ccg-workflow.

Esse runtime fornece as dependências externas que esses comandos esperam, incluindo:

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

Sem o ccg-workflow, esses comandos multi-* não funcionarão corretamente.


Suporte Multiplataforma

Este plugin agora suporta totalmente Windows, macOS e Linux, além de integração apertada com principais IDEs (Cursor, Zed, OpenCode, Antigravity) e harnesses CLI. Todos os hooks e scripts foram reescritos em Node.js para máxima compatibilidade.

Detecção do Gerenciador de Pacotes

O plugin detecta automaticamente seu gerenciador de pacote preferido (npm, pnpm, yarn ou bun) com a seguinte prioridade:

  1. Variável de ambiente: CLAUDE_PACKAGE_MANAGER
  2. Configuração do projeto: .claude/package-manager.json
  3. package.json: campo packageManager
  4. Arquivo de bloqueio: Detecção em package-lock.json, yarn.lock, pnpm-lock.yaml ou bun.lockb
  5. Configuração global: ~/.claude/package-manager.json
  6. Fallback: Primeiro gerenciador de pacote disponível

Para definir seu gerenciador de pacote preferido:

# 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

Ou use o comando /setup-pm no Claude Code.

Controles do Runtime dos Hooks

Use flags de runtime para ajustar a estritência ou desabilitar hooks específicos temporariamente:

# 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

# 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 (isolamento multi-harness)

Os ganchos de persistência de memória (resumos de sessão, habilidades aprendidas, aliases de sessão e métricas) armazenam dados sob uma única raiz de dados do agente. Por padrão, essa raiz é ~/.claude. Quando você usa o ECC tanto no Claude Code quanto no Cursor na mesma máquina, defina uma raiz separada para o Cursor para que os dois ambientes não sobrescrevam os arquivos de sessão um ao outro:

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

Os caminhos resolvidos sob essa raiz incluem:

  • $ECC_AGENT_DATA_HOME/session-data/ — resumos de sessão
  • $ECC_AGENT_DATA_HOME/skills/learned/ — habilidades aprendidas do evaluate-session
  • $ECC_AGENT_DATA_HOME/session-aliases.json — aliases de sessão
  • $ECC_AGENT_DATA_HOME/metrics/ — métricas de custo e atividade

Veja affaan-m/ECC#2065.


O que há dentro

Este repositório é um plugin do Claude Code - instale-o diretamente ou copie os componentes manualmente.

ECC/
|-- .claude-plugin/   # Plugin and marketplace manifests
|   |-- plugin.json         # Plugin metadata and component paths
|   |-- marketplace.json    # Marketplace catalog for /plugin marketplace add
|
|-- agents/           # 64 specialized subagents for delegation
|   |-- planner.md           # Feature implementation planning
|   |-- architect.md         # System design decisions
|   |-- tdd-guide.md         # Test-driven development
|   |-- code-reviewer.md     # Quality and security review
|   |-- security-reviewer.md # Vulnerability analysis
|   |-- build-error-resolver.md
|   |-- e2e-runner.md        # Playwright E2E testing
|   |-- refactor-cleaner.md  # Dead code cleanup
|   |-- doc-updater.md       # Documentation sync
|   |-- docs-lookup.md       # Documentation/API lookup
|   |-- chief-of-staff.md    # Communication triage and drafts
|   |-- loop-operator.md     # Autonomous loop execution
|   |-- harness-optimizer.md # Harness config tuning
|   |-- cpp-reviewer.md      # C++ code review
|   |-- cpp-build-resolver.md # C++ build error resolution
|   |-- fsharp-reviewer.md   # F# functional code review
|   |-- go-reviewer.md       # Go code review
|   |-- go-build-resolver.md # Go build error resolution
|   |-- python-reviewer.md   # Python code review
|   |-- database-reviewer.md # Database/Supabase review
|   |-- typescript-reviewer.md # TypeScript/JavaScript code review
|   |-- java-reviewer.md     # Java/Spring Boot code review
|   |-- java-build-resolver.md # Java/Maven/Gradle build errors
|   |-- kotlin-reviewer.md   # Kotlin/Android/KMP code review
|   |-- kotlin-build-resolver.md # Kotlin/Gradle build errors
|   |-- harmonyos-app-resolver.md # HarmonyOS/ArkTS app development
|   |-- rust-reviewer.md     # Rust code review
|   |-- rust-build-resolver.md # Rust build error resolution
|   |-- pytorch-build-resolver.md # PyTorch/CUDA training errors
|   |-- mle-reviewer.md      # Production ML pipeline, eval, serving, and monitoring review
|
|-- skills/           # Workflow definitions and domain knowledge
|   |-- coding-standards/           # Language best practices
|   |-- clickhouse-io/              # ClickHouse analytics, queries, data engineering
|   |-- backend-patterns/           # API, database, caching patterns
|   |-- frontend-patterns/          # React, Next.js patterns
|   |-- frontend-slides/            # HTML slide decks and PPTX-to-web presentation workflows (NEW)
|   |-- article-writing/            # Long-form writing in a supplied voice without generic AI tone (NEW)
|   |-- content-engine/             # Multi-platform social content and repurposing workflows (NEW)
|   |-- market-research/            # Source-attributed market, competitor, and investor research (NEW)
|   |-- investor-materials/         # Pitch decks, one-pagers, memos, and financial models (NEW)
|   |-- investor-outreach/          # Personalized fundraising outreach and follow-up (NEW)
|   |-- continuous-learning/        # Legacy v1 Stop-hook pattern extraction
|   |-- continuous-learning-v2/     # Instinct-based learning with confidence scoring
|   |-- iterative-retrieval/        # Progressive context refinement for subagents
|   |-- strategic-compact/          # Manual compaction suggestions (Longform Guide)
|   |-- tdd-workflow/               # TDD methodology
|   |-- security-review/            # Security checklist
|   |-- eval-harness/               # Verification loop evaluation (Longform Guide)
|   |-- verification-loop/          # Continuous verification (Longform Guide)
|   |-- videodb/                   # Video and audio: ingest, search, edit, generate, stream (NEW)
|   |-- golang-patterns/            # Go idioms and best practices
|   |-- golang-testing/             # Go testing patterns, TDD, benchmarks
|   |-- cpp-coding-standards/         # C++ coding standards from C++ Core Guidelines (NEW)
|   |-- cpp-testing/                # C++ testing with GoogleTest, CMake/CTest (NEW)
|   |-- django-patterns/            # Django patterns, models, views (NEW)
|   |-- django-security/            # Django security best practices (NEW)
|   |-- django-tdd/                 # Django TDD workflow (NEW)
|   |-- django-verification/        # Django verification loops (NEW)
|   |-- laravel-patterns/           # Laravel architecture patterns (NEW)
|   |-- laravel-security/           # Laravel security best practices (NEW)
|   |-- laravel-tdd/                # Laravel TDD workflow (NEW)
|   |-- laravel-verification/       # Laravel verification loops (NEW)
|   |-- python-patterns/            # Python idioms and best practices (NEW)
|   |-- python-testing/             # Python testing with pytest (NEW)
|   |-- quarkus-patterns/            # Java Quarkus patterns (NEW)
|   |-- quarkus-security/            # Quarkus security (NEW)
|   |-- quarkus-tdd/                 # Quarkus TDD (NEW)
|   |-- quarkus-verification/        # Quarkus verification (NEW)
|   |-- springboot-patterns/        # Java Spring Boot patterns (NEW)
|   |-- springboot-security/        # Spring Boot security (NEW)
|   |-- springboot-tdd/             # Spring Boot TDD (NEW)
|   |-- springboot-verification/    # Spring Boot verification (NEW)
|   |-- configure-ecc/              # Interactive installation wizard (NEW)
|   |-- security-scan/              # AgentShield security auditor integration (NEW)
|   |-- java-coding-standards/     # Java coding standards (NEW)
|   |-- jpa-patterns/              # JPA/Hibernate patterns (NEW)
|   |-- postgres-patterns/         # PostgreSQL optimization patterns (NEW)
|   |-- nutrient-document-processing/ # Document processing with Nutrient API (NEW)
|   |-- docs/examples/project-guidelines-template.md  # Template for project-specific skills
|   |-- database-migrations/         # Migration patterns (Prisma, Drizzle, Django, Go) (NEW)
|   |-- api-design/                  # REST API design, pagination, error responses (NEW)
|   |-- deployment-patterns/         # CI/CD, Docker, health checks, rollbacks (NEW)
|   |-- docker-patterns/            # Docker Compose, networking, volumes, container security (NEW)
|   |-- e2e-testing/                 # Playwright E2E patterns and Page Object Model (NEW)
|   |-- content-hash-cache-pattern/  # SHA-256 content hash caching for file processing (NEW)
|   |-- cost-aware-llm-pipeline/     # LLM cost optimization, model routing, budget tracking (NEW)
|   |-- regex-vs-llm-structured-text/ # Decision framework: regex vs LLM for text parsing (NEW)
|   |-- swift-actor-persistence/     # Thread-safe Swift data persistence with actors (NEW)
|   |-- swift-protocol-di-testing/   # Protocol-based DI for testable Swift code (NEW)
|   |-- search-first/               # Research-before-coding workflow (NEW)
|   |-- skill-stocktake/            # Audit skills and commands for quality (NEW)
|   |-- liquid-glass-design/         # iOS 26 Liquid Glass design system (NEW)
|   |-- foundation-models-on-device/ # Apple on-device LLM with FoundationModels (NEW)
|   |-- swift-concurrency-6-2/       # Swift 6.2 Approachable Concurrency (NEW)
|   |-- mle-workflow/               # Production ML data contracts, evals, deployment, monitoring (NEW)
|   |-- perl-patterns/             # Modern Perl 5.36+ idioms and best practices (NEW)
|   |-- perl-security/             # Perl security patterns, taint mode, safe I/O (NEW)
|   |-- perl-testing/              # Perl TDD with Test2::V0, prove, Devel::Cover (NEW)
|   |-- autonomous-loops/           # Autonomous loop patterns: sequential pipelines, PR loops, DAG orchestration (NEW)
|   |-- plankton-code-quality/      # Write-time code quality enforcement with Plankton hooks (NEW)
|   |-- codehealth-mcp/             # Optional CodeScene Code Health MCP skill (opt-in; not enabled by default) (NEW)
|
|-- commands/         # Maintained slash-entry compatibility; prefer skills/
|   |-- plan.md             # /plan - Implementation planning
|   |-- code-review.md      # /code-review - Quality review
|   |-- build-fix.md        # /build-fix - Fix build errors
|   |-- refactor-clean.md   # /refactor-clean - Dead code removal
|   |-- quality-gate.md     # /quality-gate - Verification gate
|   |-- learn.md            # /learn - Extract patterns mid-session (Longform Guide)
|   |-- learn-eval.md       # /learn-eval - Extract, evaluate, and save patterns (NEW)
|   |-- checkpoint.md       # /checkpoint - Save verification state (Longform Guide)
|   |-- setup-pm.md         # /setup-pm - Configure package manager
|   |-- go-review.md        # /go-review - Go code review (NEW)
|   |-- go-test.md          # /go-test - Go TDD workflow (NEW)
|   |-- go-build.md         # /go-build - Fix Go build errors (NEW)
|   |-- skill-create.md     # /skill-create - Generate skills from git history (NEW)
|   |-- instinct-status.md  # /instinct-status - View learned instincts (NEW)
|   |-- instinct-import.md  # /instinct-import - Import instincts (NEW)
|   |-- instinct-export.md  # /instinct-export - Export instincts (NEW)
|   |-- evolve.md           # /evolve - Cluster instincts into skills
|   |-- prune.md            # /prune - Delete expired pending instincts (NEW)
|   |-- pm2.md              # /pm2 - PM2 service lifecycle management (NEW)
|   |-- multi-plan.md       # /multi-plan - Multi-agent task decomposition (NEW)
|   |-- multi-execute.md    # /multi-execute - Orchestrated multi-agent workflows (NEW)
|   |-- multi-backend.md    # /multi-backend - Backend multi-service orchestration (NEW)
|   |-- multi-frontend.md   # /multi-frontend - Frontend multi-service orchestration (NEW)
|   |-- multi-workflow.md   # /multi-workflow - General multi-service workflows (NEW)
|   |-- sessions.md         # /sessions - Session history management
|   |-- test-coverage.md    # /test-coverage - Test coverage analysis
|   |-- update-docs.md      # /update-docs - Update documentation
|   |-- update-codemaps.md  # /update-codemaps - Update codemaps
|   |-- python-review.md    # /python-review - Python code review (NEW)
|-- legacy-command-shims/   # Opt-in archive for retired shims such as /tdd and /eval
|   |-- tdd.md              # /tdd - Prefer the tdd-workflow skill
|   |-- e2e.md              # /e2e - Prefer the e2e-testing skill
|   |-- eval.md             # /eval - Prefer the eval-harness skill
|   |-- verify.md           # /verify - Prefer the verification-loop skill
|   |-- orchestrate.md      # /orchestrate - Prefer dmux-workflows or multi-workflow
|
|-- rules/            # Always-follow guidelines (copy to ~/.claude/rules/ecc/)
|   |-- README.md            # Structure overview and installation guide
|   |-- common/              # Language-agnostic principles
|   |   |-- coding-style.md    # Immutability, file organization
|   |   |-- git-workflow.md    # Commit format, PR process
|   |   |-- testing.md         # TDD, 80% coverage requirement
|   |   |-- performance.md     # Model selection, context management
|   |   |-- patterns.md        # Design patterns, skeleton projects
|   |   |-- hooks.md           # Hook architecture, TodoWrite
|   |   |-- agents.md          # When to delegate to subagents
|   |   |-- security.md        # Mandatory security checks
|   |-- typescript/          # TypeScript/JavaScript specific
|   |-- python/              # Python specific
|   |-- golang/              # Go specific
|   |-- swift/               # Swift specific
|   |-- php/                 # PHP specific (NEW)
|   |-- arkts/               # HarmonyOS / ArkTS specific
|
|-- hooks/            # Trigger-based automations
|   |-- README.md                 # Hook documentation, recipes, and customization guide
|   |-- hooks.json                # All hooks config (PreToolUse, PostToolUse, Stop, etc.)
|   |-- memory-persistence/       # Session lifecycle hooks (Longform Guide)
|   |-- strategic-compact/        # Compaction suggestions (Longform Guide)
|
|-- scripts/          # Cross-platform Node.js scripts (NEW)
|   |-- lib/                     # Shared utilities
|   |   |-- utils.js             # Cross-platform file/path/system utilities
|   |   |-- package-manager.js   # Package manager detection and selection
|   |-- hooks/                   # Hook implementations
|   |   |-- session-start.js     # Load context on session start
|   |   |-- session-end.js       # Save state on session end
|   |   |-- pre-compact.js       # Pre-compaction state saving
|   |   |-- suggest-compact.js   # Strategic compaction suggestions
|   |   |-- evaluate-session.js  # Extract patterns from sessions
|   |-- setup-package-manager.js # Interactive PM setup
|
|-- tests/            # Test suite (NEW)
|   |-- lib/                     # Library tests
|   |-- hooks/                   # Hook tests
|   |-- run-all.js               # Run all tests
|
|-- contexts/         # Dynamic system prompt injection contexts (Longform Guide)
|   |-- dev.md              # Development mode context
|   |-- review.md           # Code review mode context
|   |-- research.md         # Research/exploration mode context
|
|-- examples/         # Example configurations and sessions
|   |-- CLAUDE.md             # Example project-level config
|   |-- user-CLAUDE.md        # Example user-level config
|   |-- saas-nextjs-CLAUDE.md   # Real-world SaaS (Next.js + Supabase + Stripe)
|   |-- go-microservice-CLAUDE.md # Real-world Go microservice (gRPC + PostgreSQL)
|   |-- django-api-CLAUDE.md      # Real-world Django REST API (DRF + Celery)
|   |-- laravel-api-CLAUDE.md     # Real-world Laravel API (PostgreSQL + Redis) (NEW)
|   |-- rust-api-CLAUDE.md        # Real-world Rust API (Axum + SQLx + PostgreSQL) (NEW)
|
|-- mcp-configs/      # MCP server configurations
|   |-- mcp-servers.json    # GitHub, Supabase, Vercel, Railway, etc.
|
|-- ecc_dashboard.py  # Desktop GUI dashboard (Tkinter)
|
|-- assets/           # Assets for dashboard
|   |-- images/
|       |-- ecc-logo.png
|
|-- marketplace.json  # Self-hosted marketplace config (for /plugin marketplace add)

Ferramentas de Ecossistema

Criador de Habilidades

Duas formas de gerar habilidades do Claude Code a partir do seu repositório:

Opção A: Análise Local (Incorporado)

Use o comando /skill-create para análise local sem serviços externos:

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

Isso analisa o histórico git localmente e gera arquivos SKILL.md.

Opção B: App do GitHub (Avançado)

Para recursos avançados (+ de 10k commits, PRs automáticos, compartilhamento em equipe):

Instalar Ferramentas ECC do GitHub | ecc.tools

# Comment on any issue:
/ecc-tools analyze

# Or run against a repo from the hosted app

Ambas as opções criam:

  • Arquivos SKILL.md — Habilidades prontas para uso no harness ativo
  • Coleções de Instinto — Para continuous-learning-v2
  • Extração de Padrões — Aprende com seu histórico de commits

AgentShield — Auditor de Segurança

Desenvolvido na Hackathon do Claude Code (Cerebral Valley x Anthropic, fev. 2026). 1282 testes, 98% de cobertura, 102 regras de análise estática.

Varre sua configuração do Claude Code em busca de vulnerabilidades, más configurações e riscos de injeção.

# Quick scan (no install needed)
npx ecc-agentshield scan

# Auto-fix safe issues
npx ecc-agentshield scan --fix

# Deep analysis with three Opus 4.6 agents
npx ecc-agentshield scan --opus --stream

# Generate secure config from scratch
npx ecc-agentshield init

O que ele varre: CLAUDE.md, settings.json, configs MCP, ganchos, definições de agente e habilidades ao longo de 5 categorias — detecção de segredos (14 padrões), auditoria de permissões, análise de injeção em ganchos, perfilamento de risco do servidor MCP e revisão da configuração do agente.

A flag --opus executa três agentes Claude Opus 4.6 em um pipeline red-team/blue-team/auditor. O atacante encontra cadeias de exploração, o defensor avalia proteções e o auditor sintetiza ambos em uma avaliação de risco priorizada. Raciocínio adversarial, não apenas correspondência de padrões.

Formatos de saída: Terminal (classificado por cores A-F), JSON (pipelines CI), Markdown, HTML. Código de saída 2 para achados críticos nas portas de build.

Use /security-scan no Claude Code para executá-lo ou adicione ao CI com o GitHub Action.

GitHub | npm

Aprendizado Contínuo v2

O sistema de aprendizado baseado em instinto aprende automaticamente seus padrões:

/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

Veja skills/continuous-learning-v2/ para a documentação completa. Mantenha apenas continuous-learning/ quando você explicitamente quiser o fluxo legado v1 Stop-hook aprendido-skill.


Requisitos

Versão do CLI Claude Code

Versão mínima: v2.1.0 ou posterior

Este plugin requer o CLI Claude Code v2.1.0+ devido a mudanças na forma como o sistema de plugins lida com ganchos.

Verifique sua versão:

claude --version

Importante: Comportamento de Carregamento Automático de Ganchos

AVISO: Para Contribuidores: NÃO adicione um campo "hooks" ao .claude-plugin/plugin.json. Isso é enforced por um teste de regressão.

O Claude Code v2.1+ carrega automaticamente hooks/hooks.json de qualquer plugin instalado por convenção. Declará-lo explicitamente em plugin.json causa erro de detecção duplicada:

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

Histórico: Isso causou ciclos repetidos de correção/revert neste repositório (#29, #52, #103). O comportamento mudou entre versões do Claude Code, levando a confusão. Agora temos um teste de regressão para impedir que isso seja reintroduzido.


Opção 1: Instalar como Plugin (Recomendado)

A maneira mais fácil de usar este repositório é instalá-lo como um plugin do Claude Code:

# Add this repo as a marketplace
/plugin marketplace add https://github.com/affaan-m/ECC

# Install the plugin
/plugin install ecc@ecc

Ou adicione diretamente ao seu ~/.claude/settings.json:

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

Isso lhe dá acesso imediato a todos os comandos, agentes, habilidades e ganchos.

Nota: O sistema de plugins do Claude Code não suporta distribuir rules via plugins (limitação upstream). Você precisa instalar as regras manualmente:

# Clone o repositório primeiro
git clone https://github.com/affaan-m/ECC.git
cd ECC

# Opção A: Regras de nível do usuário (aplica-se a todos os projetos)
mkdir -p ~/.claude/rules/ecc
cp -r rules/common ~/.claude/rules/ecc/
cp -r rules/typescript ~/.claude/rules/ecc/   # escolha sua stack
cp -r rules/python ~/.claude/rules/ecc/
cp -r rules/golang ~/.claude/rules/ecc/
cp -r rules/php ~/.claude/rules/ecc/

# Opção B: Regras de nível do projeto (aplica-se apenas ao projeto atual)
mkdir -p .claude/rules/ecc
cp -r rules/common .claude/rules/ecc/
cp -r rules/typescript .claude/rules/ecc/     # escolha sua stack

Opção 2: Instalação Manual

Se você preferir controle manual sobre o que é instalado:

# Clone the repo
git clone https://github.com/affaan-m/ECC.git
cd ECC

# Copy agents to your Claude config
cp agents/*.md ~/.claude/agents/

# Copy 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
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/

# Copy skills first (primary workflow surface)
# Recommended (new users): core/general skills only
mkdir -p ~/.claude/skills
cp -r .agents/skills/* ~/.claude/skills/
cp -r skills/search-first ~/.claude/skills/
# Claude Code loads skills only from direct children of ~/.claude/skills.
# Do not nest manual installs under ~/.claude/skills/ecc/.

# Optional: add niche/framework-specific skills only when needed
# for s in django-patterns django-tdd laravel-patterns springboot-patterns quarkus-patterns; do
# cp -r skills/$s ~/.claude/skills/
# done

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

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

Instalar ganchos (hooks)

Não copie o repositório cru hooks/hooks.json para ~/.claude/settings.json ou ~/.claude/hooks/hooks.json. Esse arquivo é orientado a plugins/repo e deve ser instalado através do instalador ECC ou carregado como um plugin, portanto cópias manuais não são suportadas.

Use o instalador para instalar apenas o runtime de hook do Claude, assim os caminhos dos comandos serão reescritos corretamente:

# macOS / Linux
bash ./install.sh --target claude --modules hooks-runtime
# Windows PowerShell
pwsh -File .\install.ps1 --target claude --modules hooks-runtime

Isso escreve hooks resolvidos em ~/.claude/hooks/hooks.json e deixa qualquer ~/.claude/settings.json existente intacto.

Se você instalou o ECC via /plugin install, não copie esses ganchos para settings.json. O Claude Code v2.1+ já carrega automaticamente o plugin hooks/hooks.json, e duplicá-los em settings.json causa execução dupla e conflitos de hooks entre plataformas.

Nota Windows: o diretório de configuração do Claude é %USERPROFILE%\\.claude, não ~/claude.

Configurar MCPs

Instalações de plugins do Claude intencionalmente não ativam automaticamente as definições de servidor MCP embutidas no ECC. Isso evita nomes longos demais para ferramentas MCP de plugin em gateways estritos de terceiros, mantendo a configuração manual de MCP disponível.

Use o comando /mcp do Claude Code ou configuração gerenciada via CLI para alterações ao vivo nos servidores do Claude Code. Use /mcp para desativar no runtime do Claude Code; o Claude Code persiste essas escolhas em ~/.claude.json.

Para acesso a MCP local ao repositório, copie as definições de servidor MCP desejadas de mcp-configs/mcp-servers.json para um .mcp.json com escopo de projeto.

O ECC embarca exatamente uma conexão padrão (chrome-devtools); tudo o mais é uma habilidade que envolve um CLI/REST API ou uma entrada no catálogo opt-in. A regra e a auditoria de junho de 2026 que aposentou os seis padrões anteriores vivem em docs/MCP-CONNECTOR-POLICY.md.

Se você já executa suas próprias cópias dos MCPs embutidos no ECC, defina:

export ECC_DISABLED_MCPS="chrome-devtools"

Fluxos de instalação gerenciada pelo ECC e sincronização do Codex pularão ou removerão esses servidores embutidos em vez de re-adicionar duplicatas. ECC_DISABLED_MCPS é um filtro de instalação/sincronização do ECC, não uma chave no Claude Code ao vivo.

Importante: Substitua os placeholders YOUR_*_HERE pelas suas chaves API reais.


Conceitos Chave

Agentes (Agents)

Subagentes lidam com tarefas delegadas em escopo limitado. Exemplo:

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

You are a senior code reviewer...

Habilidades (Skills)

Habilidades são a superfície principal de fluxo de trabalho. Elas podem ser invocadas diretamente, sugeridas automaticamente e reutilizadas por agentes. O ECC ainda embarca commands/ mantidos durante a migração, enquanto shims de nomes curtos aposentados vivem sob legacy-command-shims/ apenas para opt-in explícito. Novo desenvolvimento de fluxo de trabalho deve aterrizar em skills/ primeiro.

# TDD Workflow

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

Ganchos (Hooks)

Ganchos disparam em eventos de ferramenta. Exemplo - avisar 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"
  }]
}

Regras (Rules)

Regras são diretrizes sempre seguidas, organizadas em common/ (agnóstico à linguagem) + diretórios específicos da linguagem:

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

Veja rules/README.md para detalhes de instalação e estrutura.

Qual Agente Devo Usar?

Não sabe por onde começar? Use esta referência rápida. As skills são a superfície de fluxo de trabalho canônica; as entradas mantidas no estilo /slash permanecem disponíveis para fluxos de trabalho focados em comandos.

Eu quero...Usar essa superfícieAgente usado
Planejar um novo recurso/ecc:plan "Add auth"planner
Projetar arquitetura do sistema/ecc:plan + agente architectarchitect
Escrever código com testes primeiro (TDD)skill tdd-workflowtdd-guide
Revisar o código que acabei de escrever/code-reviewcode-reviewer
Corrigir uma build falha/build-fixbuild-error-resolver
Executar testes end-to-end (E2E)skill e2e-testinge2e-runner
Encontrar vulnerabilidades de segurança/security-scansecurity-reviewer
Remover código morto/refactor-cleanrefactor-cleaner
Atualizar documentação/update-docsdoc-updater
Revisar código Go/go-reviewgo-reviewer
Revisar código Python/python-reviewpython-reviewer
Revisar código F#(invocar fsharp-reviewer diretamente)fsharp-reviewer
Revisar código TypeScript/JavaScript(invocar typescript-reviewer diretamente)typescript-reviewer
Desenvolver aplicativos HarmonyOS(invocar harmonyos-app-resolver diretamente)harmonyos-app-resolver
Auditar consultas de banco de dados(delegado automaticamente)database-reviewer
Revisar mudanças em ML na produçãoskill mle-workflow + agente mle-reviewermle-reviewer

Fluxos de Trabalho Comuns

Os formatos /slash abaixo são mostrados onde permanecem parte da superfície de comandos mantida. Shims com nomes curtos aposentados, como /tdd e /eval, vivem em legacy-command-shims/ apenas para opt-in explícito.

Iniciando um novo recurso:

/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

Corrigindo um 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

Preparando para a produção:

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

FAQ

/plugin list ecc@ecc

Isso mostra todos os agentes, comandos e skills disponíveis no plugin.

Este é o problema mais comum. NÃO adicione um campo "hooks" ao .claude-plugin/plugin.json. O Claude Code v2.1+ carrega automaticamente hooks/hooks.json de plugins instalados. Declará-lo explicitamente causa erros de detecção duplicada. Veja #29, #52, #103.

Sim. O ECC não codifica rigidamente configurações de transporte hospedadas pela Anthropic. Ele roda localmente através da interface CLI/plugin normal do Claude Code, então funciona com:

  • Claude Code hospedado na Anthropic
  • Configurações oficiais de gateway do Claude Code usando ANTHROPIC_BASE_URL e ANTHROPIC_AUTH_TOKEN
  • Endpoints personalizados compatíveis que falam a API da Anthropic esperada pelo Claude Code

Exemplo mínimo:

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

Se seu gateway remapeia nomes de modelos, configure isso no Claude Code em vez do ECC. Os hooks, skills, comandos e regras do ECC são agnósticos ao provedor de modelo assim que o CLI claude já está funcionando.

Referências oficiais:

Muitos servidores MCP consomem seu contexto. Cada descrição de ferramenta do MCP consome tokens da sua janela de 200k, potencialmente reduzindo-a para ~70k. O contexto SessionStart é limitado a 8000 caracteres por padrão; reduza com ECC_SESSION_START_MAX_CHARS=4000 ou desative-o com ECC_SESSION_START_CONTEXT=off para configurações de modelos locais ou baixo contexto.

Solução: Desabilize MCPs não usados no Claude Code com /mcp. O Claude Code grava essas escolhas de runtime em ~/.claude.json; .claude/settings.json e .claude/settings.local.json não são alternativos confiáveis para servidores MCP já carregados.

Mantenha menos de 10 MCPs habilitados e menos de 80 ferramentas ativas.

Sim. Use a Opção 2 (instalação manual) e copie apenas o que você precisa:

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

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

Cada componente é totalmente independente.

Sim. O ECC é cross-platform:

  • Cursor: Configurações pré-traduzidas em .cursor/. Veja Suporte ao IDE do Cursor.
  • Gemini CLI: Suporte local de projeto experimental via .gemini/GEMINI.md e plumbagem compartilhada de instalador.
  • OpenCode: Suporte completo a plugins em .opencode/. Veja Suporte ao OpenCode.
  • Codex: Suporte de primeira classe tanto para o app macOS quanto CLI, com guardas contra derivação do adaptador e fallback SessionStart. Veja PR #257.
  • GitHub Copilot (VS Code): Camada de instruções e prompts via .github/copilot-instructions.md, .vscode/settings.json e .github/prompts/. Veja Suporte ao GitHub Copilot.
  • Antigravity: Configuração integrada para workflows, skills e regras achatadas em .agent/. Veja Guia do Antigravity.
  • JoyCode / CodeBuddy: Adaptadores de instalação seletiva local de projeto para comandos, agentes, skills e regras achatadas. Veja Guia do Adaptador JoyCode.
  • Qwen CLI: Adaptador de instalação seletiva no diretório home para comandos, agentes, skills, regras e configuração Qwen. Veja Guia do Adaptador Qwen CLI.
  • Zed: Adaptador de instalação seletiva local de projeto para .zed/settings.json, regras achatadas, comandos, agentes e skills.
  • Harneses não nativos: Camada manual de fallback para Grok e interfaces similares. Veja Guia de Adaptação Manual.
  • Claude Code: Nativo — este é o alvo primário.

Veja CONTRIBUTING.md. A versão resumida:

  1. Faça fork do repositório
  2. Crie seu skill em skills/your-skill-name/SKILL.md (com frontmatter YAML)
  3. Ou crie um agente em agents/your-agent.md
  4. Envie uma PR com uma descrição clara do que ele faz e quando usá-lo

Executando Testes

O plugin inclui uma suíte de testes abrangente:

# 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

Contribuindo

Contribuições são bem-vindas e encorajadas.

Este repositório é destinado a ser um recurso da comunidade. Se você tem:

  • Agentes ou skills úteis
  • Hooks inteligentes
  • Configurações MCP melhores
  • Regras melhoradas

Por favor, contribua! Veja CONTRIBUTING.md para diretrizes.

Ideias para Contribuições

  • Habilidades específicas de linguagem (Rust, C#, Kotlin, Java) — Go, Python, Perl, Swift e TypeScript já estão incluídos; HarmonyOS/ArkTS também.
  • Configurações específicas de framework (Rails, FastAPI) — Django, NestJS, Spring Boot e Laravel já estão incluídos.
  • Agentes DevOps (Kubernetes, Terraform, AWS, Docker).
  • Estratégias de teste (diferentes frameworks, regressão visual).
  • Conhecimento específico do domínio (ML, engenharia de dados, mobile).

Suporte ao Cursor IDE

O ECC oferece suporte ao Cursor IDE com hooks, regras, agentes, habilidades, comandos e configurações MCP adaptados para o layout de projetos do Cursor.

Início Rápido (Cursor)

# 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

O que está incluído

ComponenteQuantidadeDetalhes
Eventos Hook15sessionStart, beforeShellExecution, afterFileEdit, beforeMCPExecution, beforeSubmitPrompt e mais 10.
Scripts de Hook16Finos scripts Node.js que delegam para scripts/hooks/ via adaptador compartilhado.
Regras (Rules)349 comuns (alwaysApply) + 25 específicas por linguagem (TypeScript, Python, Go, Swift, PHP).
Agentes48.cursor/agents/ecc-*.md quando instalado; prefixados para evitar colisões com agentes de usuário ou da marketplace.
Habilidades (Skills)Compartilhado + Bundled.cursor/skills/ para adições traduzidas.
ComandosCompartilhado.cursor/commands/ se instalado.
Configuração MCPCompartilhada.cursor/mcp.json se instalada.

Notas sobre carregamento no Cursor

O ECC não instala o AGENTS.md raiz em .cursor/. O Cursor trata arquivos AGENTS.md aninhados como contexto de diretório, então copiar a identidade do repositório do ECC para um projeto hospedeiro poluiria esse projeto.

O comportamento nativo de carregamento no Cursor pode variar conforme a versão construída (build) do Cursor. O ECC instala agentes como .cursor/agents/ecc-*.md; se sua build do Cursor não expor agentes de projeto, esses arquivos ainda funcionam como definições explícitas de referência em vez de contexto global oculto.

Isolamento de memória e dados (Cursor + Claude Code)

Os hooks de memória do ECC reutilizam os mesmos scripts/hooks/*.js que o Claude Code. Para o Cursor, o ECC tenta manter a memória fora de ~/.claude automaticamente:

  1. Hook sessionStart do Cursor (instalado em .cursor/hooks.json com --target cursor) injeta ECC_AGENT_DATA_HOME para toda a sessão do compositor.
  2. Padrão de execução do hook — quando CURSOR_VERSION ou CURSOR_PROJECT_DIR estão presentes, os hooks padrão usam ~/.cursor/ecc se a variável de ambiente não estiver definida.
  3. Configuração do projeto — .cursor/ecc-agent-data.json documenta e sobreescreve o caminho (agentDataHome).
  4. Regra sempre ativa — .cursor/rules/ecc-agent-data-home.mdc lembra ao agente onde a memória reside.

Você ainda pode sobrescrever explicitamente:

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

Para compartilhar intencionalmente a memória com o Claude Code, defina ECC_AGENT_DATA_HOME=~/.claude no shell ou em .cursor/ecc-agent-data.json.

Os instintos de aprendizado contínuo v2 permanecem separados sob CLV2_HOMUNCULUS_DIR (padrão ~/.local/share/ecc-homunculus).

Arquitetura do Hook (Padrão DRY Adapter)

O Cursor tem mais eventos de hook que o Claude Code (20 vs 8). O módulo .cursor/hooks/adapter.js transforma o JSON stdin do Cursor para o formato do Claude Code, permitindo reutilizar os existentes scripts/hooks/*.js sem duplicação.

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

Hooks principais:

  • beforeShellExecution — Bloqueia servidores de desenvolvimento fora do tmux (saída 2), revisão de push git.
  • afterFileEdit — Auto-format + verificação TypeScript + aviso console.log.
  • beforeSubmitPrompt — Detecta segredos (padrões sk-, ghp_, AKIA) em prompts.
  • beforeTabFileRead — Bloqueia o Tab de ler arquivos .env, .key, .pem (saída 2).
  • beforeMCPExecution / afterMCPExecution — Auditoria de log do MCP.

Formato das Regras

As regras do Cursor usam frontmatter YAML com description, globs e alwaysApply:

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

Suporte ao App Codex macOS + CLI

O ECC oferece suporte de primeira classe para o Codex tanto no app macOS quanto na CLI, incluindo uma configuração de referência, suplemento AGENTS.md específico do Codex e habilidades compartilhadas.

Início Rápido (App Codex + CLI)

# Run Codex CLI in the repo — AGENTS.md and .codex/ are auto-detected
codex

# Automatic setup: sync ECC assets (AGENTS.md, skills, MCP servers) into ~/.codex
npm install && bash scripts/sync-ecc-to-codex.sh
# or: pnpm install && bash scripts/sync-ecc-to-codex.sh
# or: yarn install && bash scripts/sync-ecc-to-codex.sh
# or: bun install && bash scripts/sync-ecc-to-codex.sh

# Or manually: copy the reference config to your home directory
cp .codex/config.toml ~/.codex/config.toml

O script de sincronização mescla com segurança os servidores MCP do ECC no seu ~/.codex/config.toml existente usando uma estratégia add-only — ele nunca remove ou modifica seus servidores existentes. Execute com --dry-run para visualizar as alterações, ou --update-mcp para forçar a atualização dos servidores do ECC até a configuração recomendada mais recente.

Para o Context7, o ECC usa o nome de seção canônico [mcp_servers.context7], enquanto ainda lança o pacote @upstash/context7-mcp. Se você já tiver uma entrada legada [mcp_servers.context7-mcp], o --update-mcp a migra para o nome da seção canônico.

App Codex macOS:

  • Abra este repositório como seu workspace.
  • O AGENTS.md raiz é detectado automaticamente.
  • .codex/config.toml e .codex/agents/*.toml funcionam melhor quando mantidos locais ao projeto.
  • A referência .codex/config.toml intencionalmente não fixa o model ou model_provider, então o Codex usa seu próprio padrão atual, a menos que você sobrescreva.
  • Opcional: copie .codex/config.toml para ~/.codex/config.toml para padrões globais; mantenha os arquivos de papel multi-agente locais ao projeto, a menos que também copie .codex/agents/.

O que está incluído

ComponenteQuantidadeDetalhes
Config1.codex/config.toml — aprovações de nível superior/sandbox/web_search, servidores MCP, notificações e perfis
AGENTS.md2Raiz (universal) + .codex/AGENTS.md (suplemento específico do Codex)
Skills32.agents/skills/ — SKILL.md + agents/openai.yaml por habilidade
MCP Servers6GitHub, Context7, Exa, Memory, Playwright, Pensamento Sequencial (7 com Supabase via sincronização --update-mcp)
Perfis2strict (sandbox somente leitura) e yolo (aprovação automática total)
Papéis de Agente3.codex/agents/ — explorador, revisor, pesquisador de documentação

Habilidades

As habilidades em .agents/skills/ são carregadas automaticamente pelo Codex:

Habilidades canônicas da Anthropic como claude-api, frontend-design e skill-creator não são reempacotadas intencionalmente aqui. Instale-as de anthropics/skills quando quiser as versões oficiais.

HabilidadeDescrição
agent-introspection-debuggingDepuração do comportamento, roteamento e limites dos prompts do agente
agent-sortOrdenação de catálogos de agentes e superfícies de atribuição
api-designPadrões de design para APIs REST
article-writingEscrita longa baseada em notas e referências por voz
backend-patternsDesign de API, banco de dados, cacheamento
brand-voicePerfis de estilo de escrita derivados da fonte a partir do conteúdo real
bun-runtimeBun como runtime, gerenciador de pacotes, empacotador e executador de testes
coding-standardsPadrões universais de codificação
codehealth-mcpOpcional — Code Health MCP (servidor opt-in + token); revisão estrutural e portões para commit/PR
content-engineConteúdo social nativo da plataforma e reaproveitamento
crosspostDistribuição de conteúdo multiplataforma no X, LinkedIn e Threads
deep-researchPesquisa com múltiplas fontes, síntese e atribuição de origem
dmux-workflowsOrquestração multi-agente usando gerenciador de painéis tmux
documentation-lookupDocumentações atualizadas da biblioteca e frameworks via MCP Context7
e2e-testingTestes E2E do Playwright
eval-harnessDesenvolvimento impulsionado por avaliação (eval)
everything-claude-codeConvenções de desenvolvimento e padrões para o projeto
exa-searchBusca neural via MCP Exa para web, código e pesquisa corporativa
fal-ai-mediaGeração unificada de mídia para imagens, vídeo e áudio
frontend-patternsPadrões React/Next.js
frontend-slidesApresentações HTML, conversão PPTX, exploração visual do estilo
investor-materialsDecks, memos, modelos e resumos em uma página (one-pagers)
investor-outreachAbordagem personalizada, follow-ups e introduções curtas
market-researchPesquisa de mercado e concorrentes com atribuição de fonte
mcp-server-patternsCriação de servidores MCP usando SDK Node/TypeScript
nextjs-turbopackNext.js 16+ e empacotamento incremental do Turbopack
product-capabilityTradução de objetivos de produto em mapas de capacidade escopados
security-reviewChecklist abrangente de segurança
strategic-compactGerenciamento de contexto
tdd-workflowDesenvolvimento impulsionado por testes com 80%+ de cobertura
verification-loopConstruir, testar, lintar, verificar tipos e segurança
video-editingWorkflows de edição de vídeo assistidos por IA com FFmpeg e Remotion
x-apiIntegração da API X/Twitter para postagem e análises

Limitação Principal

O Codex ainda não fornece paridade na execução de hooks estilo Claude. A aplicação ECC (Enforcement) ali é baseada em instruções via AGENTS.md, sobrescritas opcionais do arquivo model_instructions_file e configurações de sandbox/aprovação.

Suporte Multi-Agente

As construções atuais do Codex suportam workflows multi-agente estáveis.

  • Ative features.multi_agent = true em .codex/config.toml
  • Defina papéis sob [agents.<name>]
  • Aponte cada papel para um arquivo sob .codex/agents/
  • Use /agent no CLI para inspecionar ou guiar agentes filhos

O ECC envia três configurações de exemplo de papel:

PapelPropósito
explorerColetação de evidências do código-base somente leitura antes das edições
reviewerRevisão de correção, segurança e testes faltantes
docs_researcherVerificação de documentação e API antes da liberação/mudanças na docs

Suporte ao Zed

O ECC fornece suporte a projetos do Zed através de um adaptador conservador .zed para configurações locais do projeto, regras achatadas, agentes, comandos e habilidades.

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

O adaptador escreve arquivos gerenciados pelo ECC sob .zed/ e mantém as credenciais BYOK/OpenRouter fora do repositório. Configure a conta Zed ou chaves de API através da própria interface de configurações do Zed ou das suas configurações locais de usuário.


Suporte ao OpenCode

O ECC fornece suporte completo ao OpenCode, incluindo plugins e hooks.

Início Rápido

# Install OpenCode
npm install -g opencode

# Run in the repository root
opencode

A configuração é detectada automaticamente a partir de .opencode/opencode.json.

Paridade de Recursos

RecursoClaude CodeOpenCodeStatus
AgentesPASS: 64 agentesPASS: 12 agentesClaude Code lidera
ComandosPASS: 84 comandosPASS: 35 comandosClaude Code lidera
HabilidadesPASS: 262 habilidadesPASS: 37 habilidadesClaude Code lidera
HooksPASS: 8 tipos de eventosPASS: 11 eventosOpenCode tem mais!
RegrasPASS: 29 regrasPASS: 13 instruçõesClaude Code lidera
Servidores MCPPASS: 14 servidoresPASS: CompletoParidade total
Ferramentas PersonalizadasPASS: Via hooksPASS: 6 ferramentas nativasOpenCode é melhor

Suporte a Hooks via Plugins

O sistema de plugins do OpenCode é MAIS sofisticado que o Claude Code, com mais de 20 tipos de eventos:

Hook do Claude CodeEvento Plugin do OpenCode
PreToolUsetool.execute.before
PostToolUsetool.execute.after
Stopsession.idle
SessionStartsession.created
SessionEndsession.deleted

Eventos adicionais do OpenCode: file.edited, file.watcher.updated, message.updated, lsp.client.diagnostics, tui.toast.show, e mais.

Entradas de Slash Mantidas

ComandoDescrição
/planCriar plano de implementação
/code-reviewRevisão de alterações de código
/build-fixCorrigir erros de compilação
/refactor-cleanRemover código morto
/learnExtrair padrões da sessão
/checkpointSalvar estado de verificação
/quality-gateExecutar o portão de verificação mantido
/update-docsAtualizar documentação
/update-codemapsAtualizar codemaps
/test-coverageAnalisar cobertura
/go-reviewRevisão de código Go
/go-testFluxo TDD para Go
/go-buildCorrigir erros de compilação do Go
/python-reviewRevisão de código Python (PEP 8, tipos hints, segurança)
/multi-planPlanejamento colaborativo multi-modelo
/multi-executeExecução colaborativa multi-modelo
/multi-backendFluxo multi-modelo focado em backend
/multi-frontendFluxo multi-modelo focado em frontend
/multi-workflowFluxo de desenvolvimento completo multi-modelo
/pm2Gerar automaticamente comandos do serviço PM2
/sessionsGerenciar histórico da sessão
/skill-createGerar habilidades a partir do git
/instinct-statusVisualizar instintos aprendidos
/instinct-importImportar instintos
/instinct-exportExportar instintos
/evolveAgrupar instintos em habilidades
/promotePromover instintos de projeto para escopo global
/projectsListar projetos conhecidos e estatísticas de instinto
/pruneExcluir instintos pendentes expirados (TTL 30d)
/learn-evalExtrair e avaliar padrões antes de salvar
/setup-pmConfigurar gerenciador de pacotes
/harness-auditAuditar confiabilidade do harness, prontidão para avaliação e postura de risco
/loop-startIniciar padrão de execução controlada de loop agêntico
/loop-statusInspectar status ativo do loop e checkpoints
/quality-gateExecutar verificações do portão de qualidade para caminhos ou repositório inteiro
/model-routeRotejar tarefas para modelos por complexidade e orçamento

Instalação de Plugins

Opção 1: Usar diretamente

cd ECC
opencode

Opção 2: Instalar como pacote npm

npm install ecc-universal

Em seguida, adicione ao seu opencode.json:

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

Essa entrada de plugin npm habilita o módulo de plugin OpenCode publicado do ECC (hooks/eventos e ferramentas de plugins).
Ele não adiciona automaticamente todo o catálogo completo de comandos/agentes/instruções do ECC à sua configuração de projeto.

Para a instalação completa do OpenCode do ECC, faça um dos seguintes:

  • Execute o OpenCode dentro deste repositório, ou
  • Copie os ativos de configuração .opencode/ embutidos para seu projeto e conecte as entradas instructions, agent e command no opencode.json.

Documentação

  • Guia de Migração: .opencode/MIGRATION.md
  • README do Plugin OpenCode: .opencode/README.md
  • Regras Consolidadas: .opencode/instructions/INSTRUCTIONS.md
  • Documentação LLM: llms.txt (documentação completa do OpenCode para LLMs)

Suporte ao GitHub Copilot

O ECC oferece suporte ao GitHub Copilot no VS Code via o sistema nativo de instruções e arquivos de prompt do Chat do Copilot — sem necessidade de ferramentas extras.

O que está incluído

ComponenteArquivoPropósito
Instruções centrais.github/copilot-instructions.mdRegras sempre carregadas: estilo de codificação, segurança, testes, fluxo do git
Configurações VS Code.vscode/settings.jsonArquivos de instrução por tarefa para geração de código, testes e mensagens de commit
Prompt de plano.github/prompts/plan.prompt.mdPlanejamento de implementação em fases
Prompt TDD.github/prompts/tdd.prompt.mdCiclo Red-Green-Improve
Prompt de revisão de segurança.github/prompts/security-review.prompt.mdAnálise profunda alinhada com OWASP
Prompt de correção de compilação.github/prompts/build-fix.prompt.mdResolução sistemática de erros de build e CI
Prompt de refatoração.github/prompts/refactor.prompt.mdLimpeza de código morto e simplificação

Início Rápido (GitHub Copilot)

Os arquivos já estão no lugar — abra qualquer repositório que contenha este projeto e o GitHub Copilot Chat automaticamente detectará .github/copilot-instructions.md. O settings.json commitado em .vscode/ habilita chat.promptFiles, permitindo que o VS Code carregue os prompts reutilizáveis de .github/prompts/.

Para usar os prompts do fluxo de trabalho no Copilot Chat:

  1. Abra o painel Copilot Chat no VS Code.
  2. Clique no ícone de grampo / anexar e selecione Prompt..., ou digite / para escolher um prompt.
  3. Selecione o prompt desejado (ex.: plan, tdd, security-review).

Como Funciona

O GitHub Copilot no VS Code lê automaticamente dois tipos de arquivos:

  • .github/copilot-instructions.md — instruções em nível de repositório, sempre injetadas em cada solicitação do Copilot Chat. Contém os padrões de codificação centrais da ECC, checklist de segurança, requisitos de teste e fluxo de trabalho git.
  • .github/prompts/*.prompt.md — arquivos de prompt reutilizáveis que o usuário invoca sob demanda. Cada prompt guia o Copilot por um fluxo de trabalho específico da ECC, como planejamento, TDD, revisão de segurança, correção de build ou refatoração.

O .vscode/settings.json adiciona camadas de instruções específicas para cada tarefa, garantindo que o Copilot receba o contexto adequado para geração de código, testes e redação de mensagens de commit.

Cobertura de Recursos

Recurso da ECCEquivalente no Copilot
Padrões de codificaçãoSempre ativo via copilot-instructions.md
Checklist de segurançaSempre ativo + prompt security-review
Testes / TDDSempre ativo + prompt tdd
Planejamento da implementaçãoPrompt plan
Revisão de códigoRevisão externa do PR via CodeRabbit e Greptile
Resolução de erros de buildPrompt build-fix
RefatoraçãoPrompt refactor
Formato da mensagem de commitInstrução por tarefa em settings.json
Hooks / automaçãoNão suportado (Copilot não possui sistema de hooks)
Agentes / delegaçãoNão suportado (Copilot não possui API de subagentes)

Limitações

O GitHub Copilot não possui um sistema de hooks nem uma API de subagentes, portanto as automações por hook da ECC (formatação automática, verificação TypeScript, persistência de sessão e guardião do servidor de desenvolvimento) e a delegação de agentes estão indisponíveis. A camada de instruções e prompts ainda traz toda a filosofia de codificação da ECC — padrões, segurança, TDD e fluxo de trabalho — para cada sessão no Copilot Chat.


Paridade de Recursos entre Ferramentas

A ECC é o primeiro plugin a maximizar todas as principais ferramentas de IA para codificação. Veja como cada harness se compara:

RecursoClaude CodeCursor IDECodex CLIOpenCodeGitHub Copilot
Agentes64Compartilhado (AGENTS.md)Compartilhado (AGENTS.md)12N/A
Comandos84CompartilhadoBaseado em instruções355 prompts
Habilidades262Compartilhado10 (formato nativo)37Via instruções
Eventos de Hook8 tipos15 tiposNenhum ainda11 tiposNenhum
Scripts de Hook20+ scripts16 scripts (adaptador DRY)N/AHooks do pluginN/A
Regras34 (comuns + idioma)34 (frontmatter YAML)Baseado em instruções13 instruções1 arquivo sempre ativo
Ferramentas PersonalizadasVia hooksVia hooksN/A6 ferramentas nativasN/A
Servidores MCP14Compartilhado (mcp.json)7 (unidos automaticamente via parser TOML)CompletoN/A
Formato de Configuraçãosettings.jsonhooks.json + regras/config.tomlopencode.jsoncopilot-instructions.md + settings.json
Arquivo de ContextoCLAUDE.md + AGENTS.mdAGENTS.mdAGENTS.mdAGENTS.mdcopilot-instructions.md
Detecção de SegredosBaseado em hookHook beforeSubmitPromptSandboxed (sandbox)Baseado em hookBaseado em instrução
Formatação AutomáticaHook PostToolUseHook afterFileEditN/Afile.edited hookN/A
VersãoPluginPluginConfig de referência2.0.0Camada de instruções

Decisões arquiteturais principais:

  • O arquivo universal cross-tool AGENTS.md na raiz é lido pelo Claude Code, Cursor, Codex e OpenCode (o GitHub Copilot usa .github/copilot-instructions.md em vez disso).
  • O padrão de adaptador DRY permite que o Cursor reutilize os scripts de hook do Claude Code sem duplicação.
  • O formato de Habilidades (SKILL.md com frontmatter YAML) funciona no Claude Code, Codex e OpenCode.
  • A falta de hooks no Codex é compensada pelo AGENTS.md, sobrescritas opcionais em model_instructions_file e permissões do sandbox.

Contexto

Estou usando o Claude Code desde seu lançamento experimental. Ganhei a hackathon Anthropic x Forum Ventures em setembro de 2025 com @DRodriguezFX — construí zenith.chat inteiramente usando o Claude Code.

Essas configurações foram testadas na produção em múltiplos aplicativos.


Otimização de Tokens

O uso do Claude Code pode ser caro se você não gerenciar o consumo de tokens. Essas configurações reduzem significativamente os custos sem sacrificar a qualidade.

Configurações Recomendadas

Adicione a ~/.claude/settings.json:

{
  "model": "sonnet",
  "env": {
    "MAX_THINKING_TOKENS": "10000",
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50"
  }
}
ConfiguraçãoPadrãoRecomendadoImpacto
modelopussonnetRedução de custo ~60%; lida com 80%+ das tarefas de codificação
MAX_THINKING_TOKENS31,99910,000Redução de ~70% no custo oculto de pensamento por requisição
CLAUDE_AUTOCOMPACT_PCT_OVERRIDE9550Compacta mais cedo — melhor qualidade em sessões longas
ECC_CONTEXT_MONITOR_COST_WARNINGSonoff para usuários com assinaturaSuprime avisos de estimativa de taxa da API voltados ao agente, mantendo avisos de contexto/escopo/bucles

Troque apenas para Opus quando precisar de raciocínio arquitetônico profundo:

/model opus

Comandos do Fluxo Diário

ComandoQuando Usar
/model sonnetPadrão para a maioria das tarefas
/model opusArquitetura complexa, depuração, raciocínio profundo
/clearEntre tarefas não relacionadas (reseta instantaneamente e sem custo)
/compactEm pontos de ruptura lógicos da tarefa (pesquisa concluída, marco atingido)
/costMonitorar gasto de tokens durante a sessão

Se você usa uma assinatura do Claude e as estimativas de taxa da API do monitor de contexto não são úteis, defina ECC_CONTEXT_MONITOR_COST_WARNINGS=off. Isso suprime apenas os avisos de custo voltados ao agente; não desativa avisos de esgotamento de contexto, escopo ou bucles.

Compactação Estratégica

A habilidade strategic-compact (incluída neste plugin) sugere /compact em pontos lógicos de ruptura, em vez de depender da compactação automática a 95% do contexto. Veja skills/strategic-compact/SKILL.md para o guia completo de decisão.

Quando compactar:

  • Após pesquisa/exploração, antes da implementação
  • Após completar um marco, antes de iniciar o próximo
  • Após depuração, antes de continuar com o trabalho no recurso
  • Após uma abordagem falha, antes de tentar outra

Quando NÃO compactar:

  • No meio da implementação (você perderá nomes de variáveis, caminhos de arquivos e estado parcial)

Gerenciamento da Janela de Contexto

Crítico: Não ative todos os MCPs ao mesmo tempo. A descrição de cada ferramenta do MCP consome tokens da sua janela de 200k, potencialmente reduzindo-a para ~70k.

  • Mantenha menos de 10 MCPs ativados por projeto
  • Mantenha menos de 80 ferramentas ativas
  • Use /mcp para desativar servidores do Claude Code MCP não utilizados; essas escolhas de tempo de execução persistem em ~/.claude.json
  • Use ECC_DISABLED_MCPS apenas para filtrar configurações de MCP geradas pelo ECC durante fluxos de instalação/sincronização

Aviso de Custo das Equipes de Agentes

Equipes de Agente cria múltiplas janelas de contexto. Cada colega consome tokens independentemente. Use apenas em tarefas onde o paralelismo oferece valor claro (trabalho multi-módulo, revisões paralelas). Para tarefas sequenciais simples, subagentes são mais eficientes quanto a tokens.


AVISO: Notas Importantes

Otimização de Tokens

Atingiu os limites diários? Veja o Guia de Otimização de Tokens para configurações recomendadas e dicas de fluxo de trabalho.

Ganhos rápidos:

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

Use /clear entre tarefas não relacionadas, /compact em pontos lógicos de ruptura e /cost para monitorar gastos.

Personalização

Essas configs funcionam para meu fluxo de trabalho. Você deve:

  1. Começar com o que ressoa
  2. Modificar para sua stack
  3. Remover o que não usa
  4. Adicionar seus próprios padrões

Patrocinadores

Patrocinadores em destaque estão no topo deste README — lista completa e tiers em SPONSORS.md. Torne-se um patrocinador.


Links


Licença

MIT - Use livremente, modifique conforme necessário e contribua se puder.


Dê uma estrela neste repositório se ajudar. Leia ambos os guias. Construa algo incrível.

Ver o original no GitHub

Bom para

Relacionados