your prompt
               │
               ▼
   ┌───────────────────────┐   deterministic · <0.5 s · zero model calls
   │       COMPILE         │   callers · git log · blast radius · bug-site source
   └───────────────────────┘
               │   facts injected before the agent's first token
               ▼
   ┌───────────────────────┐
   │      YOUR AGENT       │   edits with the facts already in context
   └───────────────────────┘
               │   after it edits
               ▼
   ┌───────────────────────┐   scoped review over exactly the changed lines
   │        VERIFY         │   returns a fix-or-suppress list before it stops
   └───────────────────────┘

pip install git+https://github.com/Cranot/compile-code
cd your-repo
compile claude          # index + wire + launch Claude Code, all-in-one

That one line installs the compile CLI and its roam-code engine. (A shorter pip install compile-code lands with the first PyPI release.)

That's it. From then on, every prompt you type gets compiled facts injected before the model sees it, and every edit gets a scoped verification after. Prefer your native workflow? Wire once, then keep typing claude like always:

compile init
compile wire claude     # persistent; `compile unwire claude` to undo

Requirements: Python 3.10+, a git repository, and Claude Code for the wired flow (compile run works standalone). The indexer reads 28 languages.

For a one-off navigation prompt, preflight the facts before your agent starts with broad grep/read setup:

compile run "who calls handleSave?"

That prints the compiled answer envelope up front: callers, file:line citations, and the answer contract the agent can use instead of re-deriving the basics.

Coding agents burn most of their turns and tokens gathering context: grepping for the symbol, reading the file, running git log, re-deriving the call graph. All of that is deterministic — a compiler can do it in well under a second from a local index, with zero model calls, and hand the agent the answers up front.

All numbers are head-to-head A/B runs — the identical prompt and repo, with and without the compiled envelope — on a 300+ KLOC production Python codebase, June 2026. Medians over repeated runs; negative cells published alongside the wins.

Headline (Claude Fable 5, 41-cell A/B, n=2/cell — controlled benchmark, June 2026, roam v13.4):

A second run on Claude Opus showed the same direction at smaller magnitude (−33% turns overall on that run; the best single cell reached −88%, but no aggregate supports more than −33%). Other model tiers (Sonnet, Haiku, non-Claude agents) have not been measured on this A/B — the deltas above are measured on the frontier tier and should not be assumed to transfer. On a ground-truth bug bench (a failing test must transition to passing — not LLM-judged), the compiled arm fixed 10/10, as did vanilla, at −13% cost. Read that honestly: 10/10 vs 10/10 does not establish quality parity — at n=10 the 95% interval on the true resolve rate runs [72%, 100%], and a compiled arm that had genuinely dropped to 90% would still have shown 10/10 about a third of the time. It means no quality difference was detected at a sample size with little power to detect one.

A real envelope, compiled from this repo (compile run "who calls _require_index?", trimmed):

VERDICT: l1_probe_envelope for structural_callers
procedure:       structural_callers
classifier_conf: 0.85
named_paths:     ['src/compile_code/cli.py', 'tests/test_cli.py']

PREFETCHED ANSWERS (do not re-run the tools that produced these):
  callers: (2 items)
    - {'name': 'claude',  'location': 'src/compile_code/cli.py:131', 'edge': 'call',
       'call_line': 'if not _require_index():',  'call_location': 'src/compile_code/cli.py:145'}
    - {'name': 'doctor',  'location': 'src/compile_code/cli.py:182', 'edge': 'call',
       'call_line': 'indexed = _require_index()', 'call_location': 'src/compile_code/cli.py:190'}
  callers_definition: Callers of `_require_index`. Each entry includes
    `call_line` — the actual calling source line — so you do NOT need to
    re-grep the symbol.

The agent receives this before its first token. The answer to "who calls _require_index?" is already in its context, with file:line citations and an answer contract — no grep, no file reads, no tool-call round-trips.

The compiler classifies your prompt into one of 23 intent procedures (deterministic regex + a local code graph — no model calls) and pre-executes the matching probes:

