Referência da CLI

Rode uma vez em cada projeto que você quer que o EGC gerencie. Prepara o protocolo cognitivo em todas as ferramentas detectadas, registra os servidores MCP, prepara o armazenamento do estado, configura o filtro de privacidade dos commits do repositório e termina com uma checagem compacta da instalação. Cada etapa imprime uma linha de checagem; o relatório completo está a um egc doctor de distância.

$ egc init

✓  cognitive protocol  6 tools up to date (v6)
✓  MCP registration  7 tools already registered
✓  memory  state store ready (6 migrations); loads on your first session
✓  commit-privacy filter  already configured; populated memory is stripped from staged blobs (local repo only)
✓  token crusher  shim installed and on PATH
✓  install check  12 targets healthy
Installation complete.

Confere se os dois servidores estão compilados, se o banco de dados está acessível e se todas as ferramentas detectadas têm o EGC registrado. É o primeiro comando a rodar depois da instalação.

$ egc doctor

egc-guardian  running
egc-memory    running
database      ok
claude code   registered
cursor        registered

# Check against a local development checkout instead of the installed package:
$ egc doctor --repo-root /path/to/EGC

Mostra as 5 últimas decisões salvas na memória do projeto atual, junto com o arquivo de estado da branch ativa.

$ egc status

Branch: feat/auth  (state: ~/.egc/state/my-app/feat-auth.md)
[2026-06-05] Moved from Prisma to Drizzle ORM
[2026-06-04] Dropped JWT in favor of iron-session
[2026-06-03] Settled on functional-only components
[2026-06-02] PostgreSQL with row-level security
[2026-06-01] Next.js 15 App Router

Compacta o arquivo de estado do projeto atual quando ele fica grande demais. Reescreve os itens em três camadas: Working (últimos 7 dias, mantidos na íntegra), Episodic (últimos 30 dias, resumidos por semana) e Semantic (itens mais antigos, condensados nos fatos essenciais). O arquivo original vai para um backup em ~/.egc/state/archive/ antes de qualquer reescrita.

$ egc consolidate

Consolidating state for my-app...
Working layer:  3 entries kept verbatim
Episodic layer: 12 entries summarized (2 weeks)
Semantic layer: 31 entries condensed
✓ Written to ~/.egc/state/my-app/main.md
  Backup at ~/.egc/state/archive/my-app-main-20260613.md

# Preview without writing:
$ egc consolidate --dry-run

# Run even if below the line threshold:
$ egc consolidate --force

Imprime o documento de memória descriptografado de um projeto (por padrão, a pasta atual) ou do escopo global do usuário. Em texto puro, sai o documento Markdown do Agent Memory Interchange do jeito que está guardado; com --json, ele é separado nos campos do cabeçalho e nas cinco seções. Só leitura: o arquivo de estado e a chave nunca são alterados. Códigos de saída: 0 impresso, 1 erro de uso ou arquivo de estado ou chave que não pode ser lido ou não é confiável, 2 nenhuma memória no escopo, 3 memória criptografada sem a chave.

$ egc export

# Project State
project: /home/you/projects/my-app
branch: main
...

# Another project, as JSON:
$ egc export --project /path/to/other-app --json

# The global scope shared by all projects:
$ egc export --scope global

Sem opções: prepara o motor e pergunta sobre a biblioteca de prompts opcional (o padrão é não; a partir da v1.1.22, --prompt-library e --no-prompt-library decidem sem a pergunta). Com --target e --profile: instala a biblioteca em uma ferramenta, por exemplo depois de adicionar uma ferramenta nova.

$ egc install --target cursor

Lista os perfis e componentes disponíveis na biblioteca de prompts e busca no catálogo inteiro por palavra-chave, com resultados ordenados.

$ egc catalog

agents    61
skills   232
commands  77
rules    109

$ egc catalog search memory session

Catalog matches for "memory session":

- ck [skill]
  Persistent per-project memory for Gemini Code...

Restaura arquivos gerenciados que mudaram ou sumiram. Injeta de novo o bootstrap cognitivo se ele foi sobrescrito.

$ egc repair

✓ ~/.claude/CLAUDE.md restored
✓ ~/.gemini/GEMINI.md restored

# Repair against a local development checkout instead of the installed package:
$ egc repair --repo-root /path/to/EGC

Reproduz uma sessão gravada com uma linha do tempo navegável: cada chamada de ferramenta, edição de arquivo e contagem de tokens, em ordem.

$ egc sessions
$ egc replay <session-id>

Define limites de tokens e de custo por sessão, aplicados pelo hook antes de cada chamada de ferramenta.

$ egc budget set --tokens 500000
$ egc budget status

Registro de plugins da comunidade: instala, lista, atualiza e remove plugins do EGC distribuídos pelo npm.

$ egc plugin install <name>
$ egc plugin list

Relatório curto da economia de tokens, lido do livro-caixa local do Token Crusher. Use egc gain para o painel completo e egc discover para as oportunidades perdidas.

$ egc saved

Tokens saved: ~139.2K (87.6% efficiency)

Remove todos os arquivos gerenciados pelo EGC registrados no install-state, sem tocar na sua própria configuração.

$ egc uninstall --target cursor

Inicia o daemon de sincronização do estado nos dois sentidos. Observa todos os arquivos de configuração de ferramentas gerenciados pelo EGC no projeto. Quando algum arquivo é editado fora do ciclo de propagação do próprio EGC (por exemplo, quando você atualiza o contexto no Cursor), a mudança é extraída do bloco do EGC e sincronizada com todas as outras ferramentas automaticamente. As mudanças também voltam para ~/.egc/state/, fechando o ciclo completo.

$ egc watch

