@skyf0xx/hedgehog 4.0.3 → 4.0.7

package/bin/cli.mjs

@@ -17,18 +17,37 @@ import { constants } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join, relative, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
-import { dbInit, DB_PATH, openDb } from '../src/db/init.mjs';
-import { loadCore } from '../src/db/core.mjs';
+import { dbInit, DB_PATH, dbAbsPath, openDb } from '../src/db/init.mjs';
+import { loadCore, lintCore } from '../src/db/core.mjs';
 import { planTasks } from '../src/db/plan.mjs';
 import { addIntent, INTENTS_DIR } from '../src/db/intent.mjs';
-import { nextTask, formatNext, stalledTasks } from '../src/db/next.mjs';
+import {
+  nextTask,
+  formatNext,
+  formatPacket,
+  stalledTasks,
+  taskPacket,
+  taskStatusLine,
+} from '../src/db/next.mjs';
 import { verifyTask } from '../src/db/verify.mjs';
-import { claimTasks, releaseTask, renewLease } from '../src/db/claim.mjs';
+import {
+  claimTasks,
+  claimTask,
+  releaseTask,
+  renewLease,
+  retryTask,
+} from '../src/db/claim.mjs';
 import { readyTasks, formatReady } from '../src/db/ready.mjs';
 import { graphStatus, formatStatus } from '../src/db/status.mjs';
+import { boundaryState, formatBoundary, formatPosition, formatHandoff } from '../src/db/boundary.mjs';
+import { commitGateStatus, formatCommitGate } from '../src/db/gate.mjs';
+import { detectDrift, recompileTasks, formatRecompile } from '../src/db/drift.mjs';
+import { coreMissingRequirements, missingBinaries } from '../src/db/requires.mjs';
 import { whyPath, formatWhy } from '../src/db/why.mjs';
 import { addFriction, listFriction } from '../src/db/friction.mjs';
+import { addDebt, listDebt } from '../src/db/debt.mjs';
 import { rebuildDb } from '../src/db/rebuild.mjs';
+import { loadOverrides, addOverride, orphanedOverrides, OVERRIDES_DIR } from '../src/db/overrides.mjs';
 import { HOSTS, HOST_FLAGS, DEFAULT_HOST, availableHosts } from '../src/hosts/index.mjs';
 import { recordHosts, installedHosts } from '../src/hosts/installed.mjs';
 
@@ -187,6 +206,17 @@ const exists = (p) =>
     () => false,
   );
 
+// Printed by every command that writes to the build graph, before it
+// writes. DB_PATH is relative (`.hedgehog/hedgehog.db`), so which
+// database a command actually opens depends entirely on the directory it
+// was run from — a recovery command run one directory up silently opens
+// (or creates) a different database, matches nothing, and reports
+// success. Naming the absolute path on every write makes that visible in
+// the output instead of only in the outcome.
+function printDbTarget() {
+  console.log(`  ${dim('db')}      ${dbAbsPath()}`);
+}
+
 // Runs once at the top of every command that needs the build graph. A
 // fresh clone has no `.hedgehog/hedgehog.db` (it's a derived artifact,
 // not committed) but does have `.hedgehog/intents/*.json` — the committed
@@ -196,7 +226,11 @@ const exists = (p) =>
 // there's nothing to rebuild from either (a genuinely fresh project, no
 // intents yet), this no-ops and leaves the DB missing — the caller's own
 // existing "No build graph found" guard still fires for that case.