• "who calls handleSave?" → the caller list, with file:line
• "what changed in api.py last week?" → the git log, already filtered
• "fix the bug in cli.py:45" → the source around line 45, gutter-numbered
• "what breaks if I refactor X?" → blast radius + affected tests
• "where is the entry point?" → the [project.scripts] console script
• "compare X vs Y", "top 5 most-imported files", "why is the CLI slow?" → the comparison, the ranking, the hot path — already computed
• unknown/freeform → file skeleton + targeted search, budget-capped
• generation-shaped ("write a test for X") → lean envelope or nothing — measured as a loss, so the compiler stays out of the way

Everything arrives as a compact envelope (typically ~10 KB) with an answer contract, so the agent answers from facts instead of re-deriving them. If a file you named carries known open findings (complexity, N+1 shapes), the envelope says so — the agent fixes debt opportunistically instead of re-deriving it.

The other half of the loop: when your agent finishes editing, a scoped review runs over exactly the lines it changed — and comes back as a fix-or-suppress list the agent resolves before it stops. You see clean turns; the agent quietly cleans up after itself.

What it catches, in practice:

• a function name that breaks your codebase's own convention (learned from your production code, not a style guide — test fixtures never vote)
• an import that resolves to nothing — not your code, not the standard library (Python stdlib / Node builtins), not anything declared in pyproject or package.json. That is the signature of a hallucinated dependency, and it FAILs the check with did-you-mean candidates when a near-miss exists
• swallowed exceptions, broken syntax, complexity spikes, copy-paste duplicates — each disclosed honestly when a sub-check could not run
• a credential-shaped string about to be committed (cloud keys, tokens, PEM blocks), plus any pattern your repo declares must never ship
• quadratic loop shapes the algo catalog knows (N+1 queries, re-sorted accumulators, JSON.parse(JSON.stringify(...)) clones) — advisory, with a concrete fix sketch

Suppressions are keyed to the symbol, not the line, so they survive refactors. The whole loop is fail-open: if anything in it breaks, your agent runs as if compile-code were not installed. --no-verify skips it.

These checks are themselves eval-gated: a planted-issues corpus proves every category catches its canonical positives, and false-positive locks are dogfooded across three real repos (a Python package, a production Vue 3 app, a Node/TS server) — no false positives across that corpus, planted hallucinations caught in both languages.

compile-code and cmpl are aliases for compile if another tool owns that name on your system.

One-command wiring (compile wire claude) targets Claude Code's hook system today. The compiler itself is agent-agnostic — the compiled envelope is just text, so any agent can consume it right now:

• Any agent, headless. compile run "who calls handleSave?" prints the envelope to stdout. Pipe it into Codex, paste it into a chat, or feed it to a CI step — no Claude required. --json gives a machine-readable envelope.
• Codex and other MCP clients. The kernel ships an MCP server (roam mcp, from the roam-code dependency). Point Codex — or any MCP-capable client — at it and the same graph facts (callers, blast radius, history) are exposed as live tools.
• Roadmap. A one-command compile wire codex (MCP-first) is planned, so Codex gets the same before-the-first-token injection Claude has today.

Every mode is 100% local — no API keys, nothing leaves your machine.

compile doctor diagnoses the three states that matter: toolchain on PATH, index present, hooks wired (at either level). Every failure surfaces as a one-line VERDICT: with the fix — never a traceback. Exit codes: 0 ok, 1 user-fixable state, 2 toolchain missing, 124 timeout.

The hooks are fail-open end to end: if the compiler or verifier ever breaks, your agent runs exactly as if compile-code weren't installed. Uninstall completely with compile unwire claude && pip uninstall compile-code roam-code.

The kernel (indexer, code graph, classifier, probes, verify) is the roam-code toolchain, installed automatically as a dependency. compile-code is the product surface for the compile loop — the same relationship as a compiler driver over its toolchain libraries. 100% local, no API keys, nothing leaves your machine.

Apache-2.0 — see LICENSE. The kernel (roam-code) is Apache-2.0 too.