@azure-id/orc 2.1.0 → 2.2.0

package/bin/cli.js

@@ -244,6 +244,7 @@ function listSkillNames() {
 function nodeCmd(absPath) {
   return `node "${absPath.replace(/\\/g, "/")}"`;
 }
+const TYPED_GATE_MATCHER = "orc|orc-diy"; // the skills the effort guard gates, typed (F13)
 
 // Install the ORC guard scripts and MERGE their wiring into settings.json.
 // Non-destructive: never clobbers an existing statusLine, never duplicates the
@@ -292,6 +293,7 @@ function installGuards(claudeDir) {
       );
       console.log("     Add these manually so ORC is guarded:");
       console.log(`       PreToolUse (matcher \"Skill\"): ${guardCmd}`);
+      console.log(`       UserPromptExpansion (matcher "${TYPED_GATE_MATCHER}"): ${guardCmd}`);
       console.log(`       statusLine: ${statusCmd}`);
       return;
     }
@@ -319,6 +321,28 @@ function installGuards(claudeDir) {
     console.log("  upd   settings.json → PreToolUse effort guard path");
   }
 
+  // 1b) The typed-command gate (v2.1.2, F13) — the SAME file on a second
+  //     event. A typed /orc or /orc-diy loads the skill with no Skill tool
+  //     call, so the entry above never sees it. The matcher is an exact list,
+  //     so the hook starts for these two commands and for nothing else.
+  settings.hooks.UserPromptExpansion = settings.hooks.UserPromptExpansion || [];
+  let typedGated = false;
+  for (const entry of settings.hooks.UserPromptExpansion) {
+    for (const h of entry.hooks || []) {
+      if (typeof h.command === "string" && h.command.includes("orc-effort-guard")) {
+        h.command = guardCmd; // keep the path current
+        entry.matcher = TYPED_GATE_MATCHER; // repair a hand-edited matcher
+        typedGated = true;
+      }
+    }
+  }
+  if (!typedGated) {
+    settings.hooks.UserPromptExpansion.push({ matcher: TYPED_GATE_MATCHER, hooks: [{ type: "command", command: guardCmd }] });
+    console.log("  add   settings.json → UserPromptExpansion effort gate (typed /orc, /orc-diy)");
+  } else {
+    console.log("  upd   settings.json → UserPromptExpansion effort gate path");
+  }
+
   // 2) statusLine model warning — set ONLY if the user has none (never clobber).
   if (!settings.statusLine) {
     settings.statusLine = { type: "command", command: statusCmd };
@@ -451,6 +475,9 @@ function installGuards(claudeDir) {
   wireGraph("PreToolUse", "Grep|Glob");
   wireGraph("PreToolUse", "Bash|Read");
   wireGraph("PostToolUse", "Read");
+  // R13 (v2.2.0): an executor returning to the main session gets the
+  // touchpoint-4 `changes` card. A new entry of its own; no other hook is touched.
+  wireGraph("PostToolUse", "Task|Agent");
 
   // 7) The session hook (v2.0.0 Q8/Q9) — TWO entries, one file. `Stop` rings
   // the terminal bell when a turn of an ORC run ends, and only under
@@ -1131,6 +1158,8 @@ const KNOWN_MODELS = [
   // Kept so a config written before v2.1.0 still validates.
   "claude-sonnet-5",
   "claude-sonnet-4-6",
+  "claude-haiku-5-5",
+  // Kept so a config written before v2.2.0 still validates.
   "claude-haiku-4-5",
   "claude-fable-5",
 ];
@@ -1177,7 +1206,7 @@ const vModel = tag((raw) => {
 // would go stale the next time a band moves. `orc-` is required so a typo lands
 // as a refusal rather than as a dispatch to a name nothing answers to.
 const vFallbackAgent = tag((raw) => {
-  const v = String(raw || "").trim();
+  const v = resolveLegacyAgents(String(raw || "").trim());
   if (v === "band" || v === "ask") return { value: v };
   if (!/^orc-[a-z0-9-]+$/.test(v))
     return { err: 'must be "band", "ask", or an ORC agent name (e.g. orc-executor-opus-5-med)' };
@@ -1186,7 +1215,7 @@ const vFallbackAgent = tag((raw) => {
     warn:
       "pinned to one agent — this overrides the score table AND a slot's own pinned agent for every fallback, whatever the task. `band` is what keeps a fallback a change of WHO and not a change of tier.",
   };
-}, { kind: "text", choices: ["band", "ask", "orc-executor-opus-5-med", "orc-executor-opus-5-low", "orc-executor-sonnet-4-6-high"] });
+}, { kind: "text", choices: ["band", "ask", "orc-executor-opus-5-med", "orc-executor-opus-5-low", "orc-executor-sonnet-5-high"] });
 // v2.0.0 W2 (DE-16) — `auto` is refused BY NAME. It is the one value a reader
 // of the research expects, and ORC does not have it: no habit is ever applied
 // without a yes, so a generic "must be one of" would read as a missing feature.
@@ -1486,11 +1515,11 @@ const CONFIG_META = [
   // reason: no lane reads this key. Every lane calls `orc graph … --if-enabled`
   // and the CLI resolves it, which is how /orc-quick takes part while its Q0
   // still reads `log_dir` and nothing else.
-  { key: "code_graph", def: "off", tier: "common", answers: [{ family: "graph", prio: "P2", mode: "replace" }], lanes: [], validate: vEnum("off", "on"), options: ["off", "on"], desc: "Whether code-changing lanes (orc, ultra, diy, mini, fast, quick) build and read a local code graph under .claude/orc/graph/. The structure is extracted by the CLI from git blob SHAs and costs no model tokens; a teammate's change is found and healed at the next preflight. Off means no lane reads or writes it. See `orc graph status`." },
+  { key: "code_graph", def: "off", tier: "common", answers: [{ family: "graph", prio: "P2", mode: "replace" }], lanes: [], validate: vEnum("off", "semi", "on"), options: ["off", "semi", "on"], desc: "Whether code-changing lanes (orc, ultra, diy, mini, fast, quick) build and read a local code graph under .claude/orc/graph/. The structure is extracted by the CLI from git blob SHAs and costs no model tokens; a teammate's change is found and healed at the next preflight. Off means no lane reads or writes it. Semi keeps it built and current (preflight heal and the SubagentStop hook) but no lane reads it and nothing goes into any context. See `orc graph status`." },
   // v1.8.0 W7 — the graph's operating keys. All `lanes: []` for the same reason
   // as `code_graph`: the CLI resolves them behind `--if-enabled`. All gated by
   // `code_graph`, so turning the graph off makes every one of them INERT, out loud.
-  { key: "code_graph_notes", def: "off", tier: "common", answers: [{ family: "graph", prio: "P2", mode: "replace" }], gated_by: "code_graph", lanes: [], validate: vEnum("off", "wave", "end"), options: ["off", "wave", "end"], desc: "Whether a code lane pays for one-sentence notes on the functions it changed (orc-graph-noter-sonnet-4-6-med). `wave` = one batch per wave (per code-writing request in /orc-quick); `end` = one batch at the end of the run. The structure layer is free either way — notes are the only part of the graph that costs tokens. Inert while code_graph is off." },
+  { key: "code_graph_notes", def: "off", tier: "common", answers: [{ family: "graph", prio: "P2", mode: "replace" }], gated_by: "code_graph", lanes: [], validate: vEnum("off", "wave", "end"), options: ["off", "wave", "end"], desc: "Whether a code lane pays for one-sentence notes on the functions it changed (orc-graph-noter-haiku-5-high). `wave` = one batch per wave (per code-writing request in /orc-quick); `end` = one batch at the end of the run. The structure layer is free either way — notes are the only part of the graph that costs tokens. Inert while code_graph is off." },
   { key: "code_graph_notes_min", def: 5, tier: "advanced", answers: [{ family: "graph", prio: "P2", mode: "replace" }], gated_by: "code_graph", lanes: [], validate: vInt(1), options: [3, 5, 10], desc: "Fewest changed functions worth a notes dispatch. Below it nothing is dispatched and the functions wait for a later batch: a subagent's fixed start-up cost (~5.7K tokens) makes a one-function batch the most expensive note there is." },
   { key: "code_graph_notes_cap", def: 40, tier: "advanced", answers: [{ family: "graph", prio: "P2", mode: "replace" }], gated_by: "code_graph", lanes: [], validate: vInt(1), options: [20, 40, 80], desc: "Most functions one notes dispatch covers. The rest wait for the next batch." },
   { key: "code_graph_card_budget", def: 1200, tier: "advanced", answers: [{ family: "graph", prio: "P2", mode: "replace" }], gated_by: "code_graph", lanes: [], validate: vRange(300, 4000), options: [600, 1200, 2400], desc: "Token budget for one `orc graph ctx` card. A card never exceeds it and always says what it hid — and every card is sent again on each later turn of the agent that received it." },
@@ -1539,7 +1568,7 @@ const CONFIG_META = [
   // is a fake fix), a per-profile stall budget (the number describes ORC's
   // patience, not a provider), and a key to disable the stall report.
   { key: "extra_stall_s", def: 180, tier: "common", answers: [{ family: "extra", prio: "P2", mode: "replace" }], gated_by: "extra_enabled", lanes: [], validate: vInt(0), options: [0, 60, 120, 180, 300, 600], desc: "Seconds a foreign worker may produce NOTHING before the dispatch is stopped as `stalled`. The clock is reset by observable progress — new bytes on the worker's stream, new bytes on stderr, or a declared file that changed on disk — so it never fires on a worker that is merely slow. This is what a wall clock cannot see: `extra_timeout_s` measures the whole dispatch, and an opencode that stops mid-task and waits for someone to type `continue` burns all 900 seconds looking like a timeout. A `stalled` dispatch is RETRYABLE, so `extra_resume` continues it from what is already on disk rather than starting over. 0 turns it off and the wall clock is the only stop again. Clamped below the wall clock, because a budget that can never fire is worse than none. Engine `cli` only — engine `api` already has a per-request inactivity timeout on its own socket." },
-  { key: "extra_fallback_agent", def: "band", tier: "common", answers: [{ family: "extra", prio: "P2", mode: "replace" }], gated_by: "extra_enabled", lanes: ["orc", "orc-diy", "orc-fast", "orc-mini", "orc-quick", "orc-wiki"], validate: vFallbackAgent, options: ["band", "ask", "orc-executor-opus-5-med", "orc-executor-opus-5-low", "orc-executor-sonnet-4-6-high"], desc: "WHICH Claude agent picks up a task the foreign worker could not finish. `band` is the pre-v0.56.1 behaviour and stays the default: the exact agent the score table or the slot would have used, so a fallback changes WHO runs it and nothing else. `ask` STOPS and puts the choice to you with the failure and the position already on the table — right when a stall has just cost you fifteen minutes and you would rather pick than accept a default. Any installed agent name is accepted verbatim, for the case where you already know a stalled slice wants more (or less) than its band. It never changes the score, never widens `declared_files` and never moves `acceptance[]` — a fallback is not a re-plan." },
+  { key: "extra_fallback_agent", def: "band", tier: "common", answers: [{ family: "extra", prio: "P2", mode: "replace" }], gated_by: "extra_enabled", lanes: ["orc", "orc-diy", "orc-fast", "orc-mini", "orc-quick", "orc-wiki"], validate: vFallbackAgent, options: ["band", "ask", "orc-executor-opus-5-med", "orc-executor-opus-5-low", "orc-executor-sonnet-5-high"], desc: "WHICH Claude agent picks up a task the foreign worker could not finish. `band` is the pre-v0.56.1 behaviour and stays the default: the exact agent the score table or the slot would have used, so a fallback changes WHO runs it and nothing else. `ask` STOPS and puts the choice to you with the failure and the position already on the table — right when a stall has just cost you fifteen minutes and you would rather pick than accept a default. Any installed agent name is accepted verbatim, for the case where you already know a stalled slice wants more (or less) than its band. It never changes the score, never widens `declared_files` and never moves `acceptance[]` — a fallback is not a re-plan." },
   { key: "extra_resume_max", def: 2, tier: "advanced", answers: [{ family: "extra", prio: "P2", mode: "replace" }], gated_by: "extra_enabled", lanes: [], validate: vInt(0), desc: "Resume attempts per task before the fallback procedure takes over. Bounded like `tdd_loop_max`: hitting the cap STOPS with an honest report naming the Claude agent, never a silent third loop. A resume never widens `declared_files`, never moves `acceptance[]` and never moves the score — it is a continuation, not a discount." },
   // --- v1.0.0 W5 — the stall DEMOTION. THIRTEEN keys became FIFTEEN, and both
   // additions are numbers with a documented off value rather than a switch.
@@ -1642,6 +1671,36 @@ const LEGACY_KEYS = {
   opus5_executor_only: "opus5_only", // v0.36.0 — widened from executors to every role
 };
 
+// v2.2.0 — the agent RENAMES. An agent's model change is always a rename, so a
+// config or flow written before 2.2.0 can still name an agent that no longer
+// ships (`rubric_bands_override`, `orc diy` `fixed_executor`,
+// `extra_fallback_agent`). Every place that READS an agent name from a user
+// file resolves it through this map: the old name becomes the new agent, with
+// ONE notice line on stderr, never a crash.
+const LEGACY_AGENTS = {
+  "orc-executor-haiku-4-5": "orc-executor-haiku-5-high",
+  "orc-executor-sonnet-4-6-med": "orc-executor-haiku-5-high",
+  "orc-trace-writer-haiku-4-5": "orc-trace-writer-haiku-5-high",
+  "orc-graph-noter-sonnet-4-6-med": "orc-graph-noter-haiku-5-high",
+};
+const LEGACY_AGENT_RE = new RegExp(`(?<![\\w-])(${Object.keys(LEGACY_AGENTS).join("|")})(?![\\w-])`, "g");
+const legacyAgentNoticed = new Set();
+function legacyAgentNotice(old) {
+  if (legacyAgentNoticed.has(old)) return;
+  legacyAgentNoticed.add(old);
+  process.stderr.write(`agent ${old} is now ${LEGACY_AGENTS[old]} (2.2.0)\n`);
+}
+// One name, or a text that holds names (a hand-written block such as
+// rubric_bands_override). Anything that is not a string comes back unchanged.
+function resolveLegacyAgents(v) {
+  if (typeof v !== "string" || !v) return v;
+  return v.replace(LEGACY_AGENT_RE, (old) => {
+    legacyAgentNotice(old);
+    return LEGACY_AGENTS[old];
+  });
+}
+const LEGACY_AGENT_KEYS = new Set(["rubric_bands_override", "extra_fallback_agent", "fixed_executor"]);
+
 // A key ORC used to have and REMOVED. Distinct from LEGACY_KEYS, which is a
 // RENAME and resolves to a live key: a retired key resolves to nothing, so
 // there is no value to carry forward and no new name to point at.
@@ -1806,7 +1865,7 @@ function readOverride(claudeDir) {
   for (const e of doc.entries) {
     if (!e.key) continue;
     if (e.key !== e.wrote && Object.prototype.hasOwnProperty.call(map, e.key)) continue;
-    map[e.key] = e.value;
+    map[e.key] = LEGACY_AGENT_KEYS.has(e.key) ? resolveLegacyAgents(e.value) : e.value;
   }
   return { path: doc.path, map };
 }
@@ -2586,7 +2645,7 @@ function extraShadowNotice(claudeDir) {
 // a golden test asserts every agent named here exists in templates/agents/).
 const OPUS5_ONLY_ROLES = [
   ["mini executor", "orc-executor-sonnet-5-high", "orc-executor-opus-5-low"],
-  ["fast executor", "orc-executor-sonnet-4-6-high", "orc-executor-opus-5-low"],
+  ["fast executor", "orc-executor-sonnet-5-med", "orc-executor-opus-5-low"],
   ["mini analyze", "orc-analyze-mini-sonnet-5-high", "orc-analyze-mini-opus-5-med"],
   ["mini plan", "orc-planner-mini-sonnet-5-high", "orc-planner-mini-opus-5-med"],
   ["scout", "orc-scout-sonnet-4-6-high", "orc-scout-opus-5-low"],
@@ -2624,7 +2683,7 @@ function opus5Notice(on, claudeDir) {
       "\n  Fixed roles now dispatched instead of their defaults:\n\n" + roleRows + "\n" +
       "\n  Already Opus 5.5, unchanged: analyst · planner · reviewer · verifier · test-author\n" +
       "  · combiner · learn-writer · advisor · judge.\n" +
-      "  NEVER forced: orc-trace-writer-haiku-4-5 (it transcribes a packet, no reasoning)\n" +
+      "  NEVER forced: orc-trace-writer-haiku-5-high (it transcribes a packet, no reasoning)\n" +
       "  and orc-diy (its table is compile-owned — re-run `orc diy compile` to change it).\n" +
       "\n  " + ui.mark.warn("Tier requirement — read this one:") + "\n" +
       "  Today only the [90,100] executor band needs an Opus 5.5 main session. With this ON,\n" +
@@ -3367,13 +3426,17 @@ function laneAnnounce(lane, map, claudeDir, families) {
   // sat in the spine, and the spine was skipped. This line comes from the
   // resolver every lane already obeys and prints VERBATIM at preflight, so the
   // three steps are in front of the lane whatever the spine said.
-  const graphOn = String(Object.prototype.hasOwnProperty.call(map, "code_graph") ? map.code_graph : metaFor("code_graph").def) === "on";
+  const graphModeL = String(Object.prototype.hasOwnProperty.call(map, "code_graph") ? map.code_graph : metaFor("code_graph").def).toLowerCase();
+  const graphOn = graphModeL === "on";
+  // v2.2.0 semi: the graph is kept current, never read — ONE line, no steps.
+  if (graphModeL === "semi" && LANE_CALLS["graph-status"].lanes.includes(lane)) out.push("graph: semi — kept current, not read");
+  // v2.2.0: the four touchpoints, one line each (`_shared/code-graph.md` §0).
   if (graphOn && LANE_CALLS["graph-status"].lanes.includes(lane))
     out.push(
-      "graph: on — use the code-graph cache: (1) now: `orc graph status --if-enabled --heal --json --brief` (builds or updates it); " +
-        "(2) every code-writing slice: `orc graph ctx <declared files> --if-enabled --json --brief` cards; " +
-        "(3) after every code change: `orc graph update --if-enabled --json --brief` (keeps it for the next run). " +
-        "Copy each `line` and `trace` verbatim; `--brief` drops the rows you never print"
+      "graph: on (1/4) consult — print probes[\"graph-status\"].line; run `orc graph status --if-enabled --heal --json --brief` only when heal_needed; exit 3 → no other graph call",
+      "graph: on (2/4) orient — once, before you choose files: the request names ONE symbol → `orc graph ctx <symbol> --anchors --focus=<words> --if-enabled --json --brief` (callers, tests, coverage AND the slice anchors in ONE call: no Grep of that name, no `coverage`, no 3/4 call); else `orc graph map --focus=<3–6 words> --budget 800 --if-enabled --json --brief`, or `orc graph ctx <names, max 5> --if-enabled --json --brief` when it names files",
+      "graph: on (3/4) anchors — every dispatch that writes code: the 2/4 `anchors_card` when you ran `ctx <symbol> --anchors`; else ONE `orc graph ctx --for-slice <declared files> --focus=<words> [--refs=<files>] --anchors --if-enabled --json --brief`; the slice carries the card inline as graph_anchors",
+      "graph: on (4/4) affected tests — after the code: the hook prints a `graph changes` card when the executor returns; run its tests[] first. No card → `orc graph changes --files=<actual files> --if-enabled --json --brief`. Update only when update_step is lane; no lane calls `orc graph gain`. Copy each `line` and `trace` verbatim"
     );
   // A shadowed setting must never be silent, and neither must an inert one.
   const shadowed = [];
@@ -3556,11 +3619,11 @@ const LANE_CALLS = {
   "trace-write": {
     cmd: "orc trace write --packet - [--json]",
     what: "write ONE phase packet (stdin, plain YAML or JSON) into the run's trace pair",
-    exits: { 0: "written", 1: "usage or unreadable input", 2: "invalid packet — unknown verb, bad ts, parse error; nothing written", 3: "trace-file state — no `.current` on a later packet, or a rename target in the way; nothing written" },
+    exits: { 0: "written (`lines_written` 0 when every ASK was refused — read `ask_rejected`)", 1: "usage or unreadable input", 2: "invalid packet — unknown verb, bad ts, parse error; nothing written", 3: "trace-file state or any other write error; nothing written" },
     states: null,
     cost: "free",
     when: "at every phase close, in the same tool block as the next phase's first dispatch",
-    on_absent: "exit ≠ 0 → dispatch `orc-trace-writer-haiku-4-5` with the SAME packet (the fallback)",
+    on_absent: "exit ≠ 0 → dispatch `orc-trace-writer-haiku-5-high` with the SAME packet (the fallback)",
     canonical: "_shared/phases/trace.md",
     never: "never append trace lines by hand, and never retry a refused packet with a \"now\" timestamp",
     lanes: ["orc", "orc-fast", "orc-mini", "orc-quick", "orc-test"],
@@ -3580,8 +3643,9 @@ const LANE_CALLS = {
   "wiki-status": {
     cmd: "orc wiki status [--json]",
     what: "does a wiki EXIST, and how fresh is it",
-    exits: { 0: "answered in every state — read `tier`" },
-    states: ["none", "FRESH", "AGING", "STALE"],
+    // v2.1.2 F03 — `state` and `tier` are TWO fields; the old list mixed them.
+    exits: { 0: "answered in every state — read `state`; when it is `registered`, read `tier` (FRESH · AGING · STALE · unknown)" },
+    states: ["none", "unregistered", "corrupt", "drifted", "registered"],
     cost: "free",
     when: "once, at preflight, before any decision that needs project knowledge",
     on_absent: "`none` means absent; say so in ONE user line and continue — a missing wiki is never a blocker",
@@ -3590,7 +3654,9 @@ const LANE_CALLS = {
     // v1.9.0: /orc-mini joins. It always consulted the wiki; it now selects PAGE
     // PATHS for its slices instead of reading page bodies into its own context,
     // and the tier this command computes is what that selection rests on.
-    lanes: ["orc", "orc-boundary", "orc-brainstorm", "orc-fast", "orc-grill", "orc-mini", "orc-poly", "orc-quick", "orc-route", "orc-wiki"],
+    // v2.1.2 F03: /orc-learn and the /orc-diy wiki gate join — both computed the
+    // tier by hand, which this row's own `never` forbids.
+    lanes: ["orc", "orc-boundary", "orc-brainstorm", "orc-diy", "orc-fast", "orc-grill", "orc-learn", "orc-mini", "orc-poly", "orc-quick", "orc-route", "orc-wiki"],
   },
   "pattern-status": {
     cmd: "orc pattern status <lang>",
@@ -3642,7 +3708,7 @@ const LANE_CALLS = {
   "review-policy": {
     cmd: "orc review policy [--json]",
     what: "does the project's CLAUDE.md / AGENTS.md name its own review — the file, the line, the quote and the name",
-    exits: { 0: "answered in every state — read `policy` (orc | project)" },
+    exits: { 0: "answered in every state — read `policy` (orc | project)", 1: "usage" },
     states: ["orc", "project"],
     cost: "free",
     when: "at preflight, through the `review-policy` probe of `orc lane config`",
@@ -3659,7 +3725,7 @@ const LANE_CALLS = {
     exits: { 0: "FRESH (after a heal, too)", 1: "NONE — no index and it could not be built, or unavailable (not a git repository)", 2: "DRIFTED — and it could not be healed (locked, or `code_graph_auto_update: false`)", 3: "OFF — `code_graph` is off" },
     states: ["fresh", "none", "drifted", "off", "unavailable"],
     cost: "free",
-    when: "once, at preflight, in a code-changing lane — BEFORE the first dispatch",
+    when: "touchpoint 1 (consult), at preflight BEFORE the first dispatch: print `probes[\"graph-status\"].line` from `orc lane config`; run this call ONLY when that probe says `heal_needed`. Exit 3 (off or semi) → no other graph call this run",
     on_absent: "exit 3 is an ANSWER — print `graph: off` once and make no other graph call; any other exit never blocks: print its `line`, copy its `trace`, continue",
     canonical: "_shared/code-graph.md",
     never: "never read `code_graph` from the config yourself — `--if-enabled` is how a lane takes part without reading a key",
@@ -3671,7 +3737,7 @@ const LANE_CALLS = {
     exits: { 0: "built, updated or unchanged", 1: "unavailable — not a git repository, or another update holds the lock", 3: "off — `code_graph` is off" },
     states: ["built", "updated", "unchanged", "unavailable", "off"],
     cost: "free",
-    when: "at preflight when status was 1 or 2; after every wave's worktree audit; after a green smoke gate; after a code-writing /orc-quick request; at ship. v1.8.0 EW3 adds two paths that need no lane step: a READ heals what it is about to answer for, and the installed graph hook updates once when an ORC executor finishes",
+    when: "only when `update_step` is `lane` (`probes[\"graph-status\"].update_step`; hooks off, or notes on): after every wave's worktree audit; after a green smoke gate; after a code-writing /orc-quick request; at ship. `hook`, `preflight` or `none` → no update call: the graph hook updates when an ORC executor finishes, and a READ heals what it is about to answer for",
     on_absent: "exit 1 never blocks a phase — say it once and continue; the next preflight heals it",
     canonical: "_shared/code-graph.md",
     never: "never run it from a WATCHER or a background process — a continuous rebuild is how graph tools freeze a machine. A one-shot update at a discrete event (an executor finishing, a read that found its own target stale) is not that: it takes the same lock, it is bounded by `code_graph_heal_ms`, and a second one that finds the lock held SKIPS rather than queues",
@@ -3683,7 +3749,7 @@ const LANE_CALLS = {
     exits: { 0: "found (at least one target)", 1: "no graph index", 3: "off — `code_graph` is off", 4: "not found or ambiguous — nearest names or every candidate listed" },
     states: null,
     cost: "free",
-    when: "at slice build (the declared files, one call), in /orc-quick's Q1 look, and by the executor itself — the read ladder's step 0",
+    when: "touchpoint 3 (anchors): ONE `ctx --for-slice <declared files> --focus=<words> [--refs=<files>] --anchors` per dispatch that writes code — the slice carries its `card` inline as `graph_anchors`; a request that names ONE symbol: `ctx <symbol> --anchors --focus=<words>` is orient + anchors in one call (its `anchors_card` is the `graph_anchors`); touchpoint 2 (orient) when the request names files or symbols (max 5); and by the executor itself — the read ladder's step 0",
     on_absent: "exit 4 → back to read ladder step 1; an unknown symbol is never a reason to guess",
     canonical: "_shared/code-graph.md",
     never: "never act on behaviour from a card alone — read the RANGE it names; a card whose header says CHANGED is hints only",
@@ -3717,29 +3783,19 @@ const LANE_CALLS = {
   },
   // EW5 — the cheap signals. All three read what is already on disk (the index,
   // and git's own history), so all three cost zero model tokens.
-  "graph-coverage": {
-    cmd: "orc graph coverage <file…> --if-enabled [--json]",
-    what: "how much of each file the extractor actually saw — `full` · `partial` with the line ranges it did not finish · `skipped:<reason>` · `excluded`",
-    exits: { 0: "answered — ALWAYS, when a graph exists; a gap is an answer, never an error", 1: "no graph index", 3: "off — `code_graph` is off" },
-    states: null,
-    cost: "free",
-    when: "before you trust a card's SILENCE about a file — one batch call for every file in the slice",
-    on_absent: "exit 1 or 3 → read the source, exactly as before the graph existed",
-    canonical: "_shared/code-graph.md",
-    never: "never read `no recorded gap` as proof of completeness — a file marked `full` was fully PARSED, not fully understood",
-    lanes: ["orc", "orc-diy", "orc-quick"],
-  },
+  // v2.2.0: `graph-coverage` left the catalogue — only /orc-quick still names
+  // it, and a call one lane makes belongs to that lane.
   "graph-changes": {
     cmd: "orc graph changes [--base <ref>] --if-enabled [--json]",
     what: "the symbols THIS diff's hunks overlap, each with its callers, its tests, and a risk word that carries its own reason",
     exits: { 0: "answered (an empty answer is an answer)", 1: "no graph index, or not a git repository", 3: "off — `code_graph` is off" },
     states: null,
     cost: "free",
-    when: "at review, instead of `impact` on the declared files — and in a verify or ship summary",
+    when: "touchpoint 4 (affected tests): after the code, before the suite — `--files=<actual files>`; print `tests_line`, run `tests[]` first, then the suite, then print `blast_line`. At review, instead of `impact` on the declared files",
     on_absent: "exit 1 or 3 → review from the diff alone, exactly as before",
     canonical: "_shared/code-graph.md",
     never: "never report `risk` without the `why` beside it — a rating nobody can check is a rating nobody should act on",
-    lanes: ["orc", "orc-diy", "orc-mini", "orc-quick"],
+    lanes: ["orc", "orc-diy", "orc-fast", "orc-mini", "orc-quick"],
   },
   "graph-cochange": {
     cmd: "orc graph cochange <file> --if-enabled [--json]",
@@ -3776,17 +3832,17 @@ const LANE_CALLS = {
     exits: { 0: "a line", 1: "no ledger, or no rows yet", 3: "off" },
     states: null,
     cost: "free",
-    when: "ONCE, at the close of a code-writing request (quick) or after a green smoke gate (mini)",
+    when: "by hand — a USER command (the Code graph tab reads the same ledger). No lane calls it",
     on_absent: "exit 1 is an ANSWER — there is nothing to report yet, so report nothing",
     canonical: "_shared/code-graph.md",
     never: "never restate the line as a saving, never drop the word estimate or the range, and never let this call block or fail a run",
-    lanes: ["orc-mini", "orc-quick"],
+    lanes: [],
   },
   "graph-notes-pending": {
     cmd: "orc graph notes pending --files <a,b> [--at wave|end] --if-enabled [--json]",
     what: "which changed functions have no note for their current body — the input to one notes batch",
     exits: { 0: "rows to note — dispatch the noter", 1: "no graph index, or no --files", 3: "off — `code_graph` or `code_graph_notes` is off", 5: "none pending, fewer than `code_graph_notes_min`, or deferred to the other `--at` site — dispatch nothing" },
-    states: ["pending", "below-min", "none", "deferred", "off"],
+    states: ["pending", "below-min", "none", "deferred", "off", "usage"],
     cost: "free",
     when: "after the update that follows a wave, a green smoke gate or a code-writing request — only while notes are on",
     on_absent: "exit 5 is an ANSWER — the symbols wait for a later batch and nothing is lost",
@@ -3796,24 +3852,26 @@ const LANE_CALLS = {
     // both stopped making a SECOND call for them: each now runs
     // `update --notes-pending`, which answers the update and the pending batch
     // in one, and still dispatches the noter when the answer has rows.
-    lanes: ["orc", "orc-diy", "orc-fast"],
+    // v2.2.0: no lane names it any more — every lane asks for the batch
+    // INSIDE `update --notes-pending`; the noter agent makes this call itself.
+    lanes: [],
   },
   "gotcha-list": {
     cmd: "orc gotcha list [--archived] [--json]",
     what: "the live repair-memory entries, or the archived tail",
-    exits: { 0: "answered" },
+    exits: { 0: "entries listed", 1: "the ledger is empty — an ANSWER" },
     states: null,
     cost: "free",
     when: "on demand, when the user asks what this project has already gotten wrong",
-    on_absent: "an empty list is an ANSWER",
+    on_absent: "exit 1 is an ANSWER — inject nothing",
     canonical: "_shared/gotchas.md",
     never: "never write the ledger from a lane — a gotcha is recorded only on a red → green repair",
     lanes: ["orc-boundary", "orc-brainstorm", "orc-grill"],
   },
   "extra-resolve": {
-    cmd: "orc extra resolve <score> [--json]",
+    cmd: "orc extra resolve <score> | --slot <slot> [--json]",
     what: "does this SCORE route to a non-Claude worker, and what is the Claude answer it displaced",
-    exits: { 0: "extra", 1: "claude" },
+    exits: { 0: "extra", 1: "claude — or a bad score (read `reason`)", 2: "unknown slot, or both a score and a slot" },
     states: null,
     cost: "free",
     when: "per scored task, before dispatch",
@@ -3823,9 +3881,9 @@ const LANE_CALLS = {
     lanes: ["orc", "orc-diy", "orc-doc", "orc-fast", "orc-quick", "orc-test", "orc-wiki"],
   },
   "extra-role": {
-    cmd: "orc extra role list|set|clear [--json]",
+    cmd: "orc extra role list|show|set|rm [--json]",
     what: "which fixed POSITION is held by a non-Claude worker",
-    exits: { 0: "answered" },
+    exits: { 0: "answered — list: at least one slot routes", 1: "list: no slot routes (an ANSWER) · show/set/rm: refused, read `reason`", 2: "unknown slot" },
     states: null,
     cost: "free",
     when: "before dispatching a role that has no score",
@@ -3835,9 +3893,10 @@ const LANE_CALLS = {
     lanes: ["orc-diy", "orc-doc", "orc-fast", "orc-quick", "orc-wiki"],
   },
   "extra-dispatch": {
-    cmd: "orc extra dispatch --slice <f> (--score N | --slot S) [--json]",
+    // The score or the slot is a FIELD of the slice, never a flag.
+    cmd: "orc extra dispatch --task <slice.json> [--json]",
     what: "send ONE task to a non-Claude worker and get a validated return",
-    exits: { 0: "dispatched (read `outcome`)", 1: "refused — read `reason`" },
+    exits: { 0: "done", 1: "failed — read `reason`; run `orc extra reconcile <task>` first", 2: "bad slice or usage — nothing was sent", 3: "not routed, or held by the concurrency cap — dispatch the pinned Claude agent BY NAME", 4: "partial — reconcile before anything else" },
     states: null,
     cost: "paid-per-task",
     when: "per task, only after `extra resolve` or `extra role` said extra",
@@ -3861,7 +3920,7 @@ const LANE_CALLS = {
   "extra-stats": {
     cmd: "orc extra stats [--since <d>] [--json]",
     what: "what the foreign dispatches actually cost, per profile",
-    exits: { 0: "answered" },
+    exits: { 0: "answered", 1: "zero dispatches in the window — an ANSWER" },
     states: null,
     cost: "free",
     when: "on demand, and at the end of a run that dispatched foreign",
@@ -3873,7 +3932,7 @@ const LANE_CALLS = {
   "extra-rates": {
     cmd: "orc extra rates [--json]",
     what: "the dated price table for foreign models, and what is missing from it",
-    exits: { 0: "answered" },
+    exits: { 0: "every model is priced", 1: "a model has no rate — it reads as an EM DASH, never zero" },
     states: null,
     cost: "free",
     when: "before quoting any dollar figure for a foreign dispatch",
@@ -3900,7 +3959,7 @@ const LANE_CALLS = {
     exits: { 0: "compiled", 1: "refused" },
     states: null,
     cost: "free",
-    when: "only when the user asks, or after `diy status` reports STALE",
+    when: "only on `/orc-diy compile` — the user's explicit ask. A STALE status is REPORTED with this as the fix; the lane never runs it",
     on_absent: "a refusal names its reason; never stitch a flow in-session",
     canonical: null,
     never: "never edit FLOW-COMPILED.md or flow.lock.json by hand, and never patch a flow conversationally",
@@ -3909,7 +3968,7 @@ const LANE_CALLS = {
   "wiki-sync": {
     cmd: "orc wiki sync [--check]",
     what: "re-derive wiki/INDEX.md and wiki-meta.json from the doc headers",
-    exits: { 0: "in sync", 1: "--check found drift" },
+    exits: { 0: "in sync", 1: "no wiki docs, or (--check) drift or a crosslink alarm" },
     states: null,
     cost: "free",
     when: "after every scan-task, at every pause, and at Phase 3",
@@ -3921,8 +3980,8 @@ const LANE_CALLS = {
   "wiki-impact": {
     cmd: "orc wiki impact [--json]",
     what: "does the wiki need a DELTA refresh or a FULL one",
-    exits: { 0: "fresh", 1: "delta", 2: "full recommended", 3: "structural" },
-    states: null,
+    exits: { 0: "CLEAN — the wiki still covers HEAD", 1: "cannot compute — no wiki, not registered, no scan_commit, or git failed (read `reason`)", 2: "DELTA — refresh only the touched docs", 3: "FULL recommended — read `reasons` (affected %, STRUCTURAL, aging); advisory, the user decides" },
+    states: ["CLEAN", "DELTA", "FULL", "unavailable"],
     cost: "free",
     when: "before any refresh, to choose its shape",
     on_absent: "delta is the DEFAULT; a full refresh is recommended, never silent",
@@ -3933,7 +3992,7 @@ const LANE_CALLS = {
   "wiki-debt": {
     cmd: "orc wiki debt [--json]",
     what: "what the wiki is missing, as a report",
-    exits: { 0: "answered" },
+    exits: { 0: "no debt", 1: "debt pending — read `rows`", 3: "no wiki, or not registered" },
     states: null,
     cost: "free",
     when: "on demand",
@@ -3945,7 +4004,7 @@ const LANE_CALLS = {
   "wiki-usage": {
     cmd: "orc wiki usage [--json]",
     what: "which wiki docs are actually being read",
-    exits: { 0: "answered" },
+    exits: { 0: "answered", 1: "no trace recorded a consult yet — `used: null`, never zero" },
     states: null,
     cost: "free",
     when: "when planning a refresh or a retirement",
@@ -3969,7 +4028,7 @@ const LANE_CALLS = {
   "challenge-status": {
     cmd: "orc challenge status <slug> [--json]",
     what: "where a challenge cycle stands right now",
-    exits: { 0: "answered" },
+    exits: { 0: "passed, or nothing blocking", 1: "blocking findings, or STALE-PASS", 2: "a P0, or the ledger was TAMPERED", 3: "no such cycle, or unreadable" },
     states: null,
     cost: "free",
     when: "at entry, and after any record",
@@ -3979,9 +4038,9 @@ const LANE_CALLS = {
     lanes: ["orc-analyze", "orc-challenge"],
   },
   "challenge-init": {
-    cmd: "orc challenge init <slug> --goal … --audience … --done-means … --council …",
+    cmd: "orc challenge init <slug> --artifact <path> (--template <path> | --no-template) --goal … --audience … --done-means … --council …",
     what: "freeze the goal, the audience, the finish line and the council roster",
-    exits: { 0: "created", 1: "refused — a required answer is missing, BY NAME" },
+    exits: { 0: "created", 2: "refused — a required answer is missing, BY NAME" },
     states: null,
     cost: "free",
     when: "once per artifact, before any judging",
@@ -3993,7 +4052,7 @@ const LANE_CALLS = {
   "challenge-report": {
     cmd: "orc challenge report <slug> [--json]",
     what: "the findings and the fix brief for a cycle",
-    exits: { 0: "answered" },
+    exits: { 0: "answered", 3: "no such cycle" },
     states: null,
     cost: "free",
     when: "after a verdict is recorded",
@@ -4005,7 +4064,7 @@ const LANE_CALLS = {
   "pact-status": {
     cmd: "orc pact status [--json]",
     what: "which promises this project makes, and which are in doubt",
-    exits: { 0: "answered" },
+    exits: { 0: "every promise HOLDING (UNCHECKABLE never raises the code)", 1: "a promise DRIFTED", 2: "a promise is BROKEN", 3: "no ledger yet — a first run (an ANSWER)" },
     states: ["HOLDING", "DRIFTED", "UNCHECKABLE", "BROKEN"],
     cost: "free",
     when: "at preflight when the run will touch an anchored area",
@@ -4015,9 +4074,9 @@ const LANE_CALLS = {
     lanes: ["orc", "orc-aftermath", "orc-pact"],
   },
   "boundary-status": {
-    cmd: "orc boundary status [--area <a>] [--json]",
+    cmd: "orc boundary status [<area path>] [--json]",
     what: "may ORC attempt this area itself",
-    exits: { 0: "answered" },
+    exits: { 0: "every carded area EXECUTE", 1: "an area ESCALATES", 2: "an area REFUSES", 3: "no card, a malformed card, or every card stale — UNKNOWN, never safe" },
     states: ["EXECUTE", "ESCALATE", "REFUSE"],
     cost: "free",
     when: "at preflight, per area the run will touch",
@@ -4029,8 +4088,8 @@ const LANE_CALLS = {
   "aftermath-status": {
     cmd: "orc aftermath status [--json]",
     what: "did what we shipped hold up",
-    exits: { 0: "answered" },
-    states: null,
+    exits: { 0: "nothing came back", 1: "CHURN on a graded run", 2: "a run was REVERTED", 3: "not a git work tree, or too shallow to grade (an ANSWER)" },
+    states: ["HELD", "CHURN", "REVERTED", "TOO_RECENT", "SHALLOW"],
     cost: "free",
     when: "at preflight, ONLY when there is a real churn signal in the area about to be touched",
     on_absent: "a run under 7 days old is TOO_RECENT and KEEPS ITS SLOT — an answer, not a gap",
@@ -4039,21 +4098,27 @@ const LANE_CALLS = {
     lanes: ["orc", "orc-aftermath"],
   },
   "budget-forecast": {
-    cmd: "orc budget forecast --plan <f> [--json]",
+    // v2.1.2 F16 — the plan is a POSITIONAL, and exit 1 is an ANSWER here.
+    cmd: "orc budget forecast <plan-file> [--json] [--naive] [--as tokens|usd|quota|context|all]",
     what: "what will this PLAN cost, as a range with a sample count",
-    exits: { 0: "answered", 1: "refused — no history to forecast from" },
+    exits: {
+      0: "answered — every band has budget_min_samples or more",
+      1: "answered — a LOW-CONFIDENCE band (fewer samples than budget_min_samples): the top of the range is soft",
+      2: "answered — a task forecasts above 90% of its model's context window",
+      3: "refused — no plan file, no `- id:` task blocks, or no history to forecast from",
+    },
     states: null,
     cost: "free",
     when: "after planning, before the first wave",
-    on_absent: "no history → it REFUSES; `--naive` is the price-table floor, and a refusal is still shown once",
+    on_absent: "no history → it REFUSES with exit 3; `--naive` is the price-table floor, and a refusal is still shown once",
     canonical: null,
     never: "never quote dollars without a dated price table, a quota without a known plan, or a figure without its sample count",
     lanes: ["orc-budget", "orc-route"],
   },
   "budget-actual": {
-    cmd: "orc budget actual [--since <d>] [--json]",
+    cmd: "orc budget actual <run-slug> [--json]",
     what: "what a run actually cost",
-    exits: { 0: "answered" },
+    exits: { 0: "answered", 3: "no run matches the slug — read `known`" },
     states: null,
     cost: "free",
     when: "after a run, or on demand",
@@ -4066,7 +4131,7 @@ const LANE_CALLS = {
     cmd: "orc run list [--json]",
     what: "which runs are unfinished, and where each one stands",
     exits: { 0: "answered" },
-    states: ["waiting", "closed"],
+    states: ["waiting", "closed", "done", "empty"],
     cost: "free",
     when: "at entry, when resuming",
     on_absent: "a listing may only claim what the disk proves — a missing `state-of-play.md` never means incomplete",
@@ -4089,11 +4154,11 @@ const LANE_CALLS = {
   "export-import": {
     cmd: "orc export import [--json]",
     what: "read an existing AGENTS.md or .cursorrules and say what is already wrong",
-    exits: { 0: "answered" },
+    exits: { 0: "answered", 3: "nothing to import — an ANSWER" },
     states: null,
     cost: "free",
     when: "on demand, in a repo that never ran ORC",
-    on_absent: "nothing to import is an ANSWER",
+    on_absent: "exit 3 is an ANSWER — say so in one line",
     canonical: null,
     never: "never apply an import without the user's yes",
     lanes: ["orc-export", "orc-pact"],
@@ -4419,7 +4484,7 @@ const PHASE_FILES = {
   },
   "ship": {
     file: "_shared/phases/ship.md",
-    trace_verbs: ["PHASE", "GATE", "GRAPH-UPDATE", "GRAPH-GAIN"],
+    trace_verbs: ["PHASE", "GATE", "GRAPH-UPDATE"],
     layers: ["full", "composed"],
     // v1.0.0 W13 — orc-diy became the second reader, so the phase left
     // orc/references/phases/ for the library. `full` is /orc's procedure;
@@ -4549,7 +4614,21 @@ const PROBE_DEFS = {
     argv: () => ["graph", "status", "--if-enabled", "--brief"],
     run: () => graphCmd(),
     pick: ["state", "enabled", "exists", "files", "symbols", "generation", "auto_update", "notes", "trace"],
-    derive: (j) => ({ heal_needed: !!(j.enabled && j.auto_update && (j.state === "none" || j.state === "drifted")) }),
+    // v2.2.0: `update_step` names WHO keeps the graph current after a code
+    // change — none (off), the SubagentStop hook, the lane's own update step,
+    // or only the preflight heal (semi with the hooks off). A semi answer says
+    // state "semi" AFTER its own heal, so heal_needed reads the config too.
+    derive: (j) => {
+      const { map } = readOverride(resolveClaudeDir());
+      const get = (k) => String(Object.prototype.hasOwnProperty.call(map, k) ? map[k] : metaFor(k).def).toLowerCase();
+      const mode = get("code_graph");
+      const hooksOn = get("code_graph_hooks").split(",")[0].trim() === "on";
+      const notesOff = get("code_graph_notes") === "off";
+      const update_step =
+        mode === "on" ? (hooksOn && notesOff ? "hook" : "lane") : mode === "semi" ? (hooksOn ? "hook" : "preflight") : "none";
+      const maintained = mode === "on" || mode === "semi";
+      return { heal_needed: !!(maintained && j.auto_update && (j.state === "none" || j.state === "drifted" || (j.state === "semi" && (j.index_state === "none" || j.index_state === "drifted")))), update_step };
+    },
     line: (j) => j.line,
   },
   "rules-slice": {
@@ -4671,19 +4750,21 @@ const LANE_TRACE = {
   // `spine_verbs` (v2.0.0 T1): the verbs a lane's own SPINE emits outside
   // any declared phase row — orc's ultra gates, and orc-mini, whose pipeline is
   // still in-spine. They join `trace_grammar` like a phase's `trace_verbs`.
-  orc: { tier: "Build lanes", token: "orc", spine_verbs: ["ADVISE", "JUDGE"] },
+  // v2.1.2 F04/F68: a graph read a lane may make hands it that read's verb —
+  // mini and fast run their graph steps in-spine, and `coverage` had no verb.
+  orc: { tier: "Build lanes", token: "orc", spine_verbs: ["ADVISE", "JUDGE", "GRAPH-COVERAGE"] },
   "orc-mini": {
     tier: "Build lanes",
     token: "mini",
-    spine_verbs: ["PHASE", "GATE", "OUTCOME", "DRIFT", "TDD-RED", "TDD-GREEN", "FINDING", "FINDING-OUTCOME", "REVIEW-WHICH", "GRAPH-CONSULT", "GRAPH-UPDATE", "GRAPH-COMPLEXITY", "GRAPH-NOTES"],
+    spine_verbs: ["PHASE", "GATE", "OUTCOME", "DRIFT", "TDD-RED", "TDD-GREEN", "FINDING", "FINDING-OUTCOME", "REVIEW-WHICH", "GRAPH-CONSULT", "GRAPH-MAP", "GRAPH-UPDATE", "GRAPH-COMPLEXITY", "GRAPH-CHANGES", "GRAPH-NOTES"],
   },
-  "orc-fast": { tier: "Build lanes", token: "fast" },
+  "orc-fast": { tier: "Build lanes", token: "fast", spine_verbs: ["GRAPH-UPDATE", "GRAPH-NOTES", "GRAPH-CHANGES"] },
   "orc-wiki": { tier: "Multi-dispatch", token: "wiki" },
   "orc-pr-driver": { tier: "Multi-dispatch", token: "prdriver" },
   "orc-diy": { tier: "Composed", token: "diy" },
   "orc-quick": { tier: "Iterative", token: "quick" },
   "orc-challenge": { tier: "Iterative", token: "challenge" },
-  "orc-doc": { tier: "Iterative", token: "doc" },
+  "orc-doc": { tier: "Iterative", token: "doc", spine_verbs: ["DOC"] },
   "orc-test": { tier: "Iterative", token: "test" },
   "orc-claude": { tier: "Single-dispatch", token: "claude" },
   "orc-analyze": { tier: "Single-dispatch", token: "analyze" },
@@ -4722,14 +4803,15 @@ const TRACE_VERBS = {
   CONFIG: { grammar: "CONFIG <key=value …>", emitter: "orc → writer", meaning: "Phase 1 — the resolved config values this run will consume, ALWAYS with opus5_only", owner: "_shared/phases/trace-verbs.md" },
   "WIKI-CONSULT": { grammar: "WIKI-CONSULT <fresh|aging|stale|absent|empty> :: docs=<list|none>", emitter: "orc → writer", meaning: "project wiki consulted for grounding, with its staleness tier", owner: "_shared/phases/wiki-consult.md" },
   CROSSLINK: { grammar: "CROSSLINK <cached|configured-no-cache|none> :: boundaries=<n> peers=<names> · CROSSLINK inject task=<id> :: <boundary>", emitter: "orc → writer", meaning: "cross-repo peer-knowledge state at the consult point; `inject` when a slice receives a linked contract", owner: "_shared/phases/wiki-consult.md" },
-  "GRAPH-CONSULT": { grammar: "GRAPH-CONSULT <fresh|updated|built|drifted|none|off> :: files=<n> symbols=<n>[ density=<n>[ thin=1]] · GRAPH-CONSULT card task=<id> :: targets=<…>", emitter: "orc → writer", meaning: "the code graph's preflight state, copied VERBATIM from the CLI `trace` field", owner: "_shared/code-graph.md" },
+  "GRAPH-CONSULT": { grammar: "GRAPH-CONSULT <fresh|updated|built|drifted|none|semi|off|pack|anchors> :: files=<n> symbols=<n>[ density=<n>[ thin=1]] · GRAPH-CONSULT card task=<id> :: targets=<…> · GRAPH-CONSULT pack :: files=<n> refs=<n> excerpts=<n> tokens=<n> gen=<n> · GRAPH-CONSULT anchors :: ranges=<n> files=<n> gen=<n>", emitter: "orc → writer", meaning: "the code graph's preflight state, copied VERBATIM from the CLI `trace` field", owner: "_shared/code-graph.md" },
   "GRAPH-UPDATE": { grammar: "GRAPH-UPDATE <state> :: parsed=<n> reused=<n> deleted=<n> gen=<n> route=<n> ms=<n>", emitter: "orc → writer", meaning: "one graph update, the `trace` field of `orc graph update --json`, verbatim", owner: "_shared/phases/trace-verbs.md" },
   "GRAPH-MAP": { grammar: "GRAPH-MAP <repo|focused> :: files=<shown>/<total> [focus=<a,b>] gen=<n>", emitter: "orc → writer", meaning: "ONE line at the start of planning, the `trace` field of `orc graph map --json`, verbatim", owner: "_shared/phases/trace-verbs.md" },
   "GRAPH-CHANGES": { grammar: "GRAPH-CHANGES <found|none> :: symbols=<n> high=<n> medium=<n> low=<n> gen=<n>", emitter: "orc → writer", meaning: "one line at review, the `trace` field of `orc graph changes --json`, verbatim", owner: "_shared/phases/trace-verbs.md" },
   "GRAPH-COMPLEXITY": { grammar: "GRAPH-COMPLEXITY <mini-ok|recommend-orc> :: files=<n> callers=<n> caller_files=<n> maybe=<n> tests=<n> risk=<n> cochange=<n> gen=<n>", emitter: "orc → writer", meaning: "one line per /orc-mini run, the `trace` field of the `--complexity` impact call, verbatim", owner: "_shared/phases/trace-verbs.md" },
-  "GRAPH-COCHANGE": { grammar: "GRAPH-COCHANGE <found|none> :: rows=<n> commits=<n>", emitter: "orc → writer", meaning: "one line per planning batch, for the file that produced the widest answer", owner: "_shared/phases/trace-verbs.md" },
+  "GRAPH-COCHANGE": { grammar: "GRAPH-COCHANGE <found|none> :: rows=<n> commits=<n> · GRAPH-COCHANGE none :: history=<n>", emitter: "orc → writer", meaning: "one line per planning batch, for the file that produced the widest answer", owner: "_shared/phases/trace-verbs.md" },
+  "GRAPH-COVERAGE": { grammar: "GRAPH-COVERAGE <clean|gaps> :: paths=<n> gaps=<n> gen=<n>", emitter: "orc → writer", meaning: "the `trace` field of `orc graph coverage --json` — which files a card's silence can be trusted on", owner: "_shared/phases/trace-verbs.md" },
   "GRAPH-HINT": { grammar: "GRAPH-HINT injected=<n> subagent_start=<n> read_notes=<n> updates=<n>", emitter: "orc → writer", meaning: "ONE line per phase close, the graph hook's counters; omitted when the counter file does not exist", owner: "_shared/phases/trace-verbs.md" },
-  "GRAPH-GAIN": { grammar: "GRAPH-GAIN paid=<n> low=<n> high=<n> calls=<n>", emitter: "orc → writer", meaning: "ONE line per run at ship; `paid` is exact, `low`/`high` are an estimate never collapsed into one number", owner: "_shared/phases/trace-verbs.md" },
+  "GRAPH-GAIN": { grammar: "GRAPH-GAIN paid=<n> low=<n> high=<n> calls=<n>", emitter: "orc → writer", meaning: "OLD traces only — no lane emits it now (`orc graph gain` is a user command); `paid` is exact, `low`/`high` are an estimate never collapsed into one number", owner: "_shared/phases/trace-verbs.md" },
   "GRAPH-NOTES": { grammar: "GRAPH-NOTES <applied|below-min|none|deferred|off|skipped> :: <detail>", emitter: "orc → writer", meaning: "one notes batch; `applied` copies the noter's one-line return verbatim", owner: "_shared/phases/trace-verbs.md" },
   SPAWN: { grammar: "SPAWN <agent>", emitter: "hook", meaning: "an agent dispatch was observed (skeleton)", owner: "hooks/orc-trace.js" },
   RETURN: { grammar: "RETURN <agent> :: <desc> dur=<m>m<s>s [model=<id>]", emitter: "hook", meaning: "a subagent finished (skeleton) — not an orchestrator obligation; the model check is VERIFY", owner: "hooks/orc-trace.js" },
@@ -4746,18 +4828,20 @@ const TRACE_VERBS = {
   OUTCOME: { grammar: "OUTCOME task=<id> score=<n> band=<range> model=<m> retries=<n> requeues=<n> needs_context=<n> unmet=<n>", emitter: "orc → writer", meaning: "task closed — links the scoring band to what it actually took", owner: "_shared/phases/execution.md" },
   FINDING: { grammar: "FINDING p0=<n> p1=<n> p2=<n> p3=<n>[ pre=<n> suppressed=<n> folded=<n>]", emitter: "reviewer→orc → writer", meaning: "review outcome (P0–P3 severity ladder); the tail counts the after-filter's buckets", owner: "_shared/phases/review.md" },
   "REVIEW-WHICH": { grammar: "REVIEW-WHICH chose=<orc|project|skip> name=<the review the rule names> by=<user|ledger|learned> :: <file:line of the rule>", emitter: "orc → writer", meaning: "the answer to §0 \"which review\" when the project names its own review — written ALWAYS, also under habits off; the FINISH nudge reads it", owner: "_shared/phases/trace-verbs.md" },
-  FIX: { grammar: "FIX source=<sonar|ci|defect|pr|review|other> introduced_by=<orc|ai|human|unknown> by=<user|evidence> obs=<id8>[ missed_by=<run>] :: <path:lines> <rule or finding>", emitter: "cli", meaning: "one fix recorded by `orc fix record` (/orc-fix) into the HOST run's trace — the CLI writes it, never a packet", owner: "orc-fix/SKILL.md" },
+  FIX: { grammar: "FIX source=<sonar|ci|defect|pr|review> introduced_by=<orc|ai|human|unknown> by=<user|evidence> obs=<id8>[ missed_by=<run>] :: <path:lines> <rule or finding>", emitter: "cli", meaning: "one fix recorded by `orc fix record` (/orc-fix) into the HOST run's trace — the CLI writes it, never a packet — `source` is the FILED kind: a class `other` is filed as `defect`", owner: "orc-fix/SKILL.md" },
+  WAIT: { grammar: "WAIT mode=<safe|soft|hard> requested=<n>m start=<HH:MM> end=<HH:MM> hops=<planned>/<max> trigger=<user|gate> · WAIT end :: done=<k>/<planned> reason=<elapsed|recovered|cancelled|max-hops> · WAIT block :: reason=\"<why>\" by=user · WAIT unblock", emitter: "cli", meaning: "a wait started, ended, blocked or unblocked — `orc wait` writes it into the open trace, never a packet", owner: "_shared/wait.md" },
   "FINDING-OUTCOME": { grammar: "FINDING-OUTCOME addressed=<n> disputed=<n> wontfix=<n> open=<n> pre=<n> suppressed=<n> :: <cat>:<addressed>/<total>,…", emitter: "orc → writer", meaning: "ONE line at review close (a clean review too) — what became of each finding; `orc gotcha quality` counts it as a review", owner: "_shared/phases/trace-verbs.md" },
   VERDICT: { grammar: "VERDICT pass|fail :: <detail>", emitter: "verifier→orc → writer", meaning: "verification outcome", owner: "_shared/phases/verify.md" },
   DRIFT: { grammar: "DRIFT loop=<n> :: <user description, compressed>", emitter: "orc → writer", meaning: "mock-example drift-recovery loop opened (hard cap 2 loops)", owner: "_shared/drift-recovery.md" },
   "TDD-RED": { grammar: "TDD-RED task=<id> iter=<n> :: <failing tests>", emitter: "executor→orc → writer", meaning: "TDD repair-loop iteration — the plan's acceptance tests still red", owner: "_shared/phases/trace-verbs.md" },
   "TDD-GREEN": { grammar: "TDD-GREEN task=<id> iter=<n>", emitter: "executor→orc → writer", meaning: "the task's TDD acceptance tests pass", owner: "_shared/phases/trace-verbs.md" },
   REPRO: { grammar: "REPRO red|green :: <cmd> exit=<n> · REPRO none :: <reason>", emitter: "executor→orc → writer", meaning: "a DEFECT task's reproduction: RED before the fix, GREEN after", owner: "_shared/return-validation.md" },
-  NOTE: { grammar: "NOTE :: <decisions>", emitter: "writer", meaning: "the packet's `decisions` field — the WHY layer; one line, only when non-empty", owner: "agents/orc-trace-writer-haiku-4-5.md" },
+  NOTE: { grammar: "NOTE :: <decisions>", emitter: "writer", meaning: "the packet's `decisions` field — the WHY layer; one line, only when non-empty", owner: "agents/orc-trace-writer-haiku-5-high.md" },
   STATS: { grammar: "STATS lane=<l> slug=<s> dispatches=<n> waves=<n> tasks=<n> bands=<h:n,m:n,l:n> downgrades=<n> duration_ms=<n>", emitter: "orc → writer", meaning: "ONE summary line per run, in the FINISH packet, immediately BEFORE the FINISH line", owner: "_shared/phases/trace-verbs.md" },
   PACT: { grammar: "PACT <state> :: <ids> · PACT inject task=<id> :: <PACT-id> · PACT recheck pass|fail :: <ids>", emitter: "orc → writer", meaning: "invariant-ledger state at the Phase-1 probe, a promise injected into a task, the Phase-6 recheck", owner: "orc-pact/references/gate.md" },
   BOUNDARY: { grammar: "BOUNDARY <EXECUTE|ESCALATE|REFUSE|unknown> task=<id> :: <area> · BOUNDARY lift task=<id> :: <area>", emitter: "orc → writer", meaning: "per-task boundary verdict; an uncarded area is `unknown`, never REFUSE", owner: "orc-boundary/references/gate.md" },
   CHALLENGE: { grammar: "CHALLENGE iter=<n> findings=P0:<n>/P1:<n>/P2:<n> coverage=<n>% verdict=PASS|FAIL · CHALLENGE accept|rebut :: <id> · CHALLENGE regoal|retemplate :: v<n>", emitter: "orc → writer", meaning: "one line per completed /orc-challenge iteration — `orc challenge record`'s `trace_line`, verbatim", owner: "orc-challenge/SKILL.md" },
+  DOC: { grammar: "DOC cycle=<n> sections=<k>/<m>[ wave=<k>/<n>]", emitter: "orc → writer", meaning: "one line per completed /orc-doc cycle — a completed WAVE is a completed cycle", owner: "orc-doc/SKILL.md" },
   EXTRA: { grammar: "EXTRA <profile>/<model> engine=<api|claude-shim|cli> task=<id> band=[lo,hi) tok=in/cw/cr/out outcome=<done|partial|failed|fallback> dur=<m>m<s>s · EXTRA fallback task=<id> :: <reason> → <agent> · EXTRA substitution task=<id> :: requested=<m> reported=<m> · EXTRA reroute task=<id> :: <providers> · EXTRA resume task=<id> attempt=<n> :: from=<reason> attribution=<verdict> target=<extra:profile|agent> files_preexisting=<n> · EXTRA orphan task=<id> :: attempt=<n> lease-expired files_changed=<n> state=<state> · EXTRA demote run=<slug> :: profile=<p> reason=<consecutive-stall|stale-live-attempt|manual> n=<k> → <ladder>", emitter: "orc → writer", meaning: "one line per FOREIGN dispatch — `orc extra dispatch`'s `trace_line`, verbatim", owner: "_shared/extra-dispatch.md" },
   FINISH: { grammar: "FINISH :: <detail>", emitter: "orc → writer", meaning: "run ended — mandatory, even on an abort", owner: "_shared/phases/trace.md" },
 };
@@ -4786,6 +4870,29 @@ function laneTraceGrammar(lane) {
   return out;
 }
 
+// v2.2.0 T13 — the verb heads of a lane, by lane name or trace token (`quick`,
+// `orc-quick`); null when it names no traced lane. `orc trace write` lists these
+// when it refuses an unknown verb.
+function laneVerbsFor(x) {
+  const k = String(x || "");
+  const lane = LANE_TRACE[k] ? k : Object.keys(LANE_TRACE).find((l) => LANE_TRACE[l].token === k);
+  const g = lane ? laneTraceGrammar(lane) : null;
+  return g ? Object.keys(g) : null;
+}
+
+// v2.2.0 T13 — `{ qid: "offered=<o1|o2>" }` for every ASK question registered for a lane.
+function laneAskIds(lane) {
+  let H = null;
+  try { H = require("./habit.js"); } catch (_) { return {}; }
+  const out = {};
+  for (const [q, p] of Object.entries(H.ASK_POINTS || {})) {
+    if (!(p.lanes || []).includes(lane)) continue;
+    const o = Object.keys(p.options || {});
+    out[q] = `offered=${o.length ? o.join("|") : "<the agent names you offered>"}`;
+  }
+  return out;
+}
+
 // Which lanes run which SHARED phase. A lane absent from a row does not run
 // that phase — \`/orc-retro\` is in no trace row because it mines traces and
 // writes none (its hard rule 4), and \`context-combiner\` is in none because it
@@ -4811,7 +4918,7 @@ const LANE_PHASES = {
     "orc-test",
   ],
   "stop-resume": ["orc", "orc-wiki", "orc-diy", "orc-test"],
-  intake: ["orc", "orc-mini", "orc-diy", "orc-challenge"],
+  intake: ["orc", "orc-mini", "orc-diy"],
   "plan-handoff": ["orc", "orc-route"],
   "wave-grouping": ["orc", "orc-diy"],
   "analyst-gates": ["orc", "orc-analyze", "orc-mini"],
@@ -5051,9 +5158,9 @@ const LANE_OWN_PHASES = {
     // pointer names a heading byte-for-byte, and a payload test asserts each
     // one still exists in the spine.
     { ord: 0, id: "q0", file: "orc-quick/SKILL.md", heading: "## Q0 — Preflight (ONE time per session, silent, nothing can stop the run)", read: "section", trace_verbs: ["GATE", "GRAPH-CONSULT"] },
-    { ord: 1, id: "q1", file: "orc-quick/SKILL.md", heading: "## Q1 — LOOK (silent — no questions here)", read: "section", trace_verbs: ["GATE", "WIKI-CONSULT", "GRAPH-CONSULT", "GRAPH-MAP"] },
+    { ord: 1, id: "q1", file: "orc-quick/SKILL.md", heading: "## Q1 — LOOK (silent — no questions here)", read: "section", trace_verbs: ["GATE", "WIKI-CONSULT", "GRAPH-CONSULT", "GRAPH-MAP", "GRAPH-COVERAGE"] },
     { ord: 2, id: "q2", file: "orc-quick/SKILL.md", heading: "## Q2 — ASK (ONE user turn: questions + the gate together)", read: "section", trace_verbs: [] },
-    { ord: 3, id: "q3", file: "orc-quick/SKILL.md", heading: "## Q3 — DO (dispatch → build/test → write the doc → offer)", read: "section", trace_verbs: ["DISPATCH", "VERIFY", "REPRO", "GRAPH-CHANGES", "GRAPH-UPDATE", "GRAPH-NOTES", "GRAPH-GAIN", "OUTCOME", "FINDING", "FINDING-OUTCOME", "REVIEW-WHICH", "FINISH"] },
+    { ord: 3, id: "q3", file: "orc-quick/SKILL.md", heading: "## Q3 — DO (dispatch → build/test → write the doc → offer)", read: "section", trace_verbs: ["DISPATCH", "VERIFY", "REPRO", "GRAPH-CHANGES", "GRAPH-UPDATE", "GRAPH-NOTES", "OUTCOME", "FINDING", "FINDING-OUTCOME", "REVIEW-WHICH", "FINISH"] },
   ],
   "orc-wiki": [
     { ord: 0, id: "phase-0", file: "orc-wiki/references/phases/phase-0.md", layers: ["full"], trace_verbs: [] },
@@ -5316,6 +5423,8 @@ function lanePhasesCmd(lane, claudeDir) {
       layer_set: PHASE_LAYERS,
       phase_files: PHASE_FILES,
       lanes: out,
+      // v2.2.0 T13 — one lane answered: its grammar and ASK ids at the top level too.
+      ...(out.length === 1 ? { trace_grammar: out[0].trace_grammar, ask_ids: laneAskIds(out[0].lane) } : {}),
     });
     return 0;
   }
@@ -5332,6 +5441,10 @@ function lanePhasesCmd(lane, claudeDir) {
         "  trace grammar  " +
           ui.color.gray(`${Object.keys(r.trace_grammar).length} verbs: ${Object.keys(r.trace_grammar).join(" · ")}  (--json → trace_grammar)`)
       );
+    if (!all) {
+      const ids = Object.keys(laneAskIds(r.lane));
+      if (ids.length) console.log("  ask ids  " + ui.color.gray(`${ids.join(" · ")}  (--json → ask_ids)`));
+    }
     if (!r.phases.length) {
       // An empty answer is an ANSWER: this lane runs no SHARED phase yet.
       console.log(
@@ -5620,14 +5733,13 @@ const sha256 = (s) => crypto.createHash("sha256").update(s).digest("hex");
 // (`sonnet-5-low`, `sonnet-5-med`).
 //
 // It also feeds `fixed_executor`'s option list, so every entry here is offerable
-// — which is what keeps the seven agents no band names reachable (D14).
+// — which is what keeps the six agents no band names reachable (D14).
 //
 // Effort ranks `low(0) < medium(1) < high(2) < xhigh(3) < max(4)`. There is no
 // session tier at 0: an agent at low effort fits every tier of its own model,
 // which is correct — a low-effort child never exceeds its parent.
 const DIY_EXECUTORS = {
-  "orc-executor-haiku-4-5": { model: 1, effort: 1 },
-  "orc-executor-sonnet-4-6-med": { model: 2, effort: 1 },
+  "orc-executor-haiku-5-high": { model: 1, effort: 2 },
   "orc-executor-sonnet-4-6-high": { model: 2, effort: 2 },
   "orc-executor-sonnet-5-low": { model: 3, effort: 0 },
   "orc-executor-sonnet-5-med": { model: 3, effort: 1 },
@@ -5802,7 +5914,9 @@ function readDiyConfig(claudeDir) {
     if (!t || t.startsWith("#")) continue;
     const i = t.indexOf(":");
     if (i === -1) continue;
-    map[t.slice(0, i).trim()] = t.slice(i + 1).trim().replace(/^["']|["']$/g, "");
+    const k = t.slice(0, i).trim();
+    const v = t.slice(i + 1).trim().replace(/^["']|["']$/g, "");
+    map[k] = LEGACY_AGENT_KEYS.has(k) ? resolveLegacyAgents(v) : v;
   }
   return Object.keys(map).length ? map : null;
 }
@@ -5812,7 +5926,7 @@ function readDiyConfig(claudeDir) {
 // where the ledger is in hand — a validator that read the ledger would make
 // `orc diy set` fail on a machine that has not connected yet.
 function vDiyExecutor(v) {
-  const raw = String(v || "").trim();
+  const raw = resolveLegacyAgents(String(v || "").trim());
   if (!raw) return { value: "" };
   if (Object.prototype.hasOwnProperty.call(DIY_EXECUTORS, raw)) return { value: raw };
   if (/^extra:[^/]+\/[^/]+\/.+$/.test(raw)) return { value: raw };
@@ -5924,7 +6038,7 @@ function diyValidate(cfg) {
 // v2.1.0 — FIVE BANDS. The score is always a whole number, so the user's closed
 // ranges 0–20 · 21–30 · 31–40 · 41–89 · 90–100 map exactly to these half-open
 // rows. The bottom three are Sonnet 5 with effort as the dial; from 41 every
-// task runs on Opus 5.5. `haiku-4-5`, `sonnet-4-6-med` and `sonnet-4-6-high` are
+// task runs on Opus 5.5. `haiku-5-high` (v2.2.0: was `haiku-4-5` and `sonnet-4-6-med`) and `sonnet-4-6-high` are
 // named by no band now and STAY ON DISK (the same D14 rule as above).
 const DIY_SCORE_TABLE = [
   [0, 21, "orc-executor-sonnet-5-low"],
@@ -7213,30 +7327,60 @@ const unquote = (s) => String(s == null ? "" : s).trim().replace(/^["']|["']$/g,
 const plural = (n, word, many) => `${n} ${n === 1 ? word : many || word + "s"}`;
 
 // Minimal frontmatter reader — the exact subset schemas/wiki-doc.md uses:
-// scalars, inline arrays (`covers: [a, b]`), and one nested map level
-// (`covered_files:` + indented `path: hash`). No YAML dep, by house rule.
+// scalars, inline arrays (`covers: [a, b]`), one nested map level
+// (`covered_files:` + indented `path: hash`), and — v2.1.2 (F02) — YAML block
+// lists (`checklist:` then `- item` lines, indented or not), the shape the
+// boundary card reference shows. No YAML dep, by house rule.
+function stripComment(val) {
+  // ` # …` ends a value only OUTSIDE quotes.
+  let q = null;
+  for (let i = 0; i < val.length; i++) {
+    const ch = val[i];
+    if (q) { if (ch === q) q = null; continue; }
+    if (ch === '"' || ch === "'") { q = ch; continue; }
+    if (ch === "#" && i > 0 && /\s/.test(val[i - 1])) return val.slice(0, i).trim();
+  }
+  return val.trim();
+}
+function splitInline(body) {
+  // `a, "b, c", 'd'` → ["a", "b, c", "d"] — a comma inside quotes is text.
+  const out = [];
+  let cur = "";
+  let q = null;
+  for (const ch of body) {
+    if (q) { if (ch === q) q = null; cur += ch; continue; }
+    if (ch === '"' || ch === "'") { q = ch; cur += ch; continue; }
+    if (ch === ",") { out.push(cur); cur = ""; continue; }
+    cur += ch;
+  }
+  out.push(cur);
+  return out.map((s) => unquote(s)).filter(Boolean);
+}
 function parseDocHeader(text) {
-  const m = text.replace(/^/, "").match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  const m = text.replace(/^\uFEFF/, "").match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!m) return null;
   const h = {};
-  let mapKey = null;
+  let openKey = null; // a key with an empty value: a map or a list follows
   for (const raw of m[1].split(/\r?\n/)) {
     if (!raw.trim() || raw.trim().startsWith("#")) continue;
-    if (/^\s+\S/.test(raw) && mapKey) {
-      const kv = raw.trim().replace(/\s+#.*$/, "").match(/^(.+?):\s*(.*)$/);
-      if (kv) h[mapKey][unquote(kv[1])] = unquote(kv[2]);
+    if (openKey && /^\s*-(\s|$)/.test(raw)) {
+      if (!Array.isArray(h[openKey])) h[openKey] = []; // the first `- ` makes it a list
+      const v = unquote(stripComment(raw.replace(/^\s*-\s*/, "")));
+      if (v) h[openKey].push(v);
+      continue;
+    }
+    if (/^\s+\S/.test(raw) && openKey && !Array.isArray(h[openKey])) {
+      const kv = stripComment(raw.trim()).match(/^(.+?):\s*(.*)$/);
+      if (kv) h[openKey][unquote(kv[1])] = unquote(kv[2]);
       continue;
     }
     const kv = raw.match(/^([A-Za-z0-9_]+):\s*(.*)$/);
     if (!kv) continue;
-    mapKey = null;
+    openKey = null;
     const key = kv[1];
-    const val = kv[2].replace(/\s+#.*$/, "").trim();
-    if (val === "") { h[key] = {}; mapKey = key; continue; }
-    if (val.startsWith("[")) {
-      h[key] = val.replace(/^\[|\]$/g, "").split(",").map((s) => unquote(s)).filter(Boolean);
-      continue;
-    }
+    const val = stripComment(kv[2]);
+    if (val === "") { h[key] = {}; openKey = key; continue; }
+    if (val.startsWith("[")) { h[key] = splitInline(val.replace(/^\[|\]$/g, "")); continue; }
     h[key] = unquote(val);
   }
   return h;
@@ -9360,7 +9504,7 @@ function graphMeasured(claudeDir, root, opts) {
     } catch (_) {}
     const used = (text.match(/graph_used/g) || []).length;
     const none = (text.match(/graph_used[^\n]*none/g) || []).length;
-    groups[m[1] === "off" ? "off" : "on"].push({ name: t.name, lane: t.lane, start: meta.start, end: meta.end, hints, graph_used: used, graph_used_none: none });
+    groups[m[1] === "off" || m[1] === "semi" ? "off" : "on"].push({ name: t.name, lane: t.lane, start: meta.start, end: meta.end, hints, graph_used: used, graph_used_none: none });
   }
 
   const corpus = readToolCorpus(root);
@@ -9427,12 +9571,25 @@ function gainRowFor(sub, Q, model, operands, r, ms, forSlice) {
   }
   const base = { cmd: sub, targets: operands.slice(0, 5), gen, ms, paid };
 
+  // v2.2.0 (T6): the PACK — paid is the pack file the executor reads.
+  if (sub === "ctx" && forSlice && r.pack) {
+    const p = r.pack;
+    return { ...base, cmd: "pack", paid: { card: p.tokens, source: 0, hints: 0 }, ...K.packCost(model, p.refs || [], (r.files || []).filter((rel) => (Number((model.byFile[rel] || {}).lines) || 0) > 150), p.tokens) };
+  }
+  // v2.2.0 (R6): the ANCHORS — paid is the anchor block; avoided low is 0.
+  if (sub === "ctx" && r.anchors) {
+    const c = K.impactCost(model, r.anchors.refs || [], 1, 0, []);
+    return { ...base, cmd: "anchors", ...c, paid: { card: r.anchors.tokens, source: 0, hints: 0 }, avoided: { ...c.avoided, low: 0 } };
+  }
   if (sub === "impact" || (sub === "ctx" && forSlice)) {
     const files = sub === "impact" ? r.files || [] : r.files || [];
     const callerFiles = sub === "impact" ? (r.callers || []).map((c) => c.file) : (r.blocks || []).flatMap((b) => (b.callers || []).map((c) => c.file));
     const symbols = sub === "impact" ? r.symbols || 1 : (r.blocks || []).reduce((a, b) => a + (b.total_callers || 0), 0) || 1;
     const hits = files.reduce((a, rel) => a + ((model.byFile[rel] || {}).symbols || []).reduce((n, x) => n + (x.kind === "module" ? 0 : Q.nameHits(model, x.name)), 0), 0);
     const c = K.impactCost(model, files, symbols, hits, callerFiles);
+    // v2.2.0 (G-08): an executor reads its declared files whole either way, so
+    // an outside view done well saved nothing — `low` is 0.
+    if (forSlice) c.avoided = { ...c.avoided, low: 0 };
     return { ...base, cmd: forSlice ? "for-slice" : "impact", ...c };
   }
   // D4 (v1.8.2 W7): the map's targets are its FOCUS, and what it replaced is
@@ -9513,20 +9670,44 @@ function graphGainAppend(claudeDir, row) {
 //      `ctx`, whose rows are three scalars each).
 // Every drop leaves its COUNT behind, at the level it was dropped from, except
 // where the answer already carries that count under another name.
+// v2.2.0 (G-19): the reads whose every answer — ok, empty, declined or failed —
+// leaves one ledger row with its outcome.
+const GRAPH_READ_SUBS = new Set(["ctx", "impact", "path", "map", "changes", "cochange", "coverage"]);
 const GRAPH_BRIEF_DROP = new Set(["callers", "calls", "effects", "symbols", "imports", "importers", "blocks", "names", "rows", "chain", "waiting"]);
 const GRAPH_BRIEF_KEEP = new Set(["nearest", "candidates", "cards"]);
 // V2/V3 answers that ARE the answer: `complexity` and `facts` are ten rows at
 // most, and they are the whole reason the call was made. They pass through
 // whole, never walked.
 const GRAPH_BRIEF_WHOLE = new Set(["complexity", "facts"]);
-const GRAPH_BRIEF_NO_COUNT = { impact: ["callers"], map: ["files"], changes: ["symbols"] };
+const GRAPH_BRIEF_NO_COUNT = { impact: ["callers"], map: ["files"], changes: ["symbols"], ctx: ["tests_via"] };
+
+// v2.2.0 (R7): a brief map answer keeps only these keys; every list is counted.
+const GRAPH_BRIEF_MAP_KEEP = new Set(["ok", "state", "line", "trace", "generation", "card", "counts"]);
 
 function briefOf(sub, obj) {
+  if (sub === "map" && obj && typeof obj === "object") {
+    const out = {};
+    const counts = { ...((obj.counts && typeof obj.counts === "object") ? obj.counts : {}) };
+    for (const [k, v] of Object.entries(obj)) {
+      if (GRAPH_BRIEF_MAP_KEEP.has(k)) { if (k !== "counts") out[k] = v; continue; }
+      if (Array.isArray(v)) counts[k] = v.length;
+    }
+    if (Object.keys(counts).length) out.counts = counts;
+    return out;
+  }
   const noCount = new Set(GRAPH_BRIEF_NO_COUNT[sub] || []);
   const walk = (o) => {
     const out = {};
     const counts = {};
     for (const [k, v] of Object.entries(o)) {
+      // v2.2.0 (T6-b): a map's `focus` list (every focused file) was the bulk
+      // of a 10 KB brief answer. It is counted, and any other string list in a
+      // map answer is cut to 12 with its count.
+      if (sub === "map" && o === obj && Array.isArray(v) && (k === "focus" || (v.length > 12 && typeof v[0] === "string"))) {
+        counts[k] = v.length;
+        if (k !== "focus") out[k] = v.slice(0, 12);
+        continue;
+      }
       if (Array.isArray(v)) {
         const rows = GRAPH_BRIEF_DROP.has(k) || (!GRAPH_BRIEF_KEEP.has(k) && v.length > 0 && v[0] !== null && typeof v[0] === "object");
         if (!rows) out[k] = v;
@@ -9544,15 +9725,29 @@ function briefOf(sub, obj) {
     if (Object.keys(counts).length) out.counts = { ...(out.counts || {}), ...counts };
     return out;
   };
-  return walk(obj);
+  const out = walk(obj);
+  // R11: a FULL coverage verdict is one word in a brief answer — the card row
+  // already says how many files. A partial one keeps its gap list.
+  if (sub === "ctx" && out.coverage && out.coverage.verdict === "full") out.coverage = "full";
+  return out;
+}
+
+// v2.2.0 (T6-a): write the PACK atomically, the folder created. Relative to
+// the repository root; overwritten every call.
+function writeGraphPack(root, rel, text) {
+  const G = require("./graph.js");
+  const abs = path.resolve(root, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  G.atomicWrite(abs, text);
+  return abs;
 }
 
 function graphCmd() {
   const usage =
     "Usage: orc graph status [--heal] | update [--notes-pending --files <a,b>] | gc | audit [--top=N]\n" +
-    "       orc graph ctx <symbol|file[:line]>… [--source [N]] [--callers-source] | ctx --for-slice <file…> | impact <file…> | path <from> <to>\n" +
+    "       orc graph ctx <symbol|file[:line]>… [--source [N]] [--callers-source] | ctx --for-slice <file…> [--focus=<w,…>] [--refs=<file,…>] [--anchors] [--pack=<path>] [--pack-budget=N] | impact <file…> | path <from> <to>\n" +
     "       orc graph coverage <file…> | changes [--base <ref>] [--files=<a,b>] | cochange <file>\n" +
-    "       orc graph map [--focus <file|name,…>] [--budget N]\n" +
+    "       orc graph map [--focus=<file|name|word,…>] [--budget N]\n" +
     "       orc graph gain [--run <name>] [--since 7d] [--history [--limit 40]] [--measured] [--reset --yes]\n" +
     "       orc graph notes pending --files <a,b> [--cap 40] [--min 5] [--with-source] | notes apply <file|->\n" +
     "       [--if-enabled] [--depth N] [--budget TOKENS] [--format prose|tree] [--offset N] [--json] [--brief] [--dir <path>]\n" +
@@ -9604,7 +9799,14 @@ function graphCmd() {
   };
   const ovr = readOverride(claudeDir).map;
   const cfg = (k) => (Object.prototype.hasOwnProperty.call(ovr, k) ? ovr[k] : metaFor(k).def);
-  const enabled = String(cfg("code_graph")) === "on";
+  // v2.2.0: `code_graph` is off | semi | on. `semi` keeps the graph BUILT and
+  // CURRENT (status --heal, update, the SubagentStop hook) but no lane READS it:
+  // every gated read answers exit 3 exactly as `off` does. A person who types a
+  // read WITHOUT --if-enabled still gets an answer from the index.
+  const graphMode = String(cfg("code_graph")).toLowerCase();
+  const enabled = graphMode === "on";
+  const maintained = enabled || graphMode === "semi";
+  const isSemi = graphMode === "semi";
   // v1.8.2 W2 (G8): the extra globs the map must never index. One string,
   // split here; the engine takes the list.
   const ignore = String(cfg("code_graph_ignore") || "")
@@ -9618,6 +9820,8 @@ function graphCmd() {
   const notesPendingAnswer = (gated) => {
     const N = require("./graph-notes.js");
     const notesMode = String(cfg("code_graph_notes"));
+    if (gated && isSemi)
+      return { answer: { ok: true, state: "semi", mode: "semi", enabled: false, notes: notesMode, exit: 3 }, line: "graph: semi (kept current; lanes do not read it)", trace: "GRAPH-NOTES off :: mode=semi" };
     if (gated && (!enabled || notesMode === "off"))
       return { answer: { ok: true, state: "off", enabled, notes: notesMode, exit: 3 }, line: enabled ? "graph notes: off" : "graph: off", trace: "GRAPH-NOTES off" };
     // `--at wave|end` names the CALL SITE. A batch the configured mode places at
@@ -9696,6 +9900,25 @@ function graphCmd() {
     }
     const full = { ...obj, ...(line && jsonLine ? { line } : {}), ...(trace ? { trace } : {}) };
     const payload = asJson && briefOn ? briefOf(sub, full) : full;
+    // v2.2.0 (G-19): every READ gets a row with its OUTCOME — a declined or
+    // failed read paid for its line too, and an empty answer is not a saving.
+    if (GRAPH_READ_SUBS.has(sub) && (exit === 0 || exit === 1 || exit === 4)) {
+      const empty =
+        exit === 0 &&
+        ((Array.isArray(obj.rows) && !obj.rows.length) || (sub === "changes" && Array.isArray(obj.symbols) && !obj.symbols.length) || (!obj.card && !line));
+      const outcome = exit === 4 ? "declined" : exit === 1 ? "error" : empty ? "empty" : "ok";
+      if (!gainRow) {
+        try {
+          const K = require("./graph-gain.js");
+          const cmd = sub === "ctx" && args.includes("--for-slice") ? (eqFlag("--pack") ? "pack" : args.includes("--anchors") ? "anchors" : "for-slice") : sub;
+          gainRow = { cmd, targets: positionals().slice(2, 7), gen: obj.generation || null, ms: 0, paid: { card: K.tok(obj.card || line || ""), source: 0, hints: 0 }, avoided: { low: 0, high: 0, calls_low: 0, calls_high: 0 }, basis: { files: [], grep_hits: 0 } };
+        } catch (_) {}
+      }
+      if (gainRow) {
+        gainRow.outcome = outcome;
+        gainRow.exit = exit;
+      }
+    }
     if (gainRow) {
       try {
         const K = require("./graph-gain.js");
@@ -9711,19 +9934,27 @@ function graphCmd() {
     process.exit(exit);
   };
 
+  // The --if-enabled exit-3 answer of every gated READ: off, or semi.
+  const offGate = (verb) => {
+    const V = String(verb || "").toUpperCase();
+    return isSemi
+      ? finish({ ok: true, enabled: false, state: "semi", mode: "semi", exit: 3 }, "graph: semi (kept current; lanes do not read it)", `GRAPH-${V} off :: mode=semi`)
+      : finish({ ok: true, enabled: false, state: "off", exit: 3 }, "graph: off");
+  };
+
   if (sub === "status") {
-    let r = G.graphStatus(claudeDir, root, { enabled, ignore });
+    let r = G.graphStatus(claudeDir, root, { enabled: maintained, ignore });
     const autoUpdate = String(cfg("code_graph_auto_update")) !== "false";
     // `--heal` (W9): consult AND build in ONE call. A lane that had to run
     // status, read the exit code and then run update skipped the second step.
     let healed = null;
-    if (flag("--heal") === true && enabled && autoUpdate && (r.state === "none" || r.state === "drifted")) {
-      const u = G.graphUpdate(claudeDir, root, { enabled, ifEnabled: true, ignore });
+    if (flag("--heal") === true && maintained && autoUpdate && (r.state === "none" || r.state === "drifted")) {
+      const u = G.graphUpdate(claudeDir, root, { enabled: maintained, ifEnabled: true, ignore });
       healed =
         u.exit === 0
           ? { state: u.state, added: u.added, changed: u.changed, deleted: u.deleted, parsed: u.parsed, reused: u.reused, engine_upgrade: u.engine_upgrade, ms: u.ms }
           : { state: u.state, reason: u.reason };
-      if (u.exit === 0) r = G.graphStatus(claudeDir, root, { enabled, ignore });
+      if (u.exit === 0) r = G.graphStatus(claudeDir, root, { enabled: maintained, ignore });
     }
     // What the lane does NEXT depends on these two, and the lane reads no key.
     r.auto_update = autoUpdate;
@@ -9736,7 +9967,7 @@ function graphCmd() {
     // obeys — the index did not change, so `generation` and `gen_id` do not.
     const SIGD = require("./graph-signals.js");
     let meta = metaNow();
-    if (flag("--heal") === true && enabled && meta && !meta.density && r.exists) {
+    if (flag("--heal") === true && maintained && meta && !meta.density && r.exists) {
       const capMs = Number(cfg("code_graph_heal_ms")) || 0;
       if (!capMs || !meta.update_ms || meta.update_ms <= capMs) {
         try {
@@ -9786,6 +10017,19 @@ function graphCmd() {
             : `graph: ${plural(moved, "file")} changed outside ORC → updated (${healed.ms} ms) — ${size}`;
     } else if (healed) line += ` · could not heal: ${healed.reason}`;
     if (densityText && ["fresh", "drifted", "built", "updated"].includes(consult)) line += densityText;
+    // semi: built and healed above exactly as `on`, then the lane is told OFF
+    // (exit 3) so it reads nothing. Without --if-enabled the person sees the state.
+    if (isSemi && flag("--if-enabled") === true) {
+      r.index_state = consult;
+      r.state = "semi";
+      r.mode = "semi";
+      r.exit = 3;
+      return finish(
+        r,
+        `graph: semi — kept current (${plural(r.files || 0, "file")} · ${plural(r.symbols || 0, "symbol")}); lanes do not read it`,
+        `GRAPH-CONSULT semi :: files=${r.files || 0} symbols=${r.symbols || 0} gen=${r.generation || 0}`
+      );
+    }
     return finish(
       r,
       line,
@@ -9798,7 +10042,7 @@ function graphCmd() {
 
   if (sub === "update") {
     const r = G.graphUpdate(claudeDir, root, {
-      enabled,
+      enabled: maintained,
       ifEnabled: flag("--if-enabled") === true,
       ignore,
       say: asJson ? null : (s) => console.log(s),
@@ -9817,7 +10061,7 @@ function graphCmd() {
         `graph: ${verb} — ${plural(r.files, "file")} (${r.parsed} parsed, ${r.reused} reused, ${r.deleted} deleted` +
         `${r.skipped ? `, ${r.skipped} skipped` : ""}) · ${r.ms} ms`;
     }
-    if (r.exit === 0 && !enabled) {
+    if (r.exit === 0 && !maintained) {
       line += "\n  note: code_graph is off — lanes will not read this graph (orc config set code_graph on)";
     }
     const trace =
@@ -9870,15 +10114,17 @@ function graphCmd() {
   // the lock, the read answers from the old generation — and every touched card
   // already says `CHANGED since index` for itself.
   const healOnRead = (paths) => {
-    if (!enabled) return null;
+    if (!maintained) return null;
     const autoUpdate = String(cfg("code_graph_auto_update")) !== "false";
     const capRaw = Number(cfg("code_graph_heal_ms"));
     const cap = Number.isFinite(capRaw) ? capRaw : 1500;
     if (!autoUpdate || cap <= 0) return null;
     const meta = metaNow();
     if (!meta) return null; // no graph at all — `update` is the answer, not a heal
+    // v2.2.0 (G-13): decide `moved` FIRST. Nothing moved is no line at all —
+    // an over-cap store that is current had nothing to heal. A missing
+    // `update_ms` (a cold build writes `build_ms`) counts as under the cap.
     const last = Number(meta.update_ms) || 0;
-    if (last > cap) return { state: "skipped", reason: "over-cap", last_ms: last, cap_ms: cap };
 
     let moved = null;
     try {
@@ -9903,8 +10149,9 @@ function graphCmd() {
       } catch (_) {}
     }
     if (!moved) return null;
+    if (last > cap) return { state: "skipped", reason: "over-cap", trigger: moved, last_ms: last, cap_ms: cap };
 
-    const u = G.graphUpdate(claudeDir, root, { enabled, ifEnabled: true, ignore });
+    const u = G.graphUpdate(claudeDir, root, { enabled: maintained, ifEnabled: true, ignore });
     if (u.exit !== 0) return { state: "skipped", reason: u.reason || u.state, trigger: moved };
     return { state: u.state, trigger: moved, added: u.added, changed: u.changed, deleted: u.deleted, generation: u.generation, ms: u.ms };
   };
@@ -9913,7 +10160,7 @@ function graphCmd() {
   const asPaths = (list) => list.map((x) => String(x).split("\\").join("/").replace(/^\.\//, "").replace(/:\d+$/, ""));
 
   if (sub === "coverage") {
-    if (!enabled && flag("--if-enabled") === true) return finish({ ok: true, enabled: false, state: "off", exit: 3 }, "graph: off");
+    if (!enabled && flag("--if-enabled") === true) return offGate(sub);
     const VALUE_FLAGS = new Set(["--dir"]);
     const plain = [];
     for (let i = 0; i < args.length; i++) {
@@ -9936,7 +10183,7 @@ function graphCmd() {
           ? `partial ${(x.ranges || []).map((g) => `${g[0]}-${g[1]}`).join(",")}`
           : x.coverage;
     const line =
-      `graph coverage (gen ${r.generation}) — ${plural(r.gaps, "gap")} in ${plural(r.rows.length, "path")}\n` +
+      `graph parse coverage (gen ${r.generation}) — ${plural(r.gaps, "gap")} in ${plural(r.rows.length, "path")}\n` +
       r.rows.map((x) => `  ${x.path}  ${LABEL(x)}${x.changed_since_index && x.changed_since_index !== "current" ? `  [${x.changed_since_index} since index]` : ""}`).join("\n") +
       "\n  no recorded gap is not proof of completeness — the source is ground truth";
     return finish(r, line, `GRAPH-COVERAGE ${r.gaps ? "gaps" : "clean"} :: paths=${r.rows.length} gaps=${r.gaps} gen=${r.generation}`);
@@ -9944,7 +10191,7 @@ function graphCmd() {
 
   // ── E7: the cheap signals ──────────────────────────────────────────────────
   if (sub === "changes" || sub === "cochange") {
-    if (!enabled && flag("--if-enabled") === true) return finish({ ok: true, enabled: false, state: "off", exit: 3 }, "graph: off");
+    if (!enabled && flag("--if-enabled") === true) return offGate(sub);
     const VALUE_FLAGS = new Set(["--dir", "--base"]);
     const plain = [];
     for (let i = 0; i < args.length; i++) {
@@ -9980,9 +10227,18 @@ function graphCmd() {
           const Q = require("./graph-query.js");
           const m = Q.loadModel(claudeDir, root);
           if (m) {
-            const hits = r.symbols.reduce((a, x) => a + Q.nameHits(m, x.qname), 0);
-            const callerFiles = r.symbols.flatMap((x) => (x.callers || []).map((cc) => cc.file || cc));
-            gainRow = { cmd: "changes", targets: [r.base], gen: r.generation, ms: r.ms || 0, paid: { card: K.tok(line), source: 0, hints: 0 }, ...K.changesCost(m, r.symbols.length, hits, callerFiles) };
+            // v2.2.0 (G-08): only the symbols a file OUTSIDE the diff calls are
+            // priced, and a second read of the same diff in the same run adds 0.
+            const priced = K.changesPriced(m, r.symbols, r.files, (x) => Q.nameHits(m, x.qname));
+            const key = require("crypto").createHash("sha1").update(K.changesKey(r.symbols.map((x) => ({ id: x.id, body_hash: (m.symbols.get(x.id) || {}).body_hash })))).digest("hex").slice(0, 16);
+            let run = null;
+            try {
+              run = fs.readFileSync(path.join(resolveLogDir(claudeDir), ".current"), "utf8").trim() || null;
+            } catch (_) {}
+            const repeat = K.changesSeen(claudeDir, run, key);
+            const { priced: _n, ...cost } = priced;
+            if (repeat) cost.avoided = { low: 0, high: 0, calls_low: 0, calls_high: 0 };
+            gainRow = { cmd: "changes", targets: [r.base], gen: r.generation, ms: r.ms || 0, key, ...(repeat ? { repeat: true } : {}), paid: { card: K.tok(line), source: 0, hints: 0 }, ...cost };
           }
         } catch (_) {}
       }
@@ -9990,6 +10246,17 @@ function graphCmd() {
     }
     const file = plain[2];
     if (!file) return finish({ ok: false, reason: "missing-operand", usage, exit: 1 }, usage);
+    // v2.2.0 (G-15): under 20 commits there is no history to count — an
+    // ANSWER (exit 4), given at once, before any `git log` is paid for.
+    try {
+      const rc = spawnSync("git", ["rev-list", "--count", "HEAD"], { cwd: root, encoding: "utf8" });
+      const n = rc.status === 0 ? Number(String(rc.stdout).trim()) : NaN;
+      if (Number.isFinite(n) && n < 20)
+        return finish(
+          { ok: true, state: "none", reason: "short-history", file: asPaths([file])[0], history: n, rows: [], exit: 4 },
+          `cochange: history too short (${plural(n, "commit")}) — no answer`,
+          `GRAPH-COCHANGE none :: history=${n}`);
+    } catch (_) {}
     const r = SIG.graphCochange(claudeDir, root, { file });
     if (r.exit === 1) return finish(r, r.reason === "missing-operand" ? usage : `graph: unavailable — ${r.reason}`);
     const line = r.rows.length
@@ -10006,7 +10273,7 @@ function graphCmd() {
   // `lanes: []`). It reads the index, the file table and the first lines of
   // each empty file. It never parses, never writes, and costs no model tokens.
   if (sub === "audit") {
-    if (!enabled && flag("--if-enabled") === true) return finish({ ok: true, enabled: false, state: "off", exit: 3 }, "graph: off");
+    if (!enabled && flag("--if-enabled") === true) return offGate(sub);
     const A = require("./graph-audit.js");
     const r = A.audit(claudeDir, root, { top: eqFlag("--top") });
     if (r.exit === 1) return finish(r, "graph: none — no index yet (run: orc graph update)");
@@ -10072,7 +10339,7 @@ function graphCmd() {
   // has the runs to say so — what actually happened. Three different kinds of
   // knowing, never mixed into one number.
   if (sub === "gain") {
-    if (!enabled && flag("--if-enabled") === true) return finish({ ok: true, enabled: false, state: "off", exit: 3 }, "graph: off");
+    if (!enabled && flag("--if-enabled") === true) return offGate(sub);
     const K = require("./graph-gain.js");
     const U = require("./ui.js");
     const rng = (a, b) => (a === b ? kTok(a) : `${kTok(a)} – ${kTok(b)}`);
@@ -10150,6 +10417,7 @@ function graphCmd() {
       `\n  avoided    ~${rng(r.avoided.low, r.avoided.high)} tokens   (estimate — the read ladder done well … done badly)` +
       `\n  net        ~${rng(r.net.low, r.net.high)} tokens · ~${r.calls.low} – ${r.calls.high} tool calls` +
       (byCmd ? `\n  by command ${byCmd}` : "") +
+      `\n  outcomes  ok ${(r.outcomes || {}).ok || 0} · empty ${(r.outcomes || {}).empty || 0} · declined ${(r.outcomes || {}).declined || 0} · error ${(r.outcomes || {}).error || 0}` +
       `\n  hints      ${r.hints.injected} injected · ${r.hints.read_notes} read notes · ${r.hints.updates} hook updates` +
       // R2 (v1.9.1): the reads the `on,read` hint would have named ranges for.
       // A COUNT, printed only when there is one — it is the data DE-8 waits
@@ -10174,7 +10442,7 @@ function graphCmd() {
   // files OR names, comma-separated or as bare words, so a planner can hand it
   // whatever the request happened to mention.
   if (sub === "map") {
-    if (!enabled && flag("--if-enabled") === true) return finish({ ok: true, enabled: false, state: "off", exit: 3 }, "graph: off");
+    if (!enabled && flag("--if-enabled") === true) return offGate(sub);
     const VALUE_FLAGS = new Set(["--dir", "--budget", "--focus"]);
     const plain = [];
     for (let i = 0; i < args.length; i++) {
@@ -10184,8 +10452,10 @@ function graphCmd() {
       }
       if (!String(args[i]).startsWith("--")) plain.push(args[i]);
     }
+    // B1: `--focus=a,b` is the lane form; the old space form still works.
+    const focusRaw = eqFlag("--focus") !== undefined ? eqFlag("--focus") : flag("--focus") === true ? "" : flag("--focus");
     const focus = [
-      ...String(flag("--focus") || "")
+      ...String(focusRaw || "")
         .split(",")
         .map((x) => x.trim())
         .filter(Boolean),
@@ -10202,13 +10472,14 @@ function graphCmd() {
     // The caveat is INSIDE the card (`graph-query.js`), so the `--json` reader
     // gets it too. Appending it here would have shown it only to a human.
     const line = r.card;
-    const trace = `GRAPH-MAP ${focus.length ? "focused" : "repo"} :: files=${r.shown}/${r.total_files}${focus.length ? ` focus=${r.focus.join(",")}` : ""} gen=${r.generation}`;
+    // v2.1.2 (F05): `focused` means the focus RESOLVED to files, never that a flag was passed.
+    const trace = `GRAPH-MAP ${r.focus.length ? "focused" : "repo"} :: files=${r.shown}/${r.total_files}${r.focus.length ? ` focus=${r.focus.slice(0, 8).join(",")}${r.focus.length > 8 ? `,+${r.focus.length - 8}` : ""}` : ""} gen=${r.generation}`;
     const gainRow = r.exit === 0 ? gainRowFor("map", Q, model, focus, r, Date.now() - t0, false) : null;
     return finish(r, line, trace, false, gainRow);
   }
 
   if (sub === "ctx" || sub === "impact" || sub === "path") {
-    if (!enabled && flag("--if-enabled") === true) return finish({ ok: true, enabled: false, state: "off", exit: 3 }, "graph: off");
+    if (!enabled && flag("--if-enabled") === true) return offGate(sub);
     // Positionals after the subcommand, with every value-flag's value removed.
     // D1: `--source` takes an OPTIONAL count, so it only swallows the next word
     // when that word is a number — otherwise `ctx --source handler` would lose
@@ -10224,7 +10495,8 @@ function graphCmd() {
       }
       if (!String(args[i]).startsWith("--")) plain.push(args[i]);
     }
-    const operands = plain.slice(2);
+    // v2.2.0 (R10): `--for-slice a.js,b.vue` is split like `--refs=` — a path never holds a comma.
+    const operands = plain.slice(2).flatMap((x) => String(x).split(",")).map((s) => s.trim()).filter(Boolean);
     const sourceLines = srcAt === -1 ? undefined : srcTakesValue ? Number(args[srcAt + 1]) : require("./graph-query.js").SOURCE_DEFAULT;
     // D2 is a SWITCH, so it is read from `args` — `flag()` would read the first
     // declared file as its value.
@@ -10249,7 +10521,9 @@ function graphCmd() {
     // heal that was skipped changed nothing. Either way the generation it pins
     // itself to is the one on disk now.
     let fast = null;
-    if (sub === "ctx" && !forSlice && operands.length === 1) {
+    // R11: `ctx <symbol> --anchors` builds the slice anchors from the WHOLE
+    // model, so it never takes the one-shard path.
+    if (sub === "ctx" && !forSlice && operands.length === 1 && !args.includes("--anchors")) {
       try {
         fast = require("./graph-shard.js").fastModel(claudeDir, root, operands[0], { callersSource });
       } catch (_) {
@@ -10297,6 +10571,50 @@ function graphCmd() {
         // hint never pays for the same name twice (D3).
         r = Q.forSlice(model, operands, opts);
         if (r.ok) noteGraphNamesSeen(claudeDir, r.names);
+        // v2.2.0 (T6-a): `--pack=<path>` writes the executor PACK — the outside
+        // view, the reference outlines, the quoted ranges and the tests, in ONE
+        // file — and the answer becomes the ONE line that points at it.
+        const packPath = eqFlag("--pack");
+        if (packPath) {
+          const list = (x) => String(x || "").split(",").map((s) => s.trim()).filter(Boolean);
+          if (!r.ok && r.state === "not-found")
+            r = { ok: true, state: "found", view: "for-slice", format: "tree", files: [], missing: r.missing || operands, skipped: [], blocks: [], names: [], budget: { used: 0, max: Number(opts.budget) || 0 }, card: "", exit: 0 };
+          const p = Q.buildPack(claudeDir, model, {
+            declared: operands,
+            refs: list(eqFlag("--refs")),
+            focus: list(eqFlag("--focus")),
+            budget: eqFlag("--pack-budget"),
+            outlineBudget: eqFlag("--pack-outline"),
+            sliceCard: r.files && r.files.length ? r.card : null,
+          });
+          if (!p.ok) r = p;
+          else {
+            const shown = String(packPath).split("\\").join("/");
+            writeGraphPack(root, packPath, p.text);
+            const gen = (model.meta && model.meta.generation) || 0;
+            r.pack = { path: shown, files: p.files, refs: p.refs, excerpts: p.excerpts, tokens: p.tokens, cut: p.cut };
+            r.card = `graph pack → ${shown} · ${p.files} files · ${p.refs.length} refs · ${p.excerpts} quoted ranges · ~${p.tokens} tokens · gen ${gen} — the executor reads it first`;
+            r.pack_trace = `GRAPH-CONSULT pack :: files=${p.files} refs=${p.refs.length} excerpts=${p.excerpts} tokens=${p.tokens} gen=${gen}`;
+          }
+        }
+        // v2.2.0 (R6): `--anchors` — no file. Up to 12 `path:a-b` ranges the
+        // dig found and ONE shell command that prints them all; the card is the
+        // anchor block the slice carries INLINE as `graph_anchors`.
+        if (!packPath && args.includes("--anchors")) {
+          const list = (x) => String(x || "").split(",").map((s) => s.trim()).filter(Boolean);
+          if (!r.ok && r.state === "not-found")
+            r = { ok: true, state: "found", view: "for-slice", format: "tree", files: [], missing: r.missing || operands, skipped: [], blocks: [], names: [], budget: { used: 0, max: Number(opts.budget) || 0 }, card: "", exit: 0 };
+          const a = Q.buildAnchors(claudeDir, model, { declared: operands, refs: list(eqFlag("--refs")), focus: list(eqFlag("--focus")) });
+          if (!a.ok) r = a;
+          else {
+            r.anchors = { lines: a.lines, read_cmd: a.read_cmd, code: a.code, tokens: a.tokens, read_tokens: a.read_tokens, ranges: a.ranges, files: a.files, refs: a.refs, refs_missing: a.refs_missing, missing: r.missing || [] };
+            r.card = a.card;
+            const miss = r.missing || [];
+            const rmiss = a.refs_missing || [];
+            r.anchors_line = `graph anchors: ${a.ranges} ranges in ${a.files} files · ~${a.read_tokens} tokens to read · gen ${a.gen}${a.code ? " · code inline" : ""}${miss.length ? ` · not found: ${miss[0]}${miss.length > 1 ? ` (+${miss.length - 1} more)` : ""}` : ""}${rmiss.length ? ` · ref not found: ${rmiss[0]}` : ""}`;
+            r.pack_trace = `GRAPH-CONSULT anchors :: ranges=${a.ranges} files=${a.files} gen=${a.gen}`;
+          }
+        }
       } else if (operands.length === 1) {
         if (fast && fast.model) {
           try {
@@ -10317,6 +10635,21 @@ function graphCmd() {
         // is the only way to find out why.
         r.read = fast && fast.model ? "sharded" : "full";
         if (fast && !fast.model) r.read_fallback = fast.reason;
+        // R11 (v2.2.0): `ctx <symbol> --anchors` — ONE look-time call gives the
+        // card AND the slice anchors. Declared = the target file + the non-test
+        // caller files the card names (dedup, max 10); focus defaults to the
+        // target's name. Same shape as `--for-slice --anchors`.
+        if (r.ok && r.target && args.includes("--anchors")) {
+          const list = (x) => String(x || "").split(",").map((s) => s.trim()).filter(Boolean);
+          const declared = [...new Set([r.target.file, ...(r.callers || []).map((c) => c.file).filter((f) => !Q.TEST_FILE.test(f))])].slice(0, 10);
+          const focus = list(eqFlag("--focus"));
+          const a = Q.buildAnchors(claudeDir, model, { declared, refs: list(eqFlag("--refs")), focus: focus.length ? focus : [r.target.name || String(r.target.qname || "").split(".").pop()] });
+          if (a.ok) {
+            r.anchors = { lines: a.lines, read_cmd: a.read_cmd, code: a.code, tokens: a.tokens, read_tokens: a.read_tokens, ranges: a.ranges, files: a.files, refs: a.refs, refs_missing: a.refs_missing, missing: [] };
+            r.anchors_card = a.card;
+            r.anchors_count = a.ranges;
+          }
+        }
       }
       else {
         // Several targets, ONE call, ONE budget (W9): a slice builder that had to
@@ -10353,7 +10686,14 @@ function graphCmd() {
       if (operands.length < 2) return finish({ ok: false, reason: "missing-operand", usage, exit: 1 }, usage);
       r = Q.pathBetween(model, operands[0], operands[1]);
     }
-    let line = r.card;
+    let line = r.anchors_line || r.card;
+    if (r.anchors_line) delete r.anchors_line;
+    if (r.anchors_count !== undefined) {
+      const lines = String(line || "").split("\n");
+      lines[0] = `${lines[0]} · anchors ${r.anchors_count} ranges`;
+      line = lines.join("\n");
+      delete r.anchors_count;
+    }
     if (line && r.complexity) line = `${line}\n  ${r.complexity.line}`;
     if (!line && r.state === "not-found") {
       const near = (r.nearest || []).map((s) => `${s.qname} (${s.file}:${s.lines[0]})`);
@@ -10363,7 +10703,7 @@ function graphCmd() {
       if (sub === "path") line = "graph: path needs two known symbols — " + ((r.candidates || []).length ? `ambiguous: ${r.candidates.map((s) => `${s.qname} (${s.file})`).join(", ")}` : "one end was not found");
     }
     if (!line && r.state === "ambiguous-target")
-      line = `graph: "${r.query}" names ${r.candidates.length} symbols — pick one:\n` + r.candidates.map((s) => `  ${s.id}`).join("\n");
+      line = `graph: "${r.query}" names ${r.candidates.length} ${r.candidates[0] && !r.candidates[0].id ? "files" : "symbols"} — pick one:\n` + r.candidates.map((s) => `  ${s.id || s.file}`).join("\n");
     if (healed) r.healed = healed;
     // A heal is a real event and it gets ONE line above the card — a card that
     // silently answers from a different generation than the reader expected is
@@ -10383,6 +10723,8 @@ ${line || ""}`;
       cx
         ? `GRAPH-COMPLEXITY ${cx.verdict} :: files=${cx.numbers.files} callers=${cx.numbers.callers_outside} caller_files=${cx.numbers.caller_files_outside}` +
           ` maybe=${cx.numbers.maybe} tests=${cx.numbers.tests_reaching} risk=${cx.numbers.risk.length} cochange=${cx.numbers.cochange_missing.length} gen=${r.generation || (r.facts && r.facts.generation) || 0}`
+        : sub === "ctx" && r.exit === 0 && r.pack_trace
+        ? r.pack_trace
         : sub === "ctx" && r.exit === 0
         ? `GRAPH-CONSULT ${r.view === "for-slice" ? "slice" : "card"} :: targets=${(r.view === "for-slice" ? r.files : r.cards ? r.cards.filter((c) => c.state === "found").map((c) => c.query) : [operands[0]]).join(",")}` +
           (healed && healed.state && healed.state !== "skipped" ? ` healed=${healed.trigger}` : "")
@@ -10397,7 +10739,8 @@ ${line || ""}`;
         // argument to it.
       }
     }
-    return finish(r, line, trace, !r.card, gainRow);
+    if (r.pack_trace) delete r.pack_trace;
+    return finish(r, line, trace, !r.card || !!r.pack || !!r.anchors, gainRow);
   }
 
   if (asJson) emitJson({ ok: false, reason: "unknown-subcommand", usage }, 1);
@@ -10810,6 +11153,34 @@ function stackTemplate(claudeDir, slugArg) {
   );
 }
 
+// v2.1.2 F19 — what counts as a placeholder an author still has to fill.
+// NOT one: anything inside an HTML comment (the skeleton's own instructions say
+// `fill every <...> in`) or a fenced code block (a picked PR template lives
+// there, and the driver fills it per layer); a generic type (`Promise<Order>` —
+// the `<` follows a word character); a closing or self-closing tag; the inline
+// HTML a Markdown author writes on purpose. A one-character hole (`<n>`) IS
+// one, and so is a paragraph that is one placeholder from its first character
+// to its last (the skeleton's `## Decisions` body).
+const STACK_INLINE_TAGS = new Set(["a", "b", "br", "code", "del", "details", "div", "em", "hr", "i", "img", "kbd", "li", "ol", "p", "pre", "s", "span", "strong", "sub", "summary", "sup", "table", "td", "th", "tr", "u", "ul"]);
+function stackHoles(text) {
+  const src = String(text)
+    .replace(/\r\n/g, "\n")
+    .replace(/<!--[\s\S]*?-->/g, " ")
+    .replace(/^(`{3,}|~{3,})[^\n]*\n[\s\S]*?^\1[ \t]*$/gm, " ");
+  const holes = [];
+  for (const m of src.matchAll(/<([^<>\n]{1,120})>/g)) {
+    const inner = m[1];
+    if (m.index > 0 && /\w/.test(src[m.index - 1])) continue;
+    if (inner.startsWith("/") || inner.endsWith("/")) continue;
+    const tag = /^([a-z][a-z0-9]*)(?:\s[^<>]*)?$/.exec(inner);
+    if (tag && STACK_INLINE_TAGS.has(tag[1])) continue;
+    holes.push(m[0]);
+  }
+  for (const m of src.matchAll(/^<[^<>]*\n[^<>]*>[ \t]*$/gm))
+    holes.push(m[0].replace(/\s+/g, " ").slice(0, 60) + (m[0].length > 60 ? "…>" : ""));
+  return holes;
+}
+
 // Exit code IS the contract (same convention as `orc pattern status` /
 // `orc diy status`): 0 = READY, 1 = absent | unfilled. A driver branches on it
 // without parsing prose.
@@ -10821,7 +11192,7 @@ function stackProbe(claudeDir, slug) {
   if (!fs.existsSync(p.plan)) return { slug, ready: false, plan_path: p.plan, exists: false, problems: ["absent"] };
   const text = fs.readFileSync(p.plan, "utf8");
   const problems = [];
-  const holes = [...text.matchAll(/<[^<>\n]{2,60}>/g)].map((m) => m[0]);
+  const holes = stackHoles(text);
   if (holes.length)
     problems.push(`${plural(holes.length, "unfilled placeholder")} (e.g. ${[...new Set(holes)].slice(0, 5).join(" ")})`);
   const ticket = /^-\s*ticket:\s*(.+)$/m.exec(text);
@@ -10876,30 +11247,18 @@ function stackStatus(claudeDir, slugArg) {
     );
     process.exit(1);
   }
-  const text = fs.readFileSync(p.plan, "utf8");
-  const problems = [];
-  // Unfilled placeholders — the whole reason a hand-filled plan needs a probe.
-  const holes = [...text.matchAll(/<[^<>\n]{2,60}>/g)].map((m) => m[0]);
-  if (holes.length) {
-    const uniq = [...new Set(holes)].slice(0, 5);
-    problems.push(`${plural(holes.length, "unfilled placeholder")} (e.g. ${uniq.join(" ")})`);
-  }
-  const ticket = /^-\s*ticket:\s*(.+)$/m.exec(text);
-  if (!ticket || !ticket[1].trim()) problems.push("no ticket");
-  // Layer sections: `## Layer <n> — <title>` (the schema's own heading shape).
-  const layers = [...text.matchAll(/^##\s+Layer\s+\d+\b/gm)].length;
-  if (layers < 2) problems.push(`${layers} layer section(s) — a stack needs 2+`);
-  if (!/^##\s+Decisions\s*$/m.test(text)) problems.push("no `## Decisions` section");
-  if (problems.length) {
+  // v2.1.2 F19 — ONE engine: the human path renders the probe the JSON path emits.
+  const probe = stackProbe(claudeDir, slug);
+  if (probe.problems.length) {
     console.log(
       `✗ NOT READY — ${STACK_DIR}/${slug}/${STACK_PLAN_FILE}\n` +
-        problems.map((x) => "  - " + x).join("\n") +
+        probe.problems.map((x) => "  - " + x).join("\n") +
         "\n  Fill it in, or run `/orc-pr-setup` to have the layers planned for you."
     );
     process.exit(1);
   }
   console.log(
-    `✓ READY — ${STACK_DIR}/${slug}/${STACK_PLAN_FILE} (${plural(layers, "layer")}, ticket ${ticket[1].trim()})\n` +
+    `✓ READY — ${STACK_DIR}/${slug}/${STACK_PLAN_FILE} (${plural(probe.layers, "layer")}, ticket ${probe.ticket})\n` +
       "  Run `/orc-pr-driver` to build + submit the stack."
   );
 }
@@ -11950,6 +12309,33 @@ function resume() {
 //   exit 2  unknown    — cannot prove either way
 const INFLIGHT_STALE_MS = 6 * 60 * 60 * 1000;
 
+// v2.1.2 (F14, F20) — THE OPEN RUN, the one idea orc-trace.js, orc-read-gate.js
+// and orc-session-hook.js already share: `.current` names a trace, and the newer
+// of the trace's and the pointer's own mtime is younger than 6 hours. A pointer
+// older than that belongs to a run that ended without deleting it. `lane` is null
+// for the trace hook's own bootstrap name `run-<DDMMYY>-<HHMMSS>.txt`: no lane
+// registered that run. → { name, run, path, exists, lane, slug } | null
+function openRunPointer(claudeDir) {
+  const dir = resolveLogDir(claudeDir);
+  let name = null;
+  try {
+    name = fs.readFileSync(path.join(dir, ".current"), "utf8").trim() || null;
+  } catch (_) {}
+  if (!name) return null;
+  const file = path.join(dir, name);
+  const mt = (p) => {
+    try {
+      return fs.statSync(p).mtimeMs;
+    } catch (_) {
+      return 0;
+    }
+  };
+  const last = Math.max(mt(file), mt(path.join(dir, ".current")));
+  if (!last || Date.now() - last >= INFLIGHT_STALE_MS) return null;
+  const m = TRACE_NAME.exec(name);
+  return { name, run: name.replace(/\.txt$/, ""), path: file, exists: fs.existsSync(file), lane: m ? m[1] : null, slug: m ? m[2] : null };
+}
+
 function runInflightCmd(claudeDir) {
   const dir = resolveLogDir(claudeDir);
   const out = {
@@ -12624,11 +13010,31 @@ const MODEL_FAMILIES = ["opus", "sonnet", "haiku", "fable"];
 const EFFORT_WORDS = new Set(["low", "med", "medium", "high", "xhigh", "max"]);
 
 // `orc-executor-opus-4-8-high` → `claude-opus-4-8`. An agent's model lives in its
-// NAME by house rule (a model change is always a rename), so this needs no table.
+// NAME by house rule (a model change is always a rename) — EXCEPT a point
+// release inside one family, which kept the name on purpose (§4z.33 Opus 5.5,
+// §4z.39.1 Sonnet 5.5). v2.1.2 (F25): a SHIPPED agent answers with the `model:`
+// its own file pins, so `orc-executor-opus-5-low` is `claude-opus-5-5`. Any
+// other name falls back to the name rule.
+let PINNED_MODELS = null;
+function pinnedModels() {
+  if (PINNED_MODELS) return PINNED_MODELS;
+  PINNED_MODELS = {};
+  try {
+    const dir = path.join(TEMPLATES, "agents");
+    for (const f of fs.readdirSync(dir)) {
+      if (!f.endsWith(".md")) continue;
+      const m = /^model:\s*(\S+)\s*$/m.exec(fs.readFileSync(path.join(dir, f), "utf8"));
+      if (m) PINNED_MODELS[f.slice(0, -3)] = m[1];
+    }
+  } catch (_) {}
+  return PINNED_MODELS;
+}
 function modelOf(name) {
   if (!name) return null;
   const s = String(name);
   if (s.startsWith("claude-")) return s;
+  const pinned = pinnedModels()[s];
+  if (pinned) return pinned;
   const parts = s.split("-");
   const i = parts.findIndex((p) => MODEL_FAMILIES.includes(p));
   if (i === -1) return null;
@@ -12851,6 +13257,11 @@ function listTraces(claudeDir) {
 // with the same MODEL whose timestamp is nearest and not after it by more than
 // the group's own duration. A group nothing can claim counts into `unattributed`
 // — which is ALWAYS printed, never silently dropped.
+//
+// v2.1.2 F62 — a point release inside one family joins its family's DISPATCH
+// line: `expect=opus-5/low` (the agent's NAME token) claims a `claude-opus-5-5`
+// block. The names kept the family token on purpose (§4z.33, §4z.39.1).
+const sameModel = (got, want) => got === want || String(got).startsWith(want + "-");
 function joinRun(trace, groups) {
   const out = { rows: [], unattributed: [] };
   if (!trace || trace.start === null) return out;
@@ -12861,7 +13272,7 @@ function joinRun(trace, groups) {
     let best = null;
     for (const g of inWindow) {
       if (g.claimed) continue;
-      if (want && g.model && modelOf(g.model) !== want) continue;
+      if (want && g.model && !sameModel(modelOf(g.model), want)) continue;
       const dist = d.at === null ? 0 : Math.abs(g.start - d.at);
       if (!best || dist < best.dist) best = { g, dist };
     }
@@ -13135,17 +13546,17 @@ function parsePlanTasks(text) {
 // Fixed roles a run dispatches besides executors. Named, not guessed: the
 // forecast has to say WHICH roles it priced or the total is unfalsifiable.
 const LANE_FIXED_ROLES = {
-  orc: ["orc-system-analyst-opus-5-high", "orc-planner-opus-5-med", "orc-reviewer-opus-5-low", "orc-verifier-opus-5-med", "orc-trace-writer-haiku-4-5"],
-  ultra: ["orc-advisor-opus-5-xhigh", "orc-system-analyst-opus-5-high", "orc-planner-opus-5-med", "orc-judge-opus-5-xhigh", "orc-reviewer-opus-5-low", "orc-verifier-opus-5-med", "orc-trace-writer-haiku-4-5"],
-  mini: ["orc-analyze-mini-sonnet-5-high", "orc-planner-mini-sonnet-5-high", "orc-trace-writer-haiku-4-5"],
-  fast: ["orc-trace-writer-haiku-4-5"],
+  orc: ["orc-system-analyst-opus-5-high", "orc-planner-opus-5-med", "orc-reviewer-opus-5-low", "orc-verifier-opus-5-med", "orc-trace-writer-haiku-5-high"],
+  ultra: ["orc-advisor-opus-5-xhigh", "orc-system-analyst-opus-5-high", "orc-planner-opus-5-med", "orc-judge-opus-5-xhigh", "orc-reviewer-opus-5-low", "orc-verifier-opus-5-med", "orc-trace-writer-haiku-5-high"],
+  mini: ["orc-analyze-mini-sonnet-5-high", "orc-planner-mini-sonnet-5-high", "orc-trace-writer-haiku-5-high"],
+  fast: ["orc-trace-writer-haiku-5-high"],
 };
 const FORECAST_LANES = ["ultra", "orc", "mini", "fast"];
 const LANE_CMD = { orc: "/orc", ultra: "/orc-ultra", mini: "/orc-mini", fast: "/orc-fast" };
 // orc-mini and orc-fast dispatch ONE executor for the whole request — they do
 // not score per task. Rendering a per-band table for either would be a table the
 // lane never runs.
-const LANE_ONE_EXECUTOR = { mini: "orc-executor-sonnet-5-high", fast: "orc-executor-sonnet-4-6-high" };
+const LANE_ONE_EXECUTOR = { mini: "orc-executor-sonnet-5-high", fast: "orc-executor-sonnet-5-med" };
 
 function laneForecast(lane, tasks, rates, cfg, claudeDir) {
   const rows = [];
@@ -13176,16 +13587,37 @@ function laneForecast(lane, tasks, rates, cfg, claudeDir) {
     }
   }
 
+  // v2.1.2 F25 — every row is priced at the model THAT ROW runs on: a band at
+  // its agent's pinned model, a foreign band from its provider's own dated rate,
+  // a fixed role at its own model. One row with tokens and no rate makes the
+  // lane's dollars null — never an Opus figure for work Opus will not do.
+  const table = readPricingCache;
+  const usd = { p50: 0, p90: 0 };
+  let priceable = !!table;
+  const addUsd = (v50, v90, model, extra) => {
+    if (!v50) return;
+    const rate = extra ? foreignRate(table, extra.provider, extra.model) : rateFor(table, model);
+    if (!rate) {
+      priceable = false;
+      return;
+    }
+    const at = (v) => (v.input * rate.input + v.cache_write * rate.cache_write + v.cache_read * rate.cache_read + v.output * rate.output) / 1e6;
+    usd.p50 += at(v50);
+    usd.p90 += at(v90 || v50);
+  };
+
   for (const [band, g] of grouped) {
     const src = (rates && rates.bands && rates.bands[band]) || (g.agent && rates && rates.roles && rates.roles[g.agent]) || null;
     const samples = src ? src.samples : 0;
     if (!src || samples < minSamples) low++;
     const per50 = src ? src.p50 : null;
     const per90 = src ? src.p90 : null;
-    rows.push({ band, agent: g.agent, via: g.via || "claude", extra: g.extra || null, count: g.n, tasks: g.tasks, samples, p50: per50 ? mulVec(per50, g.n) : null, p90: per90 ? mulVec(per90, g.n) : null });
+    const model = g.extra ? null : modelOf(g.agent);
+    rows.push({ band, agent: g.agent, model, via: g.via || "claude", extra: g.extra || null, count: g.n, tasks: g.tasks, samples, p50: per50 ? mulVec(per50, g.n) : null, p90: per90 ? mulVec(per90, g.n) : null });
     if (per50) {
       Object.assign(p50, sumVec(p50, mulVec(per50, g.n)));
       Object.assign(p90, sumVec(p90, mulVec(per90 || per50, g.n)));
+      addUsd(mulVec(per50, g.n), mulVec(per90 || per50, g.n), model, g.extra);
     }
     // Context risk: the p90 PEAK prompt for this band against the model's
     // window. Forecast before the wave, not after compaction.
@@ -13202,15 +13634,16 @@ function laneForecast(lane, tasks, rates, cfg, claudeDir) {
     const src = rates && rates.roles && rates.roles[role];
     if (!src) {
       lowRoles++;
-      fixed.push({ role, samples: 0, p50: null });
+      fixed.push({ role, model: modelOf(role), samples: 0, p50: null });
       continue;
     }
-    fixed.push({ role, samples: src.samples, p50: src.p50, p90: src.p90 });
+    fixed.push({ role, model: modelOf(role), samples: src.samples, p50: src.p50, p90: src.p90 });
     Object.assign(p50, sumVec(p50, src.p50));
     Object.assign(p90, sumVec(p90, src.p90));
+    addUsd(src.p50, src.p90, modelOf(role), null);
   }
 
-  return { lane, cmd: LANE_CMD[lane], rows, fixed, p50, p90, low_confidence_bands: low, low_confidence_roles: lowRoles, context_risk: contextRisk };
+  return { lane, cmd: LANE_CMD[lane], rows, fixed, p50, p90, usd: priceable ? usd : { p50: null, p90: null }, low_confidence_bands: low, low_confidence_roles: lowRoles, context_risk: contextRisk };
 }
 
 const mulVec = (v, n) => {
@@ -13252,8 +13685,12 @@ function budgetForecast(claudeDir, planPath) {
   const asView = typeof flag("--as") === "string" ? String(flag("--as")) : String(cfg.budget_units || "auto");
 
   if (!planPath) {
-    console.error("usage: orc budget forecast <plan-file> [--json] [--as tokens|usd|quota|context|all]");
-    process.exit(1);
+    // v2.1.2 F16 — exit 1 is a low-confidence ANSWER on this route, so a missing
+    // plan is the "no plan" refusal (3), and --json still gets its one object.
+    const usage = "usage: orc budget forecast <plan-file> [--json] [--naive] [--as tokens|usd|quota|context|all]";
+    if (asJson) emitJson({ ok: false, reason: "no-plan", path: null, hint: usage }, 3);
+    console.error(usage);
+    process.exit(3);
   }
   const root = repoRootOf(claudeDir);
   const abs = path.isAbsolute(planPath)
@@ -13287,8 +13724,9 @@ function budgetForecast(claudeDir, planPath) {
   const waves = Math.max(1, new Set(tasks.map((t) => t.depends_on.length)).size);
   const lanes = FORECAST_LANES.map((l) => laneForecast(l, tasks, rates, cfg, claudeDir));
   const primary = lanes.find((l) => l.lane === "orc");
-  const money50 = priceVector(claudeDir, primary.p50, "claude-opus-4-8");
-  const money90 = priceVector(claudeDir, primary.p90, "claude-opus-4-8");
+  // v2.1.2 F25 — the dollars are the SUM of the rows, each at its own model.
+  const money50 = { usd: primary.usd.p50, weighted: weightedTokens(primary.p50), raw: rawTokens(primary.p50) };
+  const money90 = { usd: primary.usd.p90, weighted: weightedTokens(primary.p90), raw: rawTokens(primary.p90) };
   const quota = quotaView(table, cfg, money50.weighted);
   const risk = primary.context_risk;
   const code = risk.length ? 2 : primary.low_confidence_bands ? 1 : 0;
@@ -13320,7 +13758,7 @@ function budgetForecast(claudeDir, planPath) {
           cmd: l.cmd,
           raw: rawTokens(l.p50),
           weighted: weightedTokens(l.p50),
-          usd: priceVector(claudeDir, l.p50, "claude-opus-4-8").usd,
+          usd: l.usd.p50,
           low_confidence_bands: l.low_confidence_bands,
           low_confidence_roles: l.low_confidence_roles,
         })),
@@ -13355,7 +13793,7 @@ function budgetForecast(claudeDir, planPath) {
     const stale = table && table._stale ? `  ⚠ price table ${table._age_days === null ? "undated" : table._age_days + " days old"} (> ${PRICE_STALE_DAYS})` : table ? `  price table ${table.as_of} (${table._age_days} days old ✓)` : "";
     console.log(
       `\nUSD          ` +
-        (money50.usd === null ? "unavailable: no rate for this model in the price table" : `$${money50.usd.toFixed(2)} → $${money90.usd.toFixed(2)}${stale}`)
+        (money50.usd === null ? "unavailable: a band or role has no rate in the price table" : `$${money50.usd.toFixed(2)} → $${money90.usd.toFixed(2)}${stale}`)
     );
   }
   if (show("quota"))
@@ -13390,7 +13828,7 @@ function budgetForecast(claudeDir, planPath) {
   console.log("\n  lane          raw p50    weighted    usd p50");
   console.log("  " + "─".repeat(46));
   for (const l of lanes) {
-    const u = priceVector(claudeDir, l.p50, "claude-opus-4-8").usd;
+    const u = l.usd.p50;
     console.log(
       `  ${(l.cmd || l.lane).padEnd(13)} ${(rawTokens(l.p50) ? kTok(rawTokens(l.p50)) : "—").padStart(8)} ${(rawTokens(l.p50) ? kTok(weightedTokens(l.p50)) : "—").padStart(11)} ${(u === null || !rawTokens(l.p50) ? "—" : "$" + u.toFixed(2)).padStart(10)}` +
         (l.low_confidence_bands + l.low_confidence_roles ? "  floor" : "") +
@@ -13437,7 +13875,18 @@ function budgetActual(claudeDir, slugArg) {
     };
   });
   const unatt = j.unattributed.reduce((a, g) => sumVec(a, g.vec), { ...ZERO_VEC });
-  const money = priceVector(claudeDir, actual, "claude-opus-4-8");
+  // v2.1.2 F25 — each joined dispatch at the model its transcript block names.
+  let usdActual = 0;
+  for (const row of j.rows) {
+    if (!row.group) continue;
+    const u = priceVector(claudeDir, row.group.vec, row.group.model).usd;
+    if (u === null) {
+      usdActual = null;
+      break;
+    }
+    usdActual += u;
+  }
+  const money = { usd: usdActual, weighted: weightedTokens(actual), raw: rawTokens(actual) };
   const cacheShare = rawTokens(actual) ? actual.cache_read / rawTokens(actual) : 0;
 
   if (asJson)
@@ -13613,19 +14062,29 @@ function pactStateOf(root, e) {
   if (lc && lc.status === "fail") return { state: "BROKEN", why: `check failed at ${String(lc.commit || "").slice(0, 8)}${lc.at ? " (" + lc.at + ")" : ""}` };
   if (kind === "manual" || !e.check || !e.check.ref)
     return { state: "UNCHECKABLE", why: "no cheap check exists — this promise is held by review, not by a runner" };
-  const anchorFiles = (e.anchors || []).map((a) => String(a).split(":")[0]).filter(Boolean);
+  const anchorFiles = [...new Set((e.anchors || []).map((a) => String(a).split(":")[0]).filter(Boolean))];
   if (!e.verified_commit) return { state: "DRIFTED", why: "never verified at a commit" };
   const argv = ["rev-list", "--count", `${e.verified_commit}..HEAD`];
   if (anchorFiles.length) argv.push("--", ...anchorFiles.slice(0, 100));
   const n = gitIn(root, argv);
   if (n === null || !/^\d+$/.test(n)) return { state: "UNCHECKABLE", why: `verified_commit ${String(e.verified_commit).slice(0, 8)} is not resolvable here` };
   const d = Number(n);
-  if (d > 0)
+  if (d > 0) {
+    // v2.1.2 F18 — name the files the commits TOUCHED, not every anchor. Two
+    // anchors in one file are one file.
+    const sha = String(e.verified_commit).slice(0, 8);
+    if (!anchorFiles.length)
+      return { state: "DRIFTED", why: `${plural(d, "commit")} since ${sha} — no anchors, so every commit counts`, distance: d, touched_files: [] };
+    const log = gitIn(root, ["log", "--format=", "--name-only", `${e.verified_commit}..HEAD`, "--", ...anchorFiles.slice(0, 100)]) || "";
+    const touched = [...new Set(log.split(/\r?\n/).map((s) => s.trim()).filter(Boolean))];
+    const list = touched.slice(0, 3).join(", ") + (touched.length > 3 ? ", …" : "");
     return {
       state: "DRIFTED",
-      why: `${plural(d, "commit")} since ${String(e.verified_commit).slice(0, 8)} touched ${plural(anchorFiles.length, "anchored file")}`,
+      why: `${plural(d, "commit")} since ${sha} touched ${touched.length} of ${plural(anchorFiles.length, "anchored file")}${list ? ` (${list})` : ""}`,
       distance: d,
+      touched_files: touched,
     };
+  }
   return { state: "HOLDING", why: `verified at ${String(e.verified_commit).slice(0, 8)}; no commit since has touched its anchors`, distance: 0 };
 }
 
@@ -13651,6 +14110,7 @@ function pactRows(claudeDir) {
       state: st.state,
       why: st.why,
       distance: st.distance === undefined ? null : st.distance,
+      touched_files: st.touched_files || null,
     };
   });
   const live = rows.filter((r) => !r.retired);
@@ -13914,6 +14374,10 @@ function readBoundaryCards(claudeDir) {
       if (out !== null && /^\d+$/.test(out)) distance = Number(out);
     }
     const malformed = [];
+    // v2.1.2 (F02): a list field that came back as a map is unreadable, never empty.
+    for (const k of ["anchored_files", "checklist", "reasons"])
+      if (h[k] && typeof h[k] === "object" && !Array.isArray(h[k]) && Object.keys(h[k]).length)
+        malformed.push(`${k} is not a list — write \`- item\` lines or [a, b]`);
     if (!BOUNDARY_VERDICTS.includes(verdict)) malformed.push(`verdict must be one of ${BOUNDARY_VERDICTS.join(" | ")}`);
     if (verdict === "REFUSE" && !checklist.length)
       malformed.push("a REFUSE with no checklist is malformed — a boundary must name what would make it a yes");
@@ -14350,7 +14814,12 @@ function aftermathStatus(claudeDir) {
     process.exit(3);
   }
   const cut = Date.now() - windowDays * 86400000;
-  const inWindow = runs.filter((r) => r.mtime >= cut && r.slug);
+  // v2.1.2 F20 — never grade the run that is still OPEN. /orc-aftermath writes
+  // `.current` and touches its own trace at A0, so every report carried a
+  // TOO_RECENT row about itself, and `history too shallow` (exit 3) could
+  // never be reached from inside the lane.
+  const open = openRunPointer(claudeDir);
+  const inWindow = runs.filter((r) => r.mtime >= cut && r.slug && !(open && r.name === open.name));
   if (!inWindow.length) {
     if (asJson) emitJson({ ok: false, reason: "shallow", window_days: windowDays, log_dir: dir, runs: [] }, 3);
     console.log(`no runs in the last ${windowDays} days under ${dir} — history too shallow to grade.`);
@@ -17316,6 +17785,8 @@ const DOC_VALUE_FLAGS = [
   "--type", "--template", "--title", "--language", "--target", "--length",
   "--role", "--section", "--set", "--dir", "--budget", "--limit",
   "--only", "--confirm",
+  // v2.1.2 — the checker's recorder
+  "--checked", "--findings",
   // v0.49.2
   "--priority", "--text", "--set-file", "--reason", "--as", "--where", "--note", "--kind",
 ];
@@ -17802,6 +18273,9 @@ function docPartsView(claudeDir, slug) {
       hash,
       state: docPartState(rec, exists, hash),
       findings: rec.findings || 0,
+      // v2.1.2 — how many edit rounds a FLAGGED section has already had. The
+      // D8 cap of 2 is read from here, never from a model's memory.
+      edit_rounds: rec.edit_rounds || 0,
       cycle: rec.cycle || null,
       subsections: (o.subsections || []).map((s) => {
         const part = src.parts.find((x) => x.sub === s.id);
@@ -19491,7 +19965,7 @@ function docPlanShape(claudeDir, slugArg, roleOverride) {
   } else if (role === "check") {
     // The hash is what turns a re-check from a full pass into a diff: a section
     // whose hash has not moved since it was checked does not need re-reading.
-    // In v2 a checker gets one bounded PART FILE, so there is no line arithmetic
+    // In v2 a checker gets only the bounded PART FILES of one slice, so there is no line arithmetic
     // anywhere in the loop.
     items = v2
       ? pv.rows
@@ -20174,7 +20648,20 @@ function docPartsCmd(claudeDir, slugArg) {
       const prev = d.sections[row.id] || {};
       const parts = {};
       for (const pt of src.parts) if (pt.sub) parts[pt.sub] = pt.hash;
-      d.sections[row.id] = { ...prev, source_hash: row.hash, state: "written", cycle: d.cycle || 0, findings: prev.findings || 0, parts };
+      // v2.1.2 — a hash that MOVED is a new body: the findings recorded against
+      // the old one no longer describe it, so they are cleared and the section
+      // goes back to the check. If it carried findings, that was an edit round.
+      const moved = prev.source_hash !== row.hash;
+      const rounds = (prev.edit_rounds || 0) + (moved && prev.findings > 0 ? 1 : 0);
+      d.sections[row.id] = {
+        ...prev,
+        source_hash: row.hash,
+        state: "written",
+        cycle: d.cycle || 0,
+        findings: moved ? 0 : prev.findings || 0,
+        ...(rounds ? { edit_rounds: rounds } : {}),
+        parts,
+      };
       confirmed.push(row.id);
     }
     if (unknown.length || empty.length || drifted.length) {
@@ -20194,6 +20681,65 @@ function docPartsCmd(claudeDir, slugArg) {
     docWrite(claudeDir, slug, d);
   }
 
+  // v2.1.2 — the CHECKER's recorder. `--confirm` was built for writer returns
+  // only, so `checked` and `findings` were read in five places and written in
+  // none: `orc doc next` named the paid `plan-check` forever.
+  //   --checked <ids>        clean, or advisory (P2/P3) findings only
+  //   --findings <id>=<n>,…  n = the P0+P1 count, n >= 1
+  // Same refusal shape as `--confirm`: one bad id and NOTHING is written. Only a
+  // part whose recorded hash still matches the file can carry a check result —
+  // a verdict on a body nobody validated is a verdict on nothing.
+  const idList = (raw) =>
+    String(raw || "")
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean);
+  const wantChecked = idList(docOpt("--checked"));
+  const wantFlagged = idList(docOpt("--findings"));
+  const checked = [];
+  const flagged = [];
+  if (wantChecked.length || wantFlagged.length) {
+    const view = docPartsView(claudeDir, slug);
+    const d = view.d;
+    const unknown = [];
+    const bad = [];
+    const refused = [];
+    const take = (want, n) => {
+      const row = view.rows.find((r) => r.id === want || r.id.startsWith(want));
+      if (!row) return void unknown.push(want);
+      if (row.state !== "written" && row.state !== "checked") return void refused.push({ id: row.id, state: row.state });
+      if (checked.includes(row.id) || flagged.some((f) => f.id === row.id)) return void bad.push(want);
+      if (n) flagged.push({ id: row.id, findings: n });
+      else checked.push(row.id);
+    };
+    for (const want of wantChecked) take(want, 0);
+    for (const pair of wantFlagged) {
+      const m = /^(.+)=(\d+)$/.exec(pair);
+      if (!m || Number(m[2]) < 1) bad.push(pair);
+      else take(m[1].trim(), Number(m[2]));
+    }
+    if (unknown.length || bad.length || refused.length) {
+      const hint =
+        (unknown.length ? `no such section: ${unknown.join(", ")}. ` : "") +
+        (bad.length
+          ? `not a check result: ${bad.join(", ")} — --findings takes <id>=<n> with n >= 1, and a section is named once. `
+          : "") +
+        (refused.length
+          ? `no validated return on record for: ` +
+            refused.map((x) => `${x.id} (${x.state})`).join(", ") +
+            ` — a check result is recorded only against a confirmed hash. Run \`orc doc parts ${slug} --confirm <ids>\` first. `
+          : "") +
+        "Nothing was written.";
+      const reason = unknown.length ? "no-such-section" : bad.length ? "bad-findings" : "not-confirmed";
+      if (asJson) emitJson({ ok: false, reason, slug, unknown, bad, refused, checked: [], flagged: [], hint }, 1);
+      console.error("❌ " + hint);
+      process.exit(1);
+    }
+    for (const id of checked) d.sections[id] = { ...(d.sections[id] || {}), state: "checked", findings: 0, checked_cycle: d.cycle || 0 };
+    for (const f of flagged) d.sections[f.id] = { ...(d.sections[f.id] || {}), state: "written", findings: f.findings };
+    docWrite(claudeDir, slug, d);
+  }
+
   const view = docPartsView(claudeDir, slug);
   const d = view.d;
   const wave = docWaveState(d, view.rows);
@@ -20207,8 +20753,10 @@ function docPartsCmd(claudeDir, slugArg) {
     dir: path.relative(view.paths.root, view.paths.sections).split(path.sep).join("/"),
     front: view.front,
     confirmed: confirm.length ? confirm : [],
-    parts: view.rows.map(({ id, heading, required, files, nested, exists, lines, hash, state, subsections, ordinal_ok, findings }) => ({
-      id, heading, required, files, nested, exists, lines, hash, state, subsections, ordinal_ok, findings,
+    checked,
+    flagged,
+    parts: view.rows.map(({ id, heading, required, files, nested, exists, lines, hash, state, subsections, ordinal_ok, findings, edit_rounds }) => ({
+      id, heading, required, files, nested, exists, lines, hash, state, subsections, ordinal_ok, findings, edit_rounds,
     })),
     total: view.rows.length,
     written: view.rows.filter((r) => r.state === "written" || r.state === "checked").length,
@@ -21878,7 +22426,26 @@ function docNextAction(claudeDir, slug) {
   // THE FREE CHECK ALWAYS RUNS BEFORE THE PAID ONE. `orc doc lint` costs zero
   // tokens and its findings ride in the checker's slice, so no model is ever
   // paid to count sentences.
-  const writtenSince = (v2 ? pv.rows : view.sections).filter((s) => s.state === "written").length;
+  //
+  // v2.1.2 — a section the checker FLAGGED goes to the edit, not back to the
+  // check. And the cap of 2 rounds is a human decision, not a third round.
+  const flagged = pv.rows.filter((r) => r.state === "written" && r.findings > 0);
+  const capped = flagged.filter((r) => r.edit_rounds >= 2);
+  if (capped.length)
+    return BLOCK(
+      "D8",
+      `${capped[0].heading}: 2 edit rounds, and the checker still reports ${capped[0].findings} blocking finding(s). Accept it, or say what should change.`,
+      [`orc doc parts ${slug} --checked ${capped[0].id}`, `orc doc log ${slug} --kind gap --text "<what stays open>"`]
+    );
+  if (flagged.length)
+    return A(
+      "D8",
+      "plan-edit",
+      `orc doc plan ${slug} --role edit --only ${flagged.map((r) => r.id).join(",")} --json`,
+      `${plural(flagged.length, "section")} ${flagged.length === 1 ? "carries" : "carry"} blocking checker findings`,
+      true
+    );
+  const writtenSince = (v2 ? pv.rows : view.sections).filter((s) => s.state === "written" && !s.findings).length;
   if (lint && lint.errors)
     return A("D7", "lint", `orc doc lint ${slug} --json`, `${plural(lint.errors, "lint error")} — the free check runs before the paid one`, false, [
       `orc doc map ${slug} --json`,
@@ -22550,7 +23117,8 @@ function doc() {
           "       orc doc status <slug> [--json]               0 nothing to do / 1 something to do / 2 unknown slug\n" +
           "       orc doc show <slug> [--json]                 full state: sections, cycles, extracts\n" +
           "       orc doc map <slug> [--json]                  the DERIVED section map (fresh line numbers)\n" +
-          "       orc doc parts <slug> [--confirm <ids>]       the SECTION FILES (works before any compile)\n" +
+          "       orc doc parts <slug> [--confirm <ids>] [--checked <ids>] [--findings <id>=<n>,…]\n" +
+          "                                                    the SECTION FILES (works before any compile)\n" +
           "       orc doc compile <slug> [--partial]           sections/ -> document.md. FREE, on demand\n" +
           "       orc doc split <slug> [--section <id> --by-heading]  document -> sections/, or a section -> parts\n" +
           "       orc doc migrate <slug> [--clean]             v1 -> v2, lazy and non-destructive\n" +
@@ -26682,7 +27250,7 @@ const EXTRA_SLOTS = [
   {
     slot: "quick-executor",
     lane: "/orc-quick",
-    claude: ["orc-executor-sonnet-4-6-med", "orc-executor-opus-5-low"],
+    claude: ["orc-executor-sonnet-5-med", "orc-executor-opus-5-low"],
     claude_opus5: ["orc-executor-opus-5-low"],
     asks: true,
     announce: "the dispatch gate — offered as a third option, never a default",
@@ -26691,8 +27259,8 @@ const EXTRA_SLOTS = [
   {
     slot: "fast-executor",
     lane: "/orc-fast",
-    claude: ["orc-executor-sonnet-4-6-high"],
-    claude_opus5: ["orc-executor-opus-5-med"],
+    claude: ["orc-executor-sonnet-5-med"],
+    claude_opus5: ["orc-executor-opus-5-low"],
     asks: false,
     announce: "the F0 preflight `extra:` line, before wave 1",
     why: "one executor, one slice, a build+test smoke gate behind it — the checks that catch a bad implementation here are engine-blind.",
@@ -26713,7 +27281,7 @@ const EXTRA_SLOTS = [
     claude_opus5: null,
     asks: false,
     announce: "before the wave",
-    why: "the checker reads one bounded part and reports; it rewrites nothing, so a finding it makes is a finding you read.",
+    why: "the checker reads only the bounded part files of one slice and reports; it rewrites nothing, so a finding it makes is a finding you read.",
   },
   // v1.5.0 - `/orc-test`'s DESIGNER, and only the designer. The interpreter
   // deliberately gets NO slot: its slice is CAPTURED RESPONSE BODIES FROM THE
@@ -30165,7 +30733,7 @@ function extraResumeTarget(v, result, cfg) {
 const EXTRA_FALLBACK_ALTERNATES = [
   { agent: "orc-executor-opus-5-med", why: "more thinking than most bands buy, without the top-tier cost." },
   { agent: "orc-executor-opus-5-low", why: "the same model on the cheapest rung — right when the slice turned out to be mechanical." },
-  { agent: "orc-executor-sonnet-4-6-high", why: "a different model entirely, for a slice where Opus is not the constraint." },
+  { agent: "orc-executor-sonnet-5-high", why: "a different model entirely, for a slice where Opus is not the constraint." },
 ];
 
 function extraFallbackChoice(cfg, claude) {
@@ -35178,6 +35746,14 @@ function doctor() {
       (arr || []).some((e) => (e.hooks || []).some((h) => typeof h.command === "string" && h.command.includes(needle)));
     if (hasCmd(hooks.PreToolUse, "orc-effort-guard")) ok("effort guard wired (PreToolUse)");
     else warn("effort-guard-unwired", "effort guard NOT wired — /orc won't be effort-gated; run `orc update`", { fixable: true });
+    const typedEntry = (hooks.UserPromptExpansion || []).find((e) =>
+      (e.hooks || []).some((h) => typeof h.command === "string" && h.command.includes("orc-effort-guard"))
+    );
+    if (!typedEntry)
+      warn("typed-gate-unwired", "a typed /orc or /orc-diy is NOT effort-gated (no UserPromptExpansion entry) — run `orc update`", { fixable: true, fix_command: "orc update" });
+    else if (typedEntry.matcher !== TYPED_GATE_MATCHER)
+      warn("typed-gate-matcher", `typed-command gate matcher is "${typedEntry.matcher || ""}" — needs "${TYPED_GATE_MATCHER}"; run \`orc update\``, { fixable: true, fix_command: "orc update" });
+    else ok(`typed /orc + /orc-diy gate wired (UserPromptExpansion ${TYPED_GATE_MATCHER})`);
     const traceEntry = (hooks.PreToolUse || []).find((e) =>
       (e.hooks || []).some((h) => typeof h.command === "string" && h.command.includes("orc-trace"))
     );
@@ -35194,7 +35770,7 @@ function doctor() {
     else warn("trace-return-unwired", "trace RETURN hook NOT wired (SubagentStop) — run `orc update`", { fixable: true });
     if (settings.statusLine && typeof settings.statusLine.command === "string") {
       if (settings.statusLine.command.includes("orc-statusline")) ok("statusline is ORC's model warning");
-      else ok("statusline present (yours — ORC left it untouched)");
+      else ok("statusline present (yours — ORC left it untouched) · a typed /orc reads its effort from ORC's line, so it is not effort-gated here");
     } else
       warn("statusline-missing", "no statusLine — the non-Opus/high model warning won't show; run `orc update`", {
         fixable: true,
@@ -35384,10 +35960,12 @@ function doctor() {
   // graph nobody has asked for yet is a doctor people learn to scroll past.
   try {
     const cfg = resolvedConfig(claudeDir);
-    if (String(cfg.code_graph || "off") !== "on") ok("code graph off (fine — the default)");
+    const dMode = String(cfg.code_graph || "off").toLowerCase();
+    if (dMode !== "on" && dMode !== "semi") ok("code graph off (fine — the default)");
     else {
       const gs = require("./graph.js").graphStatus(claudeDir, repoRootOf(claudeDir), { enabled: true });
-      if (gs.state === "drifted") {
+      if (dMode === "semi") ok("code graph semi — kept current, lanes do not read it");
+      else if (gs.state === "drifted") {
         const b = gs.behind || {};
         const n = (b.added || 0) + (b.changed || 0) + (b.deleted || 0);
         warn(
@@ -35416,13 +35994,14 @@ function doctor() {
           ["PreToolUse", "Grep|Glob"],
           ["PreToolUse", "Bash|Read"],
           ["PostToolUse", "Read"],
+          ["PostToolUse", "Task|Agent"],
         ];
         const wired = ENTRIES.filter(([e, m]) => wiredOn(e, m)).map(([e, m]) => (m ? `${e} ${m}` : e));
-        if (wired.length === ENTRIES.length) ok("graph hook wired on all five entries");
+        if (wired.length === ENTRIES.length) ok("graph hook wired on all six entries");
         else
           warn(
             "graph-hook-unwired",
-            `graph hook wired on ${wired.length} of 5 entries (${wired.join(", ") || "none"}) — the graph will not update itself when an executor finishes, and subagents get no anchors; run \`orc update\``,
+            `graph hook wired on ${wired.length} of ${ENTRIES.length} entries (${wired.join(", ") || "none"}) — the graph will not update itself when an executor finishes, and subagents get no anchors; run \`orc update\``,
             { fixable: true, fix: "orc update", fix_command: "orc update" }
           );
       }
@@ -41685,6 +42264,10 @@ Usage:
       … --confirm <id,id>                 record a VALIDATED RETURN's hash. Until then a file on
                                           disk is \`unconfirmed\`: a wave killed by a usage limit
                                           leaves exactly that, and it is re-written, never shipped
+      … --checked <id,id>                 record a CLEAN CHECK (advisory findings only). The part
+                                          stays \`checked\` only while its hash holds
+      … --findings <id>=<n>,…             record the BLOCKING (P0+P1) count per part. \`orc doc next\`
+                                          then names the edit; after 2 rounds it asks you instead
     orc doc compile <slug> [--partial]    sections/ → document.md. ZERO model tokens, on demand.
                                           --partial writes what exists and NAMES what is missing;
                                           nothing is ever stubbed into the deliverable
@@ -41846,6 +42429,9 @@ Usage:
                                           and where its safe point is
     orc wait plan <spec> [--json]         turn 30 · 90m · 2h · until 18:41 · reset into hops
       [--hop <min>] [--max-hops <n>]      (exit 0 planned / 1 unparsable / 2 no usage reading)
+    orc wait start <spec> --mode <m>      record the wait that starts now and write its WAIT line
+                                          (no run in flight = recorded: false, exit 0)  [--json]
+    orc wait end --reason <why>           close it: elapsed | recovered | cancelled | max-hops  [--json]
   orc onboarding [<topic>]                guided walkthrough (menu on a TTY; prints all when piped)
                                           topics: overview, install, first-run, lanes,
                                           config, knowledge, upgrade, troubleshooting
@@ -42028,22 +42614,17 @@ function waitHops(totalMinutes, hopMinutes, maxHops) {
   return { hops, uncovered_minutes: left, truncated: left > 0 };
 }
 
-function waitPlanCmd(claudeDir) {
-  const asJson = wantsJson();
-  const pos = positionals().slice(2);
-  const spec = pos.join(" ");
-  const now = Date.now();
+// v2.1.2 F10 — the parse and the hop arithmetic, ONCE. `wait plan` renders this
+// and `wait start` records it; two copies of the arithmetic would be two ideas
+// of when a wait ends. A refusal comes back as { ok:false, exit, reason, hint }
+// and the caller prints it.
+function waitPlanCompute(claudeDir, spec, now) {
   const cfg = resolvedConfig(claudeDir);
   const hopMin = Number(flag("--hop")) || Number(cfg.wait_hop_minutes) || WAIT_HOP_DEFAULT_MIN;
   const maxHops = Number(flag("--max-hops")) || Number(cfg.wait_max_hops) || WAIT_MAX_HOPS_DEFAULT;
 
   const parsed = waitParseSpec(spec, now);
-  if (!parsed.ok) {
-    if (asJson) emitJson({ ok: false, reason: parsed.reason, spec, hint: parsed.hint }, 1);
-    console.error(ui.mark.err(`I cannot read "${spec}" as a wait.`));
-    console.error("  " + parsed.hint);
-    process.exit(1);
-  }
+  if (!parsed.ok) return { ok: false, exit: 1, reason: parsed.reason, spec, hint: parsed.hint };
 
   let minutes = parsed.minutes;
   let source = parsed.kind;
@@ -42056,15 +42637,14 @@ function waitPlanCmd(claudeDir) {
       const why = reading
         ? "the reading has no usable reset time"
         : "there is no reading in the last 30 minutes";
-      if (asJson)
-        emitJson(
-          { ok: false, reason: "no-reading", spec, hint: `${why}. Type a time instead. Example: orc wait plan 45` },
-          2
-        );
-      console.error(ui.mark.err("I cannot read the reset time."));
-      console.error("  " + why + ".");
-      console.error("  Type a time instead. Example: " + ui.color.cyan("orc wait plan 45"));
-      process.exit(2);
+      return {
+        ok: false,
+        exit: 2,
+        reason: "no-reading",
+        spec,
+        why,
+        hint: `${why}. Type a time instead. Example: orc wait plan 45`,
+      };
     }
     minutes = Math.max(1, Math.round((at - now) / 60000));
     source = "reset";
@@ -42072,7 +42652,7 @@ function waitPlanCmd(claudeDir) {
 
   const h = waitHops(minutes, hopMin, maxHops);
   const endsAt = new Date(now + minutes * 60000);
-  const out = {
+  return {
     ok: true,
     spec,
     source,
@@ -42090,16 +42670,38 @@ function waitPlanCmd(claudeDir) {
     modes: WAIT_MODES,
     note: "A detached command does the waiting. No model runs, and no tokens are spent.",
   };
+}
+
+// The two refusals of the plan, in the human voice. Shared by `plan` and `start`
+// so the same mistake reads the same way in both.
+function waitPlanRefuse(plan, asJson) {
+  if (asJson) emitJson({ ok: false, reason: plan.reason, spec: plan.spec, hint: plan.hint }, plan.exit);
+  if (plan.exit === 2) {
+    console.error(ui.mark.bad("I cannot read the reset time."));
+    console.error("  " + plan.why + ".");
+    console.error("  Type a time instead. Example: " + ui.color.cyan("orc wait plan 45"));
+  } else {
+    console.error(ui.mark.bad(`I cannot read "${plan.spec}" as a wait.`));
+    console.error("  " + plan.hint);
+  }
+  process.exit(plan.exit);
+}
+
+function waitPlanCmd(claudeDir) {
+  const asJson = wantsJson();
+  const spec = positionals().slice(2).join(" ");
+  const out = waitPlanCompute(claudeDir, spec, Date.now());
+  if (!out.ok) waitPlanRefuse(out, asJson);
   if (asJson) emitJson(out, 0);
 
   console.log(ui.header("ORC · wait — the plan"));
   console.log("");
-  console.log(`  ${ui.color.cyan("length")}    ${minutes} min  (from ${source})`);
-  console.log(`  ${ui.color.cyan("ends at")}   ${endsAt.toTimeString().slice(0, 5)}`);
-  console.log(`  ${ui.color.cyan("hops")}      ${h.hops.join(" + ")}  (${h.hops.length} of ${maxHops} max)`);
-  if (h.truncated)
+  console.log(`  ${ui.color.cyan("length")}    ${out.minutes} min  (from ${out.source})`);
+  console.log(`  ${ui.color.cyan("ends at")}   ${new Date(out.ends_at).toTimeString().slice(0, 5)}`);
+  console.log(`  ${ui.color.cyan("hops")}      ${out.hops.join(" + ")}  (${out.hop_count} of ${out.max_hops} max)`);
+  if (out.truncated)
     console.log(
-      ui.mark.warn(`  ${h.uncovered_minutes} min are NOT covered — wait_max_hops is ${maxHops}.`)
+      ui.mark.warn(`  ${out.uncovered_minutes} min are NOT covered — wait_max_hops is ${out.max_hops}.`)
     );
   if (out.crosses_cache_ttl)
     console.log(
@@ -42691,7 +43293,7 @@ function waitBlockCmd(claudeDir, unblock) {
       ? `no run named "${slug}" under ${resolveRunDir(claudeDir)}`
       : "no run is in flight, and no slug was given";
     if (asJson) emitJson({ ok: false, reason: "no-run", slug: slug || null, hint }, 2);
-    console.error(ui.mark.err("I cannot find the run this is about."));
+    console.error(ui.mark.bad("I cannot find the run this is about."));
     console.error("  " + hint + ".");
     process.exit(2);
   }
@@ -42708,7 +43310,9 @@ function waitBlockCmd(claudeDir, unblock) {
       block_reason: null,
       unblocked_at: new Date().toISOString(),
     });
-    const trace = waitTraceLine(claudeDir, "WAIT", "unblock");
+    // v2.1.2 F11 — the sub-form is part of the VERB (`WAIT block :: …`), the
+    // shape TRACE_VERBS declares.
+    const trace = waitTraceLine(claudeDir, "WAIT unblock", null);
     if (asJson) emitJson({ ok: true, slug: run.slug, blocked: false, trace_line: trace }, 0);
     console.log(ui.mark.ok(`${run.slug}: the gate is live again.`));
     return;
@@ -42728,7 +43332,7 @@ function waitBlockCmd(claudeDir, unblock) {
         },
         1
       );
-    console.error(ui.mark.err("A block needs a reason."));
+    console.error(ui.mark.bad("A block needs a reason."));
     console.error('  orc wait block ' + run.slug + ' --reason "window resets in 5m, task needs 10"');
     process.exit(1);
   }
@@ -42738,7 +43342,7 @@ function waitBlockCmd(claudeDir, unblock) {
     block_reason: reason,
     unblocked_at: null,
   });
-  const trace = waitTraceLine(claudeDir, "WAIT", `block reason="${reason}" by=user`);
+  const trace = waitTraceLine(claudeDir, "WAIT block", `reason="${reason}" by=user`);
   if (asJson)
     emitJson(
       { ok: true, slug: run.slug, blocked: true, blocked_at: st.blocked_at, reason, trace_line: trace },
@@ -42754,6 +43358,163 @@ function waitBlockCmd(claudeDir, unblock) {
   );
 }
 
+// v2.1.2 F10 — a wait's activity is COMPUTED from its start and the clock, never
+// stored. A session that died mid-wait writes no `wait_ended_at`, so a stored
+// flag would read `waiting` for ever; one hop of grace after `ends_at` is the
+// last moment a live wait can still be hopping.
+function waitActive(st, now) {
+  const s = st || {};
+  const t = typeof now === "number" ? now : Date.now();
+  const started = !!s.wait_started_at;
+  const ended = !!s.wait_ended_at;
+  const grace = (Number(s.hop_minutes) || WAIT_HOP_DEFAULT_MIN) * 60000;
+  const endsAt = Date.parse(s.ends_at);
+  const active = started && !ended && Number.isFinite(endsAt) && t <= endsAt + grace;
+  const hops = Array.isArray(s.hops) ? s.hops : [];
+  const planned = Number(s.hops_planned) || hops.length;
+  let done = 0;
+  if (ended) done = Number(s.hops_done) || 0;
+  else if (started) {
+    // A hop is done when the clock has passed its cumulative boundary.
+    const elapsed = (t - Date.parse(s.wait_started_at)) / 60000;
+    let sum = 0;
+    for (const h of hops) {
+      sum += Number(h) || 0;
+      if (sum <= elapsed) done++;
+    }
+    done = Math.min(done, planned);
+  }
+  return { started, ended, active, stale: started && !ended && !active, hops_done: done, hops_planned: planned };
+}
+
+const WAIT_TRIGGERS = ["user", "gate"];
+const WAIT_END_REASONS = ["elapsed", "recovered", "cancelled", "max-hops"];
+
+// `orc wait start <spec> --mode <m>` — the STARTED half of wait.json, and the
+// `WAIT mode=…` line. With no run in flight a wait is simply a wait: the answer
+// is `recorded: false`, exit 0, and NOTHING is written.
+function waitStartCmd(claudeDir) {
+  const asJson = wantsJson();
+  const mode = flag("--mode");
+  const trigger = flag("--trigger") === undefined ? "user" : flag("--trigger");
+  const runFlag = typeof flag("--run") === "string" ? flag("--run") : null;
+  // positionals() does not know these three flags, so their VALUES arrive as
+  // positionals — and "30 hard" is not a spec. Take each one out once.
+  const pos = positionals().slice(2);
+  for (const v of [mode, trigger, runFlag]) {
+    const i = typeof v === "string" ? pos.indexOf(v) : -1;
+    if (i !== -1 && args.includes(v)) pos.splice(i, 1);
+  }
+  const now = Date.now();
+  const plan = waitPlanCompute(claudeDir, pos.join(" "), now);
+  if (!plan.ok) waitPlanRefuse(plan, asJson);
+
+  if (!WAIT_MODES.includes(mode)) {
+    const hint = `a wait is recorded with its mode. Pass --mode <${WAIT_MODES.join("|")}>.`;
+    if (asJson) emitJson({ ok: false, reason: "no-mode", spec: plan.spec, hint }, 1);
+    console.error(ui.mark.bad("A wait needs a mode."));
+    console.error("  " + hint);
+    process.exit(1);
+  }
+  if (!WAIT_TRIGGERS.includes(trigger)) {
+    const hint = `--trigger is ${WAIT_TRIGGERS.join(" or ")}.`;
+    if (asJson) emitJson({ ok: false, reason: "bad-trigger", spec: plan.spec, hint }, 1);
+    console.error(ui.mark.bad("I cannot read that trigger."));
+    console.error("  " + hint);
+    process.exit(1);
+  }
+
+  const run = waitResolveRun(claudeDir, runFlag);
+  if (!run) {
+    if (asJson) emitJson({ ...plan, ok: true, recorded: false, reason: "no-run", mode, trigger }, 0);
+    console.log(ui.color.gray("No run is in flight, so nothing is recorded. The wait is still a wait."));
+    return;
+  }
+  if (waitActive(readWaitState(claudeDir, run.slug), now).active) {
+    const hint = "this run already has a wait. `orc wait end` or `orc wait cancel` closes it.";
+    if (asJson) emitJson({ ok: false, reason: "already-waiting", slug: run.slug, hint }, 1);
+    console.error(ui.mark.warn(`${run.slug} already has a wait running.`));
+    console.error("  " + hint);
+    process.exit(1);
+  }
+
+  writeWaitState(claudeDir, run.slug, {
+    wait_started_at: new Date(now).toISOString(),
+    mode,
+    trigger,
+    minutes: plan.minutes,
+    hop_minutes: plan.hop_minutes,
+    hops: plan.hops,
+    hops_planned: plan.hop_count,
+    max_hops: plan.max_hops,
+    ends_at: plan.ends_at,
+    hops_done: 0,
+    wait_ended_at: null,
+    end_reason: null,
+    cancel_requested_at: null,
+  });
+  const hhmm = (iso) => new Date(iso).toTimeString().slice(0, 5);
+  const trace = waitTraceLine(
+    claudeDir,
+    `WAIT mode=${mode} requested=${plan.minutes}m start=${hhmm(now)} end=${hhmm(plan.ends_at)} ` +
+      `hops=${plan.hop_count}/${plan.max_hops} trigger=${trigger}`,
+    null
+  );
+  if (asJson)
+    emitJson({ ...plan, ok: true, recorded: true, slug: run.slug, mode, trigger, trace_line: trace }, 0);
+  console.log(
+    ui.mark.ok(`${run.slug}: the wait is recorded — ${mode}, ${plan.minutes} min, ends ${hhmm(plan.ends_at)}.`)
+  );
+}
+
+// `orc wait end [<slug>] --reason <r>` — closes the wait `start` recorded. The
+// hop count is taken from the clock at this moment, then FROZEN in the file.
+function waitEndCmd(claudeDir) {
+  const asJson = wantsJson();
+  const reason = typeof flag("--reason") === "string" ? String(flag("--reason")).trim() : "";
+  const run = waitResolveRun(claudeDir, positionals()[2]);
+  if (!run) {
+    if (asJson) emitJson({ ok: false, reason: "no-run", hint: "no run is in flight" }, 1);
+    console.error(ui.mark.warn("No run is in flight, so there is no wait to end."));
+    process.exit(1);
+  }
+  const now = Date.now();
+  const act = waitActive(readWaitState(claudeDir, run.slug), now);
+  if (!act.active) {
+    if (asJson) emitJson({ ok: false, reason: "no-wait", slug: run.slug }, 1);
+    console.error(ui.mark.warn(`${run.slug} has no wait running.`));
+    process.exit(1);
+  }
+  if (!WAIT_END_REASONS.includes(reason)) {
+    const hint = `say why the wait ended. Pass --reason <${WAIT_END_REASONS.join("|")}>.`;
+    if (asJson) emitJson({ ok: false, reason: "no-reason", slug: run.slug, hint }, 1);
+    console.error(ui.mark.bad("The end of a wait needs a reason."));
+    console.error("  " + hint);
+    process.exit(1);
+  }
+  const st = writeWaitState(claudeDir, run.slug, {
+    wait_ended_at: new Date(now).toISOString(),
+    end_reason: reason,
+    hops_done: act.hops_done,
+  });
+  const trace = waitTraceLine(claudeDir, "WAIT end", `done=${act.hops_done}/${act.hops_planned} reason=${reason}`);
+  if (asJson)
+    emitJson(
+      {
+        ok: true,
+        slug: run.slug,
+        ended: true,
+        end_reason: reason,
+        hops_done: act.hops_done,
+        hops_planned: act.hops_planned,
+        wait_ended_at: st.wait_ended_at,
+        trace_line: trace,
+      },
+      0
+    );
+  console.log(ui.mark.ok(`${run.slug}: the wait ended — ${reason}, hop ${act.hops_done} of ${act.hops_planned}.`));
+}
+
 function waitCancelCmd(claudeDir) {
   const asJson = wantsJson();
   const run = waitResolveRun(claudeDir, positionals()[2]);
@@ -42763,7 +43524,7 @@ function waitCancelCmd(claudeDir) {
     process.exit(1);
   }
   const cur = readWaitState(claudeDir, run.slug);
-  if (!cur || !cur.wait_started_at || cur.wait_ended_at) {
+  if (!waitActive(cur).active) {
     if (asJson) emitJson({ ok: false, reason: "no-wait", slug: run.slug }, 1);
     console.error(ui.mark.warn(`${run.slug} has no wait running.`));
     process.exit(1);
@@ -42786,15 +43547,19 @@ function waitStatusCmd(claudeDir) {
   }
   const st = readWaitState(claudeDir, run.slug) || {};
   const blocked = !!st.blocked_at;
-  const waiting = !!st.wait_started_at && !st.wait_ended_at;
+  // v2.1.2 F10 — computed from the start and the clock. A wait whose session
+  // died reads `stale`, never `waiting`.
+  const act = waitActive(st);
+  const waiting = act.active;
   const ageMin = blocked ? Math.round((Date.now() - Date.parse(st.blocked_at)) / 60000) : null;
   const out = {
     ok: true,
     run: run.slug,
     waiting,
+    stale: act.stale,
     mode: st.mode || null,
     hop: st.hop || null,
-    hops_done: st.hops_done || 0,
+    hops_done: act.hops_done,
     hops_planned: st.hops_planned || null,
     ends_at: st.ends_at || null,
     cancel_requested: !!st.cancel_requested_at,
@@ -42813,7 +43578,7 @@ function waitStatusCmd(claudeDir) {
     `  ${ui.color.cyan("wait")}      ` +
       (waiting
         ? `${st.mode || "?"} · hop ${out.hops_done} of ${out.hops_planned || "?"} · ends ${out.ends_at || "?"}`
-        : ui.color.gray("none"))
+        : ui.color.gray(act.stale ? "none — a wait was started and never closed (stale)" : "none"))
   );
   console.log(
     `  ${ui.color.cyan("block")}     ` +
@@ -42839,9 +43604,15 @@ function waitCmd() {
       return waitBlockCmd(claudeDir, true);
     case "cancel":
       return waitCancelCmd(claudeDir);
+    case "start":
+      return waitStartCmd(claudeDir);
+    case "end":
+      return waitEndCmd(claudeDir);
     default:
       console.error(`usage: orc wait lanes [--json]
        orc wait plan <30|90m|2h|until 18:41|reset> [--hop <min>] [--max-hops <n>] [--json]
+       orc wait start <spec> --mode <safe|soft|hard> [--trigger user|gate] [--run <slug>] [--json]
+       orc wait end [<slug>] --reason <elapsed|recovered|cancelled|max-hops> [--json]
        orc wait status [<slug>] [--json]
        orc wait block <slug> --reason "<why>" [--json]
        orc wait unblock [<slug>] [--json]
@@ -44939,7 +45710,7 @@ function slEngine() {
 // concluded could not be measured.
 const SL_TASK_FIXTURES = {
   healthy: { id: "t1", name: "orc-executor-opus-5-low", type: "orc-executor-opus-5-low", description: "wire the retry ladder", status: "running", model: "claude-opus-5-5", effort: "low", tokenCount: 84000, contextWindowSize: 200000, startTime: 1767225600000 - 17 * 60000 },
-  degraded: { id: "t2", name: "orc-executor-sonnet-4-6-med", type: "orc-executor-sonnet-4-6-med", description: "rename two files", status: "failed", model: "claude-sonnet-4-6", effort: "medium", tokenCount: 191000, contextWindowSize: 200000, startTime: 1767225600000 - 96 * 60000 },
+  degraded: { id: "t2", name: "orc-executor-haiku-5-high", type: "orc-executor-haiku-5-high", description: "rename two files", status: "failed", model: "claude-haiku-5-5", effort: "high", tokenCount: 191000, contextWindowSize: 200000, startTime: 1767225600000 - 96 * 60000 },
   empty: { id: "t3" },
 };
 
@@ -46947,7 +47718,7 @@ function lintScanFile(abs, rel, opts) {
       const low = prose.toLowerCase();
       if (on("OSW-10"))
         for (const w of LINT_LEXICON)
-          if (new RegExp(`\\b${w.replace(/[.*+?^${}()|[\]\\]/g, "\\// ── the `--json` crash envelope (v0.49.2) ───────────────────────────────────")}\\b`, "i").test(low)) {
+          if (new RegExp(`\\b${w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i").test(low)) {
             add("OSW-10", n, w, "use the plain word");
             break; // one finding per line — a list of six is a list nobody reads
           }
@@ -47249,7 +48020,7 @@ function jsonCrash(err) {
     // v2.1.0 W6 — the deterministic half of `/orc-fix`. It READS `.current`
     // (the host run) and never writes it: the lane opens no run of its own.
     case "fix":
-      require("./fix.js").fixCmd(Object.assign(gotchaDeps(), { resolveLogDir, TRACE_NAME, inflightStaleMs: INFLIGHT_STALE_MS }));
+      require("./fix.js").fixCmd(Object.assign(gotchaDeps(), { resolveLogDir, TRACE_NAME, inflightStaleMs: INFLIGHT_STALE_MS, openRunPointer }));
       break;
     case "graph":
       graphCmd();
@@ -47263,7 +48034,7 @@ function jsonCrash(err) {
     // pair. The Haiku writer is the fallback when this exits ≠ 0.
     case "trace":
       require("./trace-write.js").traceCmd({
-        flag, positionals, emitJson, wantsJson, resolveClaudeDir, resolveLogDir, TRACE_VERBS, readOverride, reviewPolicyCompute,
+        flag, positionals, emitJson, wantsJson, resolveClaudeDir, resolveLogDir, TRACE_VERBS, readOverride, reviewPolicyCompute, laneVerbsFor,
         logSweep: (claudeDir) => require("./clear-logs.js").sweep(claudeDir, clearLogsDeps()),
       });
       break;