-async function ensureDb() {
+// `log` exists for the one caller whose stdout is a machine-consumable
+// payload (`hedgehog boundary`): the rebuild notice is commentary, and
+// commentary on stdout would corrupt a block meant to be captured or
+// piped. Every other command leaves it at the default.
+async function ensureDb({ log = console.log } = {}) {
   if (await exists(DB_PATH)) return;
 
   let intentFiles = [];
@@ -218,9 +252,25 @@ async function ensureDb() {
   } finally {
     db.close();
   }
-  console.log(
+  log(
     `${dim('DB missing — rebuilt from')} ${bold(INTENTS_DIR)}${dim(':')} ${dim(`${result.intentsReplayed} intent(s) replayed, ${result.tasksMarkedComplete} task(s) marked complete`)}\n`,
   );
+  warnRebuildDrift(result, corePath);
+}
+
+// A rebuild re-derives every task from the current core.yaml and the
+// committed intents. Nothing else is committed — a task row someone
+// patched by hand has no source to replay from — so say plainly what a
+// rebuild can and cannot carry, and surface any task that ends up
+// disagreeing with core.yaml.
+function warnRebuildDrift({ drift }, corePath) {
+  if (!drift || drift.length === 0) return;
+  console.log(
+    `${yellow(bold('Core drift after rebuild.'))} ${drift.length} task(s) do not match ${bold(corePath)}.\n` +
+      `A rebuild replays ${bold(INTENTS_DIR)} and re-derives tasks from core.yaml; task rows\n` +
+      'edited by hand have no committed source and are not replayed. Run\n' +
+      `${bold('hedgehog status')} for the divergence, ${bold('hedgehog plan --recompile')} to reconcile.\n`,
+  );
 }
 
 // Writes one planned file to disk — a straight copy, or for a `merge`
@@ -305,28 +355,49 @@ ${bold('Usage')}
   npx @skyf0xx/hedgehog update                    refresh the installed agents + skills
   npx @skyf0xx/hedgehog db init                   create .hedgehog/hedgehog.db if absent
   npx @skyf0xx/hedgehog db rebuild                re-derive the build graph from committed intents + git history
-  npx @skyf0xx/hedgehog plan                      compile pending intents into tasks + dependencies,
-                                                   then open the build graph if anything compiled
+  npx @skyf0xx/hedgehog plan                      compile pending intents into tasks + dependencies
+                                                   (starts no graph server; --no-open says so explicitly)
+  npx @skyf0xx/hedgehog plan --open               also start the graph server and open it, if anything compiled
+  npx @skyf0xx/hedgehog plan --recompile          rewrite core.yaml-derived fields on not-started tasks
+                                                   [--dry-run] [--include-blocked] [--strict]
+  npx @skyf0xx/hedgehog override add <task-id> --scope <glob> [--scope <glob>...] --reason "<why>"
+                                                   record a committed, additive-only scope exception for one task
+  npx @skyf0xx/hedgehog override list             list recorded scope overrides
   npx @skyf0xx/hedgehog intent add [flags]        add an intent (rules/requirements/dependencies)
   npx @skyf0xx/hedgehog intent add --file <path>  add an intent from a JSON file
   npx @skyf0xx/hedgehog next                      print the task packet for one ready task
+  npx @skyf0xx/hedgehog show <task-id>            print the task packet for any task, at any status
   npx @skyf0xx/hedgehog claim --owner <owner> [--count <n>]   atomically claim up to n ready tasks
+  npx @skyf0xx/hedgehog claim <task-id> --owner <owner>   claim one specific task (breaks a starvation tie)
+  npx @skyf0xx/hedgehog retry <task-id>           return a blocked task to planned, so it can be rebuilt
   npx @skyf0xx/hedgehog release <task-id> --owner <owner>   hand a claimed task back to ready
   npx @skyf0xx/hedgehog renew <task-id> --owner <owner> [--minutes <n>]   extend a held lease
   npx @skyf0xx/hedgehog verify <task-id> --owner <owner>   run scope + verify checks, commit on pass
-  npx @skyf0xx/hedgehog status                    graph overview: counts by status, ready list, in flight
+  npx @skyf0xx/hedgehog status                    graph overview: counts by status, ready list, in flight,
+                                                   and any drift from core.yaml
   npx @skyf0xx/hedgehog ready                     preview which ready tasks are claimable now vs held back
   npx @skyf0xx/hedgehog quiesce                   report whether anything is still in flight
+  npx @skyf0xx/hedgehog boundary                  is this a moment to clear context? exits 0 only if it is,
+                                                   and prints what a fresh session picks up next
+  npx @skyf0xx/hedgehog boundary --handoff        print the block a fresh session starts from
+  npx @skyf0xx/hedgehog boundary --quiet          exit code only, for a shell hook
   npx @skyf0xx/hedgehog graph                     start (or reuse) the live graph server and open it
   npx @skyf0xx/hedgehog graph --no-open           start (or reuse) the server; print the URL instead
   npx @skyf0xx/hedgehog why <path>                provenance chain for a file
   npx @skyf0xx/hedgehog friction add "<note>"     log a friction note [--task <task-id>]
   npx @skyf0xx/hedgehog friction list             list logged friction, oldest first
+  npx @skyf0xx/hedgehog debt add <task-id> "<note>"   declare debt that lands in dependent tasks' packets
+  npx @skyf0xx/hedgehog debt list [<task-id>]     list declared debt, oldest first
   npx @skyf0xx/hedgehog --help
 
 Available cores: ${cores.join(', ')}
 Available hosts: ${availableHosts().join(', ')} (default: ${DEFAULT_HOST})
 
+Every command that writes to the build graph prints the absolute path of
+the database it opened, and exits non-zero when it matched no task —
+which database a relative path resolves to depends on the directory you
+ran from.
+
 After it runs, commit the payload, open your coding agent, and describe
 what you want to build — the planner agent runs planning intake, then
 hands off to bootstrap.
@@ -423,8 +494,17 @@ async function init({ force, core, explicitCore, host = DEFAULT_HOST, hostOnly =
   );
   console.log('Next steps:');
   if (explicitCore) {
-    console.log(`  1. ${bold('git add -A && git commit -m "chore: install Hedgehog"')}`);
-    console.log(`  2. ${bold('pnpm install')}`);
+    // `pnpm install` before the first commit, not after it. The core's
+    // commit gate is lefthook, and lefthook's hooks are written by its
+    // own postinstall — so a commit made before the install is a commit
+    // made with no gate at all, and the instruction that put it first
+    // was quietly teaching the project to skip its own discipline on
+    // the one commit that lands the entire workspace. Installing first
+    // means commit #1 is already gated; with no HEAD to diff against it
+    // runs the whole workspace (see lefthook.yml), so expect it to take
+    // as long as a full typecheck/lint/test — that is the gate working.
+    console.log(`  1. ${bold('pnpm install')}`);
+    console.log(`  2. ${bold('git add -A && git commit -m "chore: install Hedgehog"')}`);
     console.log(`  3. Open ${HOSTS[host].label} and describe what you want to build.`);
   } else {
     console.log(`  1. ${bold('git add -A && git commit -m "chore: install Hedgehog"')}`);
@@ -520,6 +600,7 @@ async function dbRebuildCommand() {
     return;
   }
 
+  printDbTarget();
   await dbInit(DB_PATH);
   const db = openDb();
   let result;
@@ -532,6 +613,7 @@ async function dbRebuildCommand() {
   console.log(
     `${green('rebuilt')}  ${dim(`${result.intentsReplayed} intent(s) replayed, ${result.tasksMarkedComplete} task(s) marked complete`)}\n`,
   );
+  warnRebuildDrift(result, corePath);
 }
 
 async function dbCommand(args) {
@@ -547,6 +629,7 @@ async function dbCommand(args) {
     process.exitCode = 1;
     return;
   }
+  printDbTarget();
   const { created, path } = await dbInit(DB_PATH);
   console.log(
     created
@@ -570,9 +653,84 @@ async function resolveCorePath() {
   return null;
 }
 
-async function planCommand() {
+// `hedgehog plan --recompile` — the reconciliation path for a core.yaml
+// edited after `plan` already compiled it.
+//
+// `plan` copies each layer's scope globs, verify command, commit message,
+// exclusivity and verify radius onto every task row, and from then on the
+// row is what `next`/`claim`/`verify` read. A plain re-run can't fix a
+// later core.yaml correction — compiling an intent flips it to `active`,
+// and `plan` only ever looks at `proposed`/`planned` ones — so before this
+// existed the only remedy was an UPDATE in SQLite by hand.
+//
+// Deliberately not a fresh compile: it rewrites fields on tasks nothing
+// has acted on yet and refuses the rest, so ids, dependencies, statuses
+// and history are untouched.
+async function planRecompileCommand(args, { core, corePath }) {
+  const includeBlocked = args.includes('--include-blocked');
+  const dryRun = args.includes('--dry-run');
+  const strict = args.includes('--strict');
+  const overrides = await loadOverrides();
+
+  const db = openDb();
+  let result;
+  try {
+    result = recompileTasks(db, core, { includeBlocked, dryRun, overrides });
+  } finally {
+    db.close();
+  }
+
+  if (dryRun) console.log(dim('  (--dry-run — nothing was written)'));
+  console.log(formatRecompile(result));
+
+  if (result.updated.length === 0 && result.skipped.length === 0) {
+    console.log(`\n${green(bold('In sync.'))} Every task matches ${bold(corePath)}.\n`);
+    return;
+  }
+
+  if (result.skipped.length > 0) {
+    console.log(
+      `\n${yellow(bold('Some drift remains.'))} Each skipped task above names why it kept its compiled\n` +
+        'fields. A task already built, leased, or committed is a Correction Protocol\n' +
+        'case (fix the layer at its source, re-run that layer), not a field rewrite;\n' +
+        'a changed depends_on or a layer dropped from core.yaml is a graph-shape\n' +
+        'change, which --recompile deliberately does not make.\n',
+    );
+  } else {
+    console.log(`\n${green(bold('Recompiled.'))}\n`);
+  }
+
+  if (strict && result.skipped.length > 0) process.exitCode = 1;
+}
+
+// `hedgehog plan [--open|--no-open]` — compiles pending intents.
+//
+// Starting the live graph server is opt-in (`--open`), not automatic.
+// Hedgehog's primary caller is an agent in a headless session: there is
+// no browser for `openInBrowser` to hand the URL to, so the old
+// unconditional `startOrReuseGraphServer()` bought nothing and cost a
+// detached `node` process left listening on 127.0.0.1 with an open
+// handle on the build graph, plus a `.hedgehog/graph-server.json`
+// pidfile outliving the command that wrote it. `hedgehog graph` is the
+// one command whose *purpose* is that server; `plan`'s purpose is
+// compiling the graph, and it now exits having started nothing.
+//
+// `--no-open` is accepted for symmetry with `hedgehog graph` and names
+// the default explicitly. It differs from `graph --no-open` in one way
+// that follows from the same principle: on `graph` the server is the
+// point and only the browser is suppressed, whereas on `plan` the
+// server exists solely to be opened, so suppressing the open leaves
+// nothing worth serving — no server, no pidfile, no orphan.
+async function planCommand(args = []) {
   await ensureDb();
 
+  const wantsOpen = args.includes('--open');
+  if (wantsOpen && args.includes('--no-open')) {
+    console.error(`${red('Usage:')} hedgehog plan takes --open or --no-open, not both\n`);
+    process.exitCode = 1;
+    return;
+  }
+
   const corePath = await resolveCorePath();
   if (!corePath) {
     console.error(
@@ -588,32 +746,72 @@ async function planCommand() {
     return;
   }
 
+  printDbTarget();
   const core = await loadCore(corePath);
+
+  if (args.includes('--recompile')) {
+    await planRecompileCommand(args, { core, corePath });
+    return;
+  }
+
+  const overrides = await loadOverrides();
   const db = openDb();
   let result;
   try {
-    result = planTasks(db, core);
+    result = planTasks(db, core, overrides);
   } finally {
     db.close();
   }
 
+  for (const id of result.once) {
+    console.log(`  ${green('compiled')}  ${id} ${dim('(once — one task for the whole build)')}`);
+  }
   for (const id of result.compiled) console.log(`  ${green('compiled')}  ${id}`);
   for (const id of result.skipped) console.log(`  ${dim('skipped')}  ${id} ${dim('(already compiled)')}`);
+  for (const id of result.reopened) {
+    console.log(
+      `  ${bold('reopened')}  ${id} ${dim('(once — new scope landed under it; it must run again)')}`,
+    );
+  }
   console.log(
     `\n${green(bold('Plan complete.'))} ${dim(`${result.compiled.length} intent(s) compiled, ${result.skipped.length} skipped`)}\n`,
   );
 
+  // A plain `plan` is where someone lands after editing core.yaml,
+  // expecting the edit to take. It won't — already-compiled tasks carry
+  // their own copy of the layer's fields — so say so here rather than
+  // letting the run report "0 compiled" and look like a no-op.
+  const driftDb = openDb({ readOnly: true });
+  let drifted;
+  try {
+    drifted = detectDrift(driftDb, core, { overrides });
+  } finally {
+    driftDb.close();
+  }
+  if (drifted.length > 0) {
+    console.log(
+      `${yellow(bold('Core drift.'))} ${drifted.length} already-compiled task(s) no longer match ${bold(corePath)}.\n` +
+        `Compiling does not revisit them. Run ${bold('hedgehog status')} to see the divergence,\n` +
+        `or ${bold('hedgehog plan --recompile')} to rewrite the not-started ones.\n`,
+    );
+  }
+
   // Only worth opening when this run actually changed the graph's shape
   // — a plan run that compiled nothing (every intent already had tasks)
-  // would just re-open what's already open. planTasks's own db handle is
-  // closed by this point: the graph server opens its own connection in a
-  // separate process, and holding two write-capable handles on the same
-  // sqlite file across that handoff invites lock contention for no
-  // benefit.
-  if (result.compiled.length > 0) {
-    const { port } = await startOrReuseGraphServer();
-    openInBrowser(`http://localhost:${port}`);
+  // would just re-open what's already open.
+  if (result.compiled.length === 0) return;
+
+  if (!wantsOpen) {
+    console.log(`${dim('Run')} ${bold('hedgehog graph')} ${dim('to view the build graph.')}\n`);
+    return;
   }
+
+  // planTasks's own db handle is closed by this point: the graph server
+  // opens its own connection in a separate process, and holding two
+  // write-capable handles on the same sqlite file across that handoff
+  // invites lock contention for no benefit.
+  const { port } = await startOrReuseGraphServer();
+  presentGraphUrl(`http://localhost:${port}`);
 }
 
 // Parses `hedgehog intent add` args into the same record shape
@@ -707,6 +905,7 @@ async function intentCommand(args) {
     return;
   }
 
+  printDbTarget();
   const db = openDb();
   let intent;
   try {
@@ -752,8 +951,11 @@ async function nextCommand() {
         const reason = BLOCKED_REASON_LABELS[task.blocked_reason] ?? task.blocked_reason;
         console.error(`  ${red('✗')} ${bold(task.id)}   ${task.layer}   ${dim(reason)}`);
       }
+      // `verify` refuses anything that isn't `building` and leased to
+      // the caller, so a blocked task has to go back through the queue
+      // — retry, claim, then verify — rather than straight to verify.
       console.error(
-        `\nFix the work, then re-run ${bold('hedgehog verify <task-id>')}.\n`,
+        `\nFix the work, then ${bold('hedgehog retry <task-id>')} and claim it again.\n`,
       );
       process.exitCode = 1;
       return;
@@ -765,6 +967,66 @@ async function nextCommand() {
   console.log(formatNext(packet));
 }
 
+// Mirrors, read-only, the condition verifyTask's own Phase 0
+// (claimForVerify) enforces: after expired leases are reaped, the task
+// must be `building` and leased to `owner`. The expiry predicate is
+// claim.mjs#reapExpiredLeases's, kept identical so this can't disagree
+// with the check it's standing in for. Writes nothing and reaps nothing
+// — the authoritative check, with its state changes, stays in verify.mjs.
+const VERIFIABLE_BY_SQL = `
+  SELECT 1 FROM tasks
+  WHERE id = ? AND status = 'building' AND lease_owner = ?
+    AND (lease_expires_at IS NULL OR lease_expires_at >= datetime('now'))
+`;
+
+function taskVerifiableBy(db, taskId, owner) {
+  return db.prepare(VERIFIABLE_BY_SQL).get(taskId, owner) !== undefined;
+}
+
+// The declared-binary gate for one task: resolves the task's layer in
+// the core definition and returns { layer, missing } when that layer's
+// `requires:` names binaries this environment can't find, or null when
+// there's nothing to say (no core, unknown task/layer, nothing missing).
+//
+// Runs ahead of verifyTask so the verify command is never handed to a
+// shell that will answer `exit 127` with no context. Deliberately makes
+// no state change: the task keeps its lease and its `building` status,
+// so installing the binary and re-running `hedgehog verify` is the whole
+// fix — no unblocking step, and no failed verification recorded for
+// something that never ran.
+//
+// It only speaks for a caller who could actually verify this task. A
+// caller holding no lease, or a stale one, has a different problem, and
+// telling them to install a binary would send them off to fix something
+// that isn't in their way — so this stays quiet and lets verifyTask
+// report the real ownership/state error. Nothing is lost by deferring:
+// claimForVerify throws before any verify command runs, so falling
+// through still records no failed verification.
+async function missingBinariesForTask(db, taskId, owner) {
+  if (!taskVerifiableBy(db, taskId, owner)) return null;
+
+  const row = db.prepare('SELECT layer FROM tasks WHERE id = ?').get(taskId);
+  if (row === undefined) return null;
+
+  const corePath = await resolveCorePath();
+  if (!corePath) return null;
+
+  let core;
+  try {
+    core = await loadCore(corePath);
+  } catch {
+    // An unloadable core.yaml is `plan`'s error to report; don't turn it
+    // into a confusing failure of an unrelated verify.
+    return null;
+  }
+
+  const layer = core.layers.find((l) => l.id === row.layer);
+  if (!layer) return null;
+
+  const missing = missingBinaries(layer.requires);
+  return missing.length === 0 ? null : { layer: layer.id, missing };
+}
+
 async function verifyCommand(args) {
   await ensureDb();
 
@@ -783,9 +1045,26 @@ async function verifyCommand(args) {
     return;
   }
 
+  printDbTarget();
   const db = openDb();
   let result;
   try {
+    const blockers = await missingBinariesForTask(db, taskId, owner);
+    if (blockers) {
+      const list = blockers.missing.map((b) => bold(b)).join(', ');
+      console.error(
+        `${red(bold('Missing required binaries.'))} Task ${bold(taskId)} (layer ${bold(blockers.layer)}) was not verified.\n`,
+      );
+      console.error(`Not found on PATH: ${list}`);
+      console.error(
+        `${dim(`Declared by layer "${blockers.layer}" in core.yaml (requires:). The verify command was not run.`)}`,
+      );
+      console.error(
+        `${dim('Install them, or put them on the PATH of the shell running hedgehog — an interactive login shell may see binaries a non-interactive one does not — then re-run this command.')}\n`,
+      );
+      process.exitCode = 1;
+      return;
+    }
     result = verifyTask(db, taskId, owner);
   } catch (err) {
     console.error(`${red('Verify failed:')} ${err.message}\n`);
@@ -821,21 +1100,73 @@ async function verifyCommand(args) {
   if (result.intentComplete) {
     console.log(`  ${green('intent complete')}  ${dim('every task for this intent is done')}`);
   }
+
+  // The one comparison in the circuit. Each layer's verify_command runs
+  // the tests that layer itself wrote, so it measures internal
+  // consistency and never coverage of what was asked — a layer that
+  // builds half an intent and tests that half exhaustively is green.
+  // Closing the last layer is the moment the intent is claimed done, so
+  // that is where what was requested gets printed back to be read against
+  // what was built. It is not a machine-checkable gate; it cannot be. Its
+  // value is that the comparison happens at all, once.
+  if (result.completedIntent) {
+    const { id, goal, outcome } = result.completedIntent;
+    console.log('');
+    console.log(`${bold('INTENT CHECK')}  ${bold(id)}  ${dim('— this closed the last layer of this intent.')}`);
+    console.log(`  ${dim('GOAL')}     ${goal}`);
+    console.log(`  ${dim('OUTCOME')}  ${outcome}`);
+    console.log('');
+    console.log(dim('  Confirm the work built across this intent\'s layers covers the above.'));
+    console.log(dim('  Anything asked for and not built is a Correction Protocol case now,'));
+    console.log(dim('  not a later discovery. Nothing else in the build checks this.'));
+    console.log('');
+  }
+}
+
+// Prints the full task packet for each task in `tasks`, read back from
+// the graph after the claim landed. Claiming moves a task to `building`,
+// which takes it out of `hedgehog next`'s candidate set — so if claim
+// doesn't print the packet here, the STATUS/ALLOWED SCOPE/VERIFICATION an
+// agent is supposed to be dispatched with is no longer reachable from any
+// command. (`hedgehog show <task-id>` reprints it later.)
+function printPackets(tasks) {
+  const db = openDb();
+  try {
+    for (const task of tasks) {
+      const packet = taskPacket(db, task.id);
+      if (!packet) continue;
+      console.log();
+      console.log(formatPacket(packet, taskStatusLine(packet.task)));
+    }
+  } finally {
+    db.close();
+  }
+  console.log();
 }
 
-// `hedgehog claim --owner <owner> [--count <n>]` — atomically claims up to
-// `count` mutually non-conflicting ready tasks (claimTasks's fan-out, item
-// 13) and prints each one's packet-level summary, plus which owner now
-// holds them.
+// `hedgehog claim [<task-id>] --owner <owner> [--count <n>]` — atomically
+// claims up to `count` mutually non-conflicting ready tasks (claimTasks's
+// fan-out, item 13), or the one named task, and prints each claimed
+// task's full packet plus which owner now holds it.
 async function claimCommand(args) {
   await ensureDb();
 
+  // A leading non-flag argument names one specific task; without it this
+  // is the fan-out claim it has always been.
+  const taskId = args[0] && !args[0].startsWith('--') ? args[0] : undefined;
   const ownerIdx = args.indexOf('--owner');
   const owner = ownerIdx !== -1 ? args[ownerIdx + 1] : undefined;
   const countIdx = args.indexOf('--count');
   const count = countIdx !== -1 ? Number(args[countIdx + 1]) : 1;
   if (!owner) {
-    console.error(`${red('Usage:')} hedgehog claim --owner <owner> [--count <n>]\n`);
+    console.error(
+      `${red('Usage:')} hedgehog claim --owner <owner> [--count <n>]\n   or: hedgehog claim <task-id> --owner <owner>\n`,
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (taskId && countIdx !== -1) {
+    console.error(`${red('--count cannot be combined with a task id')} — a targeted claim takes exactly one task.\n`);
     process.exitCode = 1;
     return;
   }
@@ -846,6 +1177,13 @@ async function claimCommand(args) {
     return;
   }
 
+  printDbTarget();
+
+  if (taskId) {
+    await claimOneCommand(taskId, owner);
+    return;
+  }
+
   const db = openDb();
   let claimed;
   try {
@@ -868,6 +1206,150 @@ async function claimCommand(args) {
     if (claimed.length > 1) console.log(`  ${bold(task.id)}`);
     console.log(`  ${dim('expires')}  ${task.lease_expires_at}`);
   }
+  printPackets(claimed);
+}
+
+// The targeted half of `claim`: one named task, or a non-zero exit
+// naming which precondition refused it. Never exits 0 without having
+// claimed something — an operator breaking a starvation tie has to be
+// able to tell "claimed" from "matched nothing" by exit code alone.
+async function claimOneCommand(taskId, owner) {
+  const db = openDb();
+  let result;
+  try {
+    result = claimTask(db, taskId, { owner });
+  } finally {
+    db.close();
+  }
+
+  if (result.claimed) {
+    console.log(`${green(bold('Claimed.'))} Task ${bold(taskId)} leased to ${bold(owner)}.`);
+    console.log(`  ${dim('expires')}  ${result.task.lease_expires_at}`);
+    printPackets([result.task]);
+    return;
+  }
+
+  process.exitCode = 1;
+
+  if (result.reason === 'no_such_task') {
+    console.error(`${red('No such task:')} ${bold(taskId)}${dim(` (in ${dbAbsPath()})`)}\n`);
+    return;
+  }
+  if (result.reason === 'not_claimable') {
+    const held = result.task.lease_owner ? `, leased to ${result.task.lease_owner}` : '';
+    console.error(
+      `${red('Not claimable.')} Task ${bold(taskId)} is ${bold(result.task.status)}${held}.\n` +
+        (result.task.status === 'blocked'
+          ? `\nReturn it to the queue first: ${bold(`hedgehog retry ${taskId}`)}\n`
+          : '\n'),
+    );
+    return;
+  }
+  if (result.reason === 'incomplete_dependencies') {
+    console.error(`${red('Not claimable.')} Task ${bold(taskId)} is waiting on:\n`);
+    for (const dep of result.incomplete) {
+      console.error(`  ${red('✗')} ${bold(dep.id)}   ${dep.layer}   ${dep.status}`);
+    }
+    console.error();
+    return;
+  }
+  if (result.reason === 'conflict') {
+    console.error(`${red('Not claimable.')} Task ${bold(taskId)} conflicts with work in flight:\n`);
+    for (const { task, kind } of result.conflicting) {
+      console.error(`  ${red('✗')} ${bold(task.id)}   ${task.status}   ${dim(`(${kind})`)}`);
+    }
+    console.error(
+      `\nWait for those to finish, or ${bold('hedgehog release')} them, then claim again.\n`,
+    );
+    return;
+  }
+  console.error(`${red('Not claimed.')} A concurrent claim took ${bold(taskId)} first.\n`);
+}
+
+// `hedgehog retry <task-id>` — the transition out of `blocked`, for any
+// blocked_reason. A failed verification and a scope violation are the
+// loop's normal failure cases, but `release` only accepts `building` and
+// `verify` only accepts a task leased to the caller, so before this
+// command a blocked task had no CLI path back into the queue at all.
+async function retryCommand(args) {
+  await ensureDb();
+
+  const taskId = args[0] && !args[0].startsWith('--') ? args[0] : undefined;
+  if (!taskId) {
+    console.error(`${red('Usage:')} hedgehog retry <task-id> [--owner <owner>]\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!(await exists(DB_PATH))) {
+    console.error(`${red('No build graph found.')} Run ${bold('hedgehog db init')} first.\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  printDbTarget();
+
+  const db = openDb();
+  let result;
+  try {
+    result = retryTask(db, taskId);
+  } finally {
+    db.close();
+  }
+
+  if (!result.retried) {
+    process.exitCode = 1;
+    if (result.reason === 'no_such_task') {
+      console.error(`${red('No such task:')} ${bold(taskId)}${dim(` (in ${dbAbsPath()})`)}\n`);
+      return;
+    }
+    console.error(
+      `${red('Not retried.')} Task ${bold(taskId)} is ${bold(result.task.status)}, not ${bold('blocked')}.\n`,
+    );
+    return;
+  }
+
+  const reason = BLOCKED_REASON_LABELS[result.from] ?? result.from;
+  console.log(
+    `${green(bold('Retried.'))} Task ${bold(taskId)} is back to ${bold('planned')} ${dim(`(was blocked: ${reason})`)}`,
+  );
+  console.log(`  ${dim('claim it with')}  hedgehog claim ${taskId} --owner <owner>`);
+}
+
+// `hedgehog show <task-id>` — the same packet `next` prints, for a task
+// named by id whatever its status. Read-only: claims nothing, changes
+// nothing.
+async function showCommand(args) {
+  await ensureDb();
+
+  const taskId = args[0];
+  if (!taskId) {
+    console.error(`${red('Usage:')} hedgehog show <task-id>\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!(await exists(DB_PATH))) {
+    console.error(`${red('No build graph found.')} Run ${bold('hedgehog db init')} first.\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const db = openDb();
+  let packet;
+  try {
+    packet = taskPacket(db, taskId);
+  } finally {
+    db.close();
+  }
+
+  if (!packet) {
+    console.error(`${red('No such task:')} ${bold(taskId)}${dim(` (in ${dbAbsPath()})`)}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(formatPacket(packet, taskStatusLine(packet.task)));
 }
 
 // `hedgehog release <task-id> --owner <owner>` — hands a claimed task
@@ -891,6 +1373,8 @@ async function releaseCommand(args) {
     return;
   }
 
+  printDbTarget();
+
   const db = openDb();
   let result;
   try {
@@ -900,8 +1384,19 @@ async function releaseCommand(args) {
   }
 
   if (!result.released) {
-    console.error(`${red('Not released.')} Task ${bold(taskId)} is not leased to ${bold(owner)} as ${bold('building')}.\n`);
     process.exitCode = 1;
+    if (result.reason === 'no_such_task') {
+      console.error(`${red('No such task:')} ${bold(taskId)}${dim(` (in ${dbAbsPath()})`)}\n`);
+      return;
+    }
+    console.error(
+      `${red('Not released.')} Task ${bold(taskId)} is ${bold(result.task.status)}${
+        result.task.lease_owner ? `, leased to ${bold(result.task.lease_owner)}` : ''
+      } — not ${bold('building')} under ${bold(owner)}.\n` +
+        (result.task.status === 'blocked'
+          ? `\nReturn a blocked task to the queue with: ${bold(`hedgehog retry ${taskId}`)}\n`
+          : ''),
+    );
     return;
   }
 
@@ -930,6 +1425,8 @@ async function renewCommand(args) {
     return;
   }
 
+  printDbTarget();
+
   const db = openDb();
   let result;
   try {
@@ -939,14 +1436,50 @@ async function renewCommand(args) {
   }
 
   if (!result.renewed) {
-    console.error(`${red('Not renewed.')} Task ${bold(taskId)} is not leased to ${bold(owner)}.\n`);
     process.exitCode = 1;
+    if (result.reason === 'no_such_task') {
+      console.error(`${red('No such task:')} ${bold(taskId)}${dim(` (in ${dbAbsPath()})`)}\n`);
+      return;
+    }
+    console.error(
+      `${red('Not renewed.')} Task ${bold(taskId)} is ${bold(result.task.status)}${
+        result.task.lease_owner ? `, leased to ${bold(result.task.lease_owner)}` : ''
+      } — not leased to ${bold(owner)}.\n`,
+    );
     return;
   }
 
   console.log(`${green(bold('Renewed.'))} Task ${bold(taskId)}'s lease extended by ${minutes} minute(s).`);
 }
 
+// Heuristic problems with the project's own core definition, rendered for
+// `hedgehog status`. Surfaced here because status is the command every
+// session starts with, and a core-definition smell is a build-wide fact
+// rather than one task's: a layer whose verify command doesn't reach the
+// verify_radius it declared lets a task break a neighbour and still
+// commit green, and nothing later in the loop will say so. Warnings only
+// — the certainties throw from validateCore, on load.
+async function coreWarningLines() {
+  const corePath = await resolveCorePath();
+  if (!corePath) return [];
+  const label = relative(DEST_ROOT, corePath) || corePath;
+  let core;
+  try {
+    core = await loadCore(corePath);
+  } catch (err) {
+    // Every other command that loads the core fails outright on this; say
+    // so here rather than letting `hedgehog status` die with a stack.
+    return ['', `${red('CORE')}  ${bold(label)} is invalid: ${err.message}`];
+  }
+  const warnings = lintCore(core);
+  if (warnings.length === 0) return [];
+  return [
+    '',
+    `${yellow('CORE WARNINGS')}  ${dim(label)}`,
+    ...warnings.map((warning) => `  ${yellow('!')} ${warning}`),
+  ];
+}
+
 async function statusCommand() {
   await ensureDb();
 
@@ -956,15 +1489,57 @@ async function statusCommand() {
     return;
   }
 
+  // Drift needs the core definition to compare against. A project
+  // without one yet (deferred install, pre-bootstrap) simply gets the
+  // status it always got; an unparseable one is reported but never
+  // allowed to take `status` down — it's the command every session
+  // starts with.
+  let core = null;
+  const corePath = await resolveCorePath();
+  if (corePath) {
+    try {
+      core = await loadCore(corePath);
+    } catch (err) {
+      console.error(
+        `${yellow('Core definition unreadable:')} ${corePath} — ${err.message}\n${dim('Drift against core.yaml cannot be checked.')}\n`,
+      );
+    }
+  }
+
+  const overrides = core ? await loadOverrides() : new Map();
   const db = openDb();
   let result;
   try {
-    result = graphStatus(db);
+    result = graphStatus(db, { core, overrides });
   } finally {
     db.close();
   }
 
+  // Declared-binary check (core.yaml's `requires:`) rides on `status`
+  // because status is what a fresh session runs first — that's the point
+  // at which "this core needs terraform" is a setup fact rather than an
+  // opaque exit 127 twenty minutes into the build. Reuses the `core`
+  // already loaded above for drift — a project with no core definition
+  // yet, or one that failed to parse (reported above already), has
+  // nothing to check and reports nothing here either.
+  if (core) result.missingRequirements = coreMissingRequirements(core);
+
   console.log(formatStatus(result));
+
+  // Whether the commit gate is actually enforcing. This is reported at
+  // the start of every session because a gate that isn't running looks
+  // exactly like one that is — `.git/hooks` exists, `lefthook.yml` is
+  // committed, and a passing commit prints nothing to tell the two
+  // apart. Nothing else in the discipline would notice.
+  const gate = await commitGateStatus(DEST_ROOT);
+  const gateText = formatCommitGate(gate);
+  if (gateText) {
+    console.log('');
+    console.log(gate.state === 'active' ? dim(gateText) : yellow(gateText));
+  }
+
+  const warningLines = await coreWarningLines();
+  if (warningLines.length > 0) console.log(warningLines.join('\n'));
 }
 
 // `hedgehog ready` — read-only preview of what a `hedgehog claim` call
@@ -1024,6 +1599,62 @@ async function quiesceCommand() {
   process.exitCode = 1;
 }
 
+// `hedgehog boundary [--quiet] [--handoff]` — is this a good moment to
+// clear the conversation, and where would a fresh one pick up?
+//
+// `quiesce` answers one third of that question (nothing in flight).
+// This answers all of it: nothing in flight, a clean working tree, and a
+// last closed task that completed its intent — see boundary.mjs for how
+// each is derived. Exits 0 only when all three hold, so a shell hook can
+// consume it without reading anything.
+//
+// Output is split by consumer, not by importance:
+//   stdout — the payload worth capturing: the NEXT/WHY positioning block,
+//            or with --handoff the full block a fresh session starts from.
+//   stderr — the verdict and the per-condition results, so a non-zero
+//            exit always names which condition failed without that
+//            commentary landing in a captured payload.
+//   --quiet drops the commentary and the default payload, leaving the
+//            exit code (and, if asked for explicitly, --handoff's block).
+//
+// Exit codes: 0 boundary reached; 1 not a boundary; 2 the question can't
+// be answered here (no build graph, no git repository, or a last closed
+// task that isn't identifiable).
+async function boundaryCommand(args) {
+  const quiet = args.includes('--quiet');
+  const handoff = args.includes('--handoff');
+
+  await ensureDb({ log: (msg) => console.error(msg) });
+
+  if (!(await exists(DB_PATH))) {
+    if (!quiet) {
+      console.error(`${red('No build graph found.')} Run ${bold('hedgehog db init')} first.\n`);
+    }
+    process.exitCode = 2;
+    return;
+  }
+
+  const db = openDb();
+  let state;
+  try {
+    state = boundaryState(db);
+  } finally {
+    db.close();
+  }
+
+  if (!quiet) console.error(formatBoundary(state));
+  if (handoff) console.log(formatHandoff(state));
+  else if (!quiet && state.reached) console.log(formatPosition(state));
+
+  if (state.undecidable) {
+    process.exitCode = 2;
+    return;
+  }
+  if (!state.reached) {
+    process.exitCode = 1;
+  }
+}
+
 const GRAPH_PIDFILE_PATH = '.hedgehog/graph-server.json';
 const GRAPH_SERVER_MODULE = join(PKG_ROOT, 'src/db/graph-server.mjs');
 const GRAPH_TEMPLATE_PATH = join(PKG_ROOT, 'src/templates/graph.html');
@@ -1040,6 +1671,28 @@ function openInBrowser(url) {
   spawn(cmd, args, { detached: true, stdio: 'ignore', shell: platform === 'win32' }).unref();
 }
 
+// True when there is plausibly a local display for a browser to open on.
+// macOS and Windows always have one; on Linux/BSD a session with neither
+// DISPLAY nor WAYLAND_DISPLAY set is headless (an SSH session, a
+// container, an agent's non-interactive shell), and `xdg-open` there
+// either fails silently or blocks on a text browser. Printing the URL is
+// the useful behaviour in that case — a person on the other end of a
+// port-forward can still open it.
+function hasDisplay() {
+  if (process.platform === 'darwin' || process.platform === 'win32') return true;
+  return Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+}
+
+// Hands `url` to the OS browser when that can work, and otherwise prints
+// it. One place, so `plan --open` and `graph` behave identically.
+function presentGraphUrl(url, { noOpen = false } = {}) {
+  if (noOpen || !hasDisplay()) {
+    console.log(`\nOpen ${bold(url)} in a browser to view it.`);
+    return;
+  }
+  openInBrowser(url);
+}
+
 // True if `pid` names a live process. Sending signal 0 performs the
 // existence/permission check without actually signalling anything — the
 // standard POSIX idiom `kill -0` follows, and Node exposes it the same
@@ -1054,12 +1707,14 @@ function isProcessAlive(pid) {
 }
 
 // Returns the port of a running graph server for this project, starting
-// one if none is live. Both `plan` (auto-open after scoping) and `graph`
-// (explicit request) call this rather than each managing their own
-// server, so a project only ever has one live server no matter which
-// command a person or agent happens to run — re-running `plan` after
-// `graph` is already open reuses the same tab's server instead of
-// spawning a second one bound to a different port.
+// one if none is live. Both `plan --open` and `graph` call this rather
+// than each managing their own server, so a project only ever has one
+// live server no matter which command a person or agent happens to run —
+// re-running `plan --open` after `graph` is already open reuses the same
+// tab's server instead of spawning a second one bound to a different
+// port. Nothing else calls it: a command that isn't asked to open the
+// graph starts no server, so it can leave neither a pidfile nor a
+// detached process behind.
 async function startOrReuseGraphServer() {
   const pidfilePath = join(DEST_ROOT, GRAPH_PIDFILE_PATH);
 
@@ -1143,12 +1798,9 @@ async function graphCommand(args) {
   // --no-open covers headless/SSH sessions where there's no local
   // browser to hand a URL to — the server itself is still started (or
   // reused) either way, since a remote person may open the URL manually
-  // via port-forwarding.
-  if (args.includes('--no-open')) {
-    console.log(`\nOpen ${bold(url)} in a browser to view it.`);
-  } else {
-    openInBrowser(url);
-  }
+  // via port-forwarding. presentGraphUrl reaches the same outcome
+  // unasked when the session has no display at all.
+  presentGraphUrl(url, { noOpen: args.includes('--no-open') });
 }
 
 async function whyCommand(args) {
@@ -1211,6 +1863,8 @@ async function frictionCommand(args) {
       return;
     }
 
+    printDbTarget();
+
     const db = openDb();
     let entry;
     try {
@@ -1253,6 +1907,190 @@ async function frictionCommand(args) {
   process.exitCode = 1;
 }
 
+// `hedgehog override add <task-id> --scope <glob> [--scope <glob>...]
+// --reason "<why>"` / `hedgehog override list` — per-task scope
+// exceptions (see src/db/overrides.mjs). Writes
+// .hedgehog/overrides/<task-id>.json; the next `hedgehog plan` (for a
+// not-yet-compiled task) or `hedgehog plan --recompile` (for one already
+// compiled) is what actually widens the task's scope_globs — this command
+// only records the committed intent to do so.
+async function overrideCommand(args) {
+  await ensureDb();
+
+  const sub = args[0];
+
+  if (sub === 'add') {
+    const taskId = args[1];
+    const rest = args.slice(2);
+    const scopeAdd = [];
+    let reason;
+    for (let i = 0; i < rest.length; i++) {
+      const flag = rest[i];
+      const value = rest[i + 1];
+      if (flag === '--scope') {
+        if (!value) {
+          console.error(`${red('--scope requires a glob')}\n`);
+          process.exitCode = 1;
+          return;
+        }
+        scopeAdd.push(value);
+        i++;
+      } else if (flag === '--reason') {
+        if (!value) {
+          console.error(`${red('--reason requires text')}\n`);
+          process.exitCode = 1;
+          return;
+        }
+        reason = value;
+        i++;
+      } else {
+        console.error(`${red('Unknown override flag:')} ${flag}\n`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+
+    if (!taskId || scopeAdd.length === 0 || !reason) {
+      console.error(
+        `${red('Usage:')} hedgehog override add <task-id> --scope <glob> [--scope <glob>...] --reason "<why>"\n`,
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    let record;
+    try {
+      record = await addOverride({ task: taskId, scope_add: scopeAdd, reason });
+    } catch (err) {
+      console.error(`${red('Failed to add override:')} ${err.message}\n`);
+      process.exitCode = 1;
+      return;
+    }
+
+    console.log(`  ${green('added')}  ${OVERRIDES_DIR}/${record.task.toLowerCase()}.json`);
+    for (const glob of record.scope_add) console.log(`    + ${glob}`);
+    console.log(
+      `  ${dim(`run \`hedgehog plan --recompile\` to widen ${record.task} now, if it's already compiled`)}\n`,
+    );
+    return;
+  }
+
+  if (sub === 'list') {
+    const overrides = await loadOverrides();
+    if (overrides.size === 0) {
+      console.log(`${dim('No overrides recorded.')}\n`);
+      return;
+    }
+
+    // Best-effort: an override file can legitimately exist before `db
+    // init`/`plan` has ever run (e.g. written ahead of the intent it
+    // targets), so a missing DB just skips the orphan check rather than
+    // failing the whole listing.
+    let orphaned = [];
+    if (await exists(DB_PATH)) {
+      const db = openDb({ readOnly: true });
+      try {
+        orphaned = orphanedOverrides(db, overrides);
+      } finally {
+        db.close();
+      }
+    }
+
+    for (const [taskId, records] of overrides) {
+      for (const record of records) {
+        console.log(`${bold(taskId)}`);
+        console.log(`  ${dim(record.reason)}`);
+        for (const glob of record.scope_add) console.log(`  + ${glob}`);
+        console.log('');
+      }
+    }
+
+    if (orphaned.length > 0) {
+      console.log(
+        `${yellow(bold('Orphaned:'))} ${orphaned.join(', ')} — no task with this id exists in the\n` +
+          `build graph yet. A typo'd id, a renamed layer/module, or an intent that hasn't\n` +
+          `compiled yet all look like this; it silently widens nothing until the id matches.\n`,
+      );
+    }
+    return;
+  }
+
+  console.error(
+    `${red('Unknown override subcommand:')} ${sub ?? '(none)'}\n\n` +
+      `Usage: hedgehog override add <task-id> --scope <glob> [--scope <glob>...] --reason "<why>"\n` +
+      `   or: hedgehog override list\n`,
+  );
+  process.exitCode = 1;
+}
+
+// `hedgehog debt add <task-id> "<note>"` / `hedgehog debt list [<task-id>]`
+// — declared debt between tasks. A note recorded against a task is
+// rendered into the INHERITED DEBT section of the packet of every task
+// that depends on it (see src/db/debt.mjs and src/db/next.mjs).
+async function debtCommand(args) {
+  await ensureDb();
+
+  const sub = args[0];
+
+  if (!(await exists(DB_PATH))) {
+    console.error(`${red('No build graph found.')} Run ${bold('hedgehog db init')} first.\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (sub === 'add') {
+    const taskId = args[1];
+    const note = args.slice(2).join(' ');
+    if (!taskId || !note) {
+      console.error(`${red('Usage:')} hedgehog debt add <task-id> "<note>"\n`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const db = openDb();
+    let entry;
+    try {
+      entry = addDebt(db, { taskId, note });
+    } catch (err) {
+      console.error(`${red('Failed to declare debt:')} ${err.message}\n`);
+      process.exitCode = 1;
+      return;
+    } finally {
+      db.close();
+    }
+
+    console.log(`  ${green('declared')}  #${entry.id} ${bold(entry.taskId)}`);
+    console.log(`  ${dim('reaches the packet of every task depending on it')}`);
+    return;
+  }
+
+  if (sub === 'list') {
+    const taskId = args[1];
+    const db = openDb();
+    let entries;
+    try {
+      entries = listDebt(db, taskId);
+    } finally {
+      db.close();
+    }
+
+    if (entries.length === 0) {
+      console.log(`${dim('No debt declared.')}\n`);
+      return;
+    }
+    for (const entry of entries) {
+      console.log(`#${entry.id}  ${dim(entry.loggedAt)}  ${bold(entry.taskId)}`);
+      console.log(`  ${entry.note}\n`);
+    }
+    return;
+  }
+
+  console.error(
+    `${red('Unknown debt subcommand:')} ${sub ?? '(none)'}\n\nUsage: hedgehog debt add <task-id> "<note>"\n   or: hedgehog debt list [<task-id>]\n`,
+  );
+  process.exitCode = 1;
+}
+
 async function main() {
   const args = process.argv.slice(2);
   if (args.includes('--help') || args.includes('-h') || args.length === 0) {
@@ -1322,7 +2160,7 @@ async function main() {
   }
 
   if (cmd === 'plan') {
-    await planCommand();
+    await planCommand(args.slice(1));
     return;
   }
 
@@ -1346,6 +2184,16 @@ async function main() {
     return;
   }
 
+  if (cmd === 'show') {
+    await showCommand(args.slice(1));
+    return;
+  }
+
+  if (cmd === 'retry') {
+    await retryCommand(args.slice(1));
+    return;
+  }
+
   if (cmd === 'release') {
     await releaseCommand(args.slice(1));
     return;
@@ -1371,6 +2219,11 @@ async function main() {
     return;
   }
 
+  if (cmd === 'boundary') {
+    await boundaryCommand(args.slice(1));
+    return;
+  }
+
   if (cmd === 'graph') {
     await graphCommand(args.slice(1));
     return;
@@ -1386,6 +2239,16 @@ async function main() {
     return;
   }
 
+  if (cmd === 'debt') {
+    await debtCommand(args.slice(1));
+    return;
+  }
+
+  if (cmd === 'override') {
+    await overrideCommand(args.slice(1));
+    return;
+  }
+
   console.error(`${red('Unknown command:')} ${cmd}\n`);
   await help();
   process.exitCode = 1;