[egc watch] Watching 4 tool config file(s) in /my-project
[egc watch] Press Ctrl+C to stop.
[egc watch] antigravity changed -> synced to: cursor, copilot, aider + state file

# Watch a specific project:
$ egc watch /path/to/project

# Suppress output:
$ egc watch --quiet

Inicia o EGC Dashboard, um painel de controle em tempo real em http://localhost:7890. Mostra ao vivo as chamadas de ferramenta, edições de arquivo, comandos de terminal, uso de tokens, estado da memória e status dos agents enquanto a sua IA trabalha. O painel inicia sozinho depois do egc install e do egc init e roda como servidor em segundo plano.

$ egc dashboard

EGC Dashboard running at http://localhost:7890

# Stop the background server:
$ egc dashboard stop

# Check if it's running:
$ egc dashboard status

Roda qualquer comando pelo Token Crusher. Saídas barulhentas (git logs longos, ruído de testes, poluição das instalações, JSON gigante) são comprimidas em até 90% antes de chegar ao modelo; erros e avisos sempre ficam. Nas ferramentas com hooks, isso acontece em silêncio, sem você digitar nada.

$ egc run git log
... (12439 more commits)
[egc-crusher] saved ~139178 tokens (full output: rerun with --raw)

# Escape hatch, full output:
$ egc run --raw git log

O painel completo de economia do Token Crusher: totais, média por execução, maior compressão, medidor de eficiência e divisão por tipo de comando. Lido do livro-caixa local, sem gastar token. Ou simplesmente pergunte à sua IA "quanto eu economizei?" e ela roda isso para você.

$ egc gain

EGC Token Gain (local ledger, zero token cost)
  Crushed runs:     12
  Tokens saved:     ~412.7K
  Efficiency:       ████████████████████████ 97.3%

# Run-by-run log:
$ egc gain --history

# Short summary:
$ egc saved

Varre as transcrições das suas sessões recentes em busca de saídas compressíveis que nunca passaram pelo Token Crusher, e mostra quanto essas execuções poderiam ter economizado.

$ egc discover

EGC Discover: crushable output that skipped the Token Crusher
  Transcripts scanned: 40 (last 7 days)
  Missed runs:         41
  Potential savings:   up to ~39.5K tokens

Instalado automaticamente pelo egc install e pelo egc auto-update. Um shim de binários no PATH (git, npm, pip, gh e outros) que comprime a saída barulhenta para qualquer ferramenta que os execute pelo terminal. Cobre uma lacuna conhecida: no Claude Code, a reescrita do hook PreToolUse nunca dispara para comandos que o assistente de IA roda pela própria ferramenta Bash, só para uma pessoa digitando direto no terminal, então é isso que faz o Crusher funcionar lá também. Uma pessoa num terminal interativo sempre recebe a saída completa e intacta; só a captura de saída não interativa passa pelo Token Crusher.

$ egc crusher-shim install
Shim directory: ~/.egc/bin
Installed: git, npm, pip, gh, ...
PATH updated in: ~/.bashrc, ~/.profile
Open a new terminal for it to take effect.

# Check status:
$ egc crusher-shim status

# Remove it:
$ egc crusher-shim uninstall

NanoClaw REPL: um loop de agent persistente, que conhece a sessão, sem nenhuma dependência. O histórico da conversa fica em arquivos Markdown simples, então as sessões sobrevivem a reinícios e dá para buscar nelas com grep.

$ egc claw

NanoClaw v2: Session: default
Type /help for commands, exit to quit.

claw> 

Dá nota à configuração do seu harness em cobertura de ferramentas, eficiência de contexto, gates de qualidade, persistência da memória, cobertura de avaliações, proteções de segurança e eficiência de custo. Saída em texto ou JSON.

$ egc harness-audit --format json

{
  "scope": "repo",
  "deterministic": true,
  ...
}

Baixa as últimas mudanças do GitHub, reinstala os destinos gerenciados e roda de novo o bootstrap cognitivo, para que instalações já configuradas recebam as novas seções do protocolo em vez de ficarem congeladas no que veio na primeira instalação. Numa instalação pelo npm, ele imprime o comando de atualização; no Windows, feche as ferramentas de IA e os terminais que rodam o EGC antes de rodá-lo, senão o npm falha com EBUSY num arquivo que não consegue renomear.

$ egc auto-update

Pulling latest from origin/main...
Building egc-guardian... done
Building egc-memory...  done
Reinstalling targets...
✓ claude code updated
✓ cursor updated

# Update against a local development checkout instead of the installed package:
$ egc auto-update --repo-root /path/to/EGC

Mostra os manifestos da instalação seletiva e o plano resolvido para um destino e um perfil antes de gravar qualquer coisa.

$ egc plan --profile core --target cursor

Recomenda componentes e perfis do EGC a partir de uma descrição em linguagem natural do que você está construindo.

$ egc consult "a Django API with Celery workers"

Mostra os arquivos de install-state do contexto atual: qual destino, qual perfil, quais arquivos.

$ egc list-installed

Visão agregada, só de leitura, de todos os estados de memória por projeto nesta máquina.

$ egc overview

Roda o comando de verificação do projeto e registra um comprovante para o gate de commit.

$ egc verify

Sincronização da memória da equipe por um remoto git: init uma vez por máquina, sync para trazer e enviar lições, status para ver a saúde.

$ egc team init <remote>
$ egc team sync
$ egc team status

Telemetria anônima de uso, perguntada uma vez na primeira execução do install, do doctor ou do init: status, on, off.

$ egc telemetry status
$ egc telemetry off

Emite snapshots canônicos de sessões do EGC a partir de históricos do dmux ou do Gemini.

$ egc session-inspect

Examina as transcrições em busca de wakeups de loop parados e resultados de ferramenta pendentes.

$ egc loop-status