Plan boundary
Compile gates: spec-lint, coldstart, parallax, premortem, scope-overlap
The plan boundary is the point where a plan stops being prose and becomes an executable plan.json. agb does not author plans. You plan in Antigravity (plan mode or a planning conversation writes implementation_plan.md into a brain), or you write a local spec.md. agb plan treats that artifact as source and plan.json as a compiled output (lib/plan.mjs).
agb plan <brain-id-or-prefix | spec.md> <repo-path> [--out plan.json] [--force] [--no-coldstart] [--no-parallax] [--no-premortem]C13 The full flag set is --out, --force, --no-coldstart, --no-parallax and --no-premortem. Without --force, agb plan refuses to overwrite an existing output file, because a hand-written plan may be sitting there (bin/agb.mjs). Each --no-* flag switches off one gate (bin/agb.mjs). Compiling needs live quota telemetry from agy; without it the command exits 1 before converting anything (bin/agb.mjs).
The compile pipeline
Stage A: structural loop (deterministic, blocking)
A model converts the plan into a ticket DAG. Then validatePlan checks the schema, ticket ids, edges, scopes, rails, tiers and pool_hint routability (lib/plan.mjs), and forecastOverlaps runs the scope-overlap gate: any two tickets that can run at the same time (neither reaches the other through edges) must not declare overlapping scopes (lib/preflight.mjs). An overlap is a structural error with the remediation "repartition the files or add an edge" (lib/plan.mjs).
These checks are free, so every failure is fed straight back to the converter, up to maxAttempts (3) conversions (lib/plan.mjs).
Stage B: coldstart and parallax (model, blocking)
Two LLM gates run in parallel (lib/plan.mjs):
- coldstart asks a fresh, read-only model on the cheap tier whether each ticket is executable by an agent that has only its
body(lib/preflight.mjs). Any gap blocks. - parallax interrogates each edge for contract ambiguity: several readers interpret the contract and a judge decides whether they diverge (lib/plan.mjs). A divergent edge blocks.
Blocking findings get exactly one feedback re-conversion, then the gates run again (lib/plan.mjs). A gate that errors counts as blocking.
Premortem (model, advisory)
C13 Premortem runs once on the surviving plan. It assumes the run already failed and lists likely causes. It is advisory: it never vetoes a compile. agb plan prints the causes with their likelihood after writing plan.json (bin/agb.mjs).
Projection and advisory tiers
A blocking-free plan is projected into the ADLC ticket store (the .adlc/tickets/ directory store; a repo with the retired .adlc/tickets.json is refused with LEGACY_TICKET_STORE) so the plugin's rails hook and the adlc CLI see the same active tickets (lib/adlc-bridge.mjs). adlc model-router then cross-checks tiers and adlc merge-forecast sets plan.concurrencyCap. Both are advisory and degrade to a warning when unavailable (lib/plan.mjs).
Outcomes
| Result | Exit code | What to do |
|---|---|---|
| Compiled | 0 | plan.json is written; next step is agb run plan.json. |
| Blocking findings remain | 2 | Fix the plan (the brain plan in Antigravity, or your spec.md) and re-run agb plan. Do not hand-edit the compiled JSON (bin/agb.mjs). |
| Usage, existing output, or no quota telemetry | 1 | Fix the invocation or your agy login. |
Where spec-lint fits
agb plan does not run spec-lint. Lint the spec yourself before compiling, with adlc spec-lint from the ADLC toolkit (the same goes for a stand-alone adlc premortem or adlc parallax on the spec text). The compile gates above check the ticket DAG; spec-lint checks the spec that produced it.
Gate strictness
By default, plan.gate.build and plan.gate.test must match npm test or npm run <script> (lib/plan.mjs). AGB_STRICT_GATES=0 relaxes this (lib/plan.mjs).
Hand-written plans skip the compiler but not validation: see Writing plans and the plan schema.