CLI Reference

Verify both servers are built, the database is accessible, and all detected tools have EGC registered. The first command to run after installation.

$ egc doctor

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

Show the last 5 decisions saved to memory for the current project, along with the active branch state file.

$ 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

Compact the state file for the current project when it grows too large. Rewrites entries in three layers: Working (last 7 days, kept verbatim), Episodic (last 30 days, summarized per week), and Semantic (older entries, condensed to core facts). The original file is backed up to ~/.egc/state/archive/ before any rewrite.

$ 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

Install or reinstall the prompt library to a target harness. Useful when you add a new tool after the initial install.

$ egc install --target cursor

List available profiles and components in the prompt library, and search the whole catalog by keyword with ranked results.

$ egc catalog

agents    63
skills   230
commands  77
rules    111

$ egc catalog search memory session

Catalog matches for "memory session":

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

Restore drifted or missing managed files. Re-injects the cognitive bootstrap if it was overwritten.

$ egc repair

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

Play back a recorded session with timeline scrubbing: every tool call, file edit, and token count in order.

$ egc sessions
$ egc replay <session-id>

Set per-session token and cost limits, enforced by the pre-tool hook before each call.

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

Community plugin registry: install, list, update, and remove EGC plugins distributed via npm.

$ egc plugin install <name>
$ egc plugin list

Short token-savings report from the local Token Crusher ledger. Use egc gain for the full panel and egc discover for missed opportunities.

$ egc saved

Tokens saved: ~139.2K (99.7% efficiency)

Remove every EGC-managed file recorded in install-state, leaving your own configuration untouched.

$ egc uninstall --target cursor

Start the bidirectional state sync daemon. Watches all EGC-managed tool config files in the project. When any file is edited outside of EGC's own propagation cycle - for example, when you update context in Cursor - the change is extracted from the EGC block and synced to all other tools automatically. Changes are also merged back into ~/.egc/state/ for full round-trip persistence.

$ egc watch

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

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

# Suppress output:
$ egc watch --quiet

Start the EGC Dashboard, a real-time Mission Control panel at http://localhost:7890. Shows live tool calls, file edits, shell commands, token usage, memory state, and agent status as your AI works. The dashboard auto-starts after egc install and egc init and runs as a background server.

$ egc dashboard

EGC Dashboard running at http://localhost:7890

# Stop the background server:
$ egc dashboard stop

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

Run any command through the Token Crusher. Noisy output (long git logs, test noise, install spam, giant JSON) is compressed up to 90% before it reaches the model; errors and warnings always survive. On hook-capable tools this happens silently without typing anything.

$ 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

The full Token Crusher savings panel: totals, average per run, biggest crush, efficiency meter, and a breakdown by command kind. Read from the local ledger at zero token cost. Or just ask your AI "how much did I save?" and it runs this for you.

$ 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

Scan your recent session transcripts for crushable output that never went through the Token Crusher, and see what those runs could have saved.

$ 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

NanoClaw REPL: a persistent, session-aware agent loop with zero dependencies. Conversation history lives in plain Markdown files, so sessions survive restarts and stay greppable.

$ egc claw

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

claw> 

Scores your harness setup across tool coverage, context efficiency, quality gates, memory persistence, eval coverage, security guardrails, and cost efficiency. Text or JSON output.

$ egc harness-audit --format json

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

Pull the latest changes from GitHub and reinstall managed targets.

$ egc auto-update

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