@azure-id/orc 1.9.2 → 2.1.0

package/bin/cli.js

@@ -95,8 +95,24 @@ const SL_VALUE_FLAGS = new Set([
   "--prefix", "--suffix", "--emphasis", "--hide-when", "--width", "--precision",
   "--min-width", "--min-cols", "--max-cols", "--priority", "--separator",
   "--max-width", "--theme", "--state", "--set",
+  // v2.0.4 — the design fields.
+  "--label-pos", "--value-pos", "--caption", "--caption-pos", "--caption-align",
+  "--caption-color", "--caption-case", "--fill-color", "--empty-color",
+  "--ramp-colors", "--ramp-stops", "--fill-char", "--empty-char", "--brackets",
+  "--threshold", "--pad-left", "--pad-right", "--align", "--sign", "--max-len",
+  "--unknown", "--state-color", "--state-glyph", "--param", "--sep-color",
 ]);
 
+// `orc statusline` value flags: "" and "-x" are real values here ("" clears).
+function slFlag(name) {
+  const i = args.indexOf(name);
+  if (i === -1) return undefined;
+  if (i + 1 >= args.length) return true;
+  const val = args[i + 1];
+  if (SL_VALUE_FLAGS.has(val) || ["--json", "--board", "--draw-empty", "--global", "--dir", "--ansi", "--align-columns"].includes(val)) return true;
+  return val;
+}
+
 function flag(name) {
   const i = args.indexOf(name);
   if (i === -1) return undefined;
@@ -112,7 +128,7 @@ function positionals() {
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a === "--global") continue;
-    if (a === "--dir" || a === "--from" || a === "--preset" || a === "--reason") {
+    if (a === "--dir" || a === "--from" || a === "--preset" || a === "--reason" || a === "--board") {
       i++; // skip the flag's value
       continue;
     }
@@ -179,10 +195,19 @@ function writeStdoutSync(str) {
   }
 }
 
+let PROBE_CAPTURE = null;
+
 // Print the object and (optionally) exit with the human path's code.
 // `compact` (v1.9.1 B1) writes the answer with no indentation: a `--brief`
 // answer is read by a model, and the card inside it carries its own newlines.
 function emitJson(obj, exitCode, compact) {
+  // v2.0.0 T20 — an in-process probe (`orc lane config` `probes{}`) takes the
+  // object instead of stdout. Outside a probe this line does nothing.
+  if (PROBE_CAPTURE) {
+    PROBE_CAPTURE.obj = obj;
+    if (exitCode !== undefined) process.exit(exitCode);
+    return;
+  }
   writeStdoutSync((compact ? JSON.stringify(obj) : JSON.stringify(obj, null, 2)) + "\n");
   if (exitCode !== undefined) process.exit(exitCode);
 }
@@ -239,7 +264,7 @@ function installGuards(claudeDir) {
       // EW3: the graph hook shells `orc graph update`, and a hook must never
       // guess at PATH — the installer is the one place that knows for certain
       // which cli.js this payload came from.
-      JSON.stringify({ version: currentVersion(), cli: path.resolve(__dirname, "cli.js") }) + "\n"
+      JSON.stringify({ version: currentVersion(), cli: path.resolve(__dirname, "cli.js"), catalog_hash: slCatalogHash() }) + "\n"
     );
   } catch (_) {}
   // The statusline's phase rail (v1.2.1). Regenerated every install from the
@@ -427,6 +452,35 @@ function installGuards(claudeDir) {
   wireGraph("PreToolUse", "Bash|Read");
   wireGraph("PostToolUse", "Read");
 
+  // 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
+  // `notify: bell` (default off: the hook reads the key and returns, so an
+  // unarmed bell is byte-identical to not having it — the read-gate rule).
+  // `SessionStart` on `compact` prints ONE line naming the run's
+  // state-of-play.md while a run is in flight. Same (event, matcher) match as
+  // the graph hook, so re-running `orc update` changes nothing.
+  const sessionHookCmd = nodeCmd(path.join(hooksDest, "orc-session-hook.js"));
+  const wireSession = (arrName, matcher) => {
+    settings.hooks[arrName] = settings.hooks[arrName] || [];
+    for (const entry of settings.hooks[arrName]) {
+      if ((entry.matcher || null) !== (matcher || null)) continue;
+      for (const h of entry.hooks || []) {
+        if (typeof h.command === "string" && h.command.includes("orc-session-hook")) {
+          h.command = sessionHookCmd;
+          return;
+        }
+      }
+    }
+    const entry = { hooks: [{ type: "command", command: sessionHookCmd }] };
+    if (matcher) entry.matcher = matcher;
+    settings.hooks[arrName].push(entry);
+    console.log(`  add   settings.json → ${arrName} session hook${matcher ? ` (${matcher})` : ""}`);
+  };
+  wireSession("Stop", null);
+  wireSession("SessionStart", "compact");
+  // v2.0.2 (eval D13): the reviewer / verifier / judge get the gotcha card here.
+  wireSession("SubagentStart", null);
+
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 
@@ -721,6 +775,7 @@ function install({ overwrite, forcePrune }) {
   }
 
   installGuards(claudeDir);
+  slRecompileInstalled(claudeDir);
 
   // Record ORC's footprint, then (on update only) prune files that left the
   // payload. A fresh init has nothing to prune; update diffs against the
@@ -1072,6 +1127,8 @@ const KNOWN_MODELS = [
   "claude-opus-5",
   "claude-opus-4-8",
   "claude-opus-4-7",
+  "claude-sonnet-5-5",
+  // Kept so a config written before v2.1.0 still validates.
   "claude-sonnet-5",
   "claude-sonnet-4-6",
   "claude-haiku-4-5",
@@ -1130,6 +1187,15 @@ const vFallbackAgent = tag((raw) => {
       "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"] });
+// 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.
+const vHabits = tag((raw) => {
+  const v = String(raw || "").trim();
+  if (v === "auto")
+    return { err: "`auto` is not a habits level. ORC never applies a habit without your yes. Use off, observe or propose." };
+  return ["off", "observe", "propose"].includes(v) ? { value: v } : { err: "must be one of: off, observe, propose" };
+}, { kind: "enum", choices: ["off", "observe", "propose"] });
 const vPath = tag(
   (raw) => (raw && raw.trim() ? { value: raw } : { err: "must be a non-empty path" }),
   { kind: "path" }
@@ -1161,6 +1227,26 @@ const vRepo = tag(
       : { err: "must be a GitHub owner/repo (e.g. azure-id/orc)" },
   { kind: "repo" }
 );
+// v2.0.0 W4 — the reviewer card budget. Refused BY NAME below the floor: the
+// budget is a size, and review learning has no off switch (DE-10).
+const vCardBudget = tag((raw) => {
+  const n = Number(raw);
+  if (!Number.isInteger(n)) return { err: "gotcha_card_budget must be an integer >= 200" };
+  if (n < 200)
+    return { err: `gotcha_card_budget must be 200 or more (got ${n}). It is the SIZE of the reviewer card, not an off switch — review learning is always on` };
+  return { value: n };
+}, { kind: "int", min: 200 });
+// An optional one-word value: empty clears it.
+const vOptText = tag((raw) => {
+  const s = String(raw == null ? "" : raw).trim();
+  if (/\s/.test(s)) return { err: "must be one word (no spaces)" };
+  return { value: s };
+}, { kind: "text" });
+const vSonarUrl = tag((raw) => {
+  const s = String(raw == null ? "" : raw).trim().replace(/\/+$/, "");
+  if (s && !/^https?:\/\/[^\s/]+(\/\S*)?$/.test(s)) return { err: "must be an http(s) URL (e.g. https://sonarcloud.io)" };
+  return { value: s };
+}, { kind: "text" });
 
 // Roles `orc extra` may hand to a non-Claude worker. Declared HERE, above
 // CONFIG_META, because CONFIG_META is evaluated at module load and a `const`
@@ -1169,6 +1255,8 @@ const vRepo = tag(
 // and no "forever": "forever" is the option that makes every other one
 // pointless, and a deadline that renews itself on use is not a deadline.
 const EXTRA_TTL_DAYS = [1, 3, 7, 14, 30, 90, 180, 360];
+// v2.1.0 — the closed set `orc clear logs --older-than` and `log_retention_days` take.
+const LOG_RETENTION_DAYS = [30, 60, 90, 120, 240, 360];
 const EXTRA_ROLES_ALL = [
   "executor",
   "reviewer",
@@ -1319,6 +1407,14 @@ const CONFIG_FAMILIES = {
   // structure costs no model tokens, so nothing about a dispatched model can
   // shadow whether it is built.
   graph: { contested: false, question: "whether code lanes build and read a local map of how the repo is connected" },
+  // v2.0.0 W2 — habits. UNCONTESTED: an accepted habit is not a key, it is the
+  // `learned` RANK under your config file (bin/habit.js), so nothing here
+  // competes with anything. `offers` holds the end-of-run offers a habit can
+  // answer; before 2.0.0 no key existed, so nothing could remember them.
+  habits: { contested: false, question: "whether ORC learns your usual answers and proposes them — never applied without your yes" },
+  offers: { contested: false, question: "which offers a lane still asks after the work, and which your setting answers" },
+  notify: { contested: false, question: "whether a turn of an ORC run ends with the terminal bell" },
+  rules: { contested: false, question: "how large the rules card is in an executor slice" },
 };
 
 // Ordered, tiered metadata. Common first, then advanced.
@@ -1348,6 +1444,15 @@ const CONFIG_META = [
   { key: "pattern_findings", def: "ask", tier: "common", answers: [{ family: "patterns", prio: "P2", mode: "replace" }], lanes: ["orc", "orc-pattern", "orc-wiki"], validate: vEnum("ask", "on", "off"), options: ["ask", "on", "off"], desc: "Code-pattern gate on an FE/BE cache miss: ask = prompt, on = auto-codify, off = always agnostic." },
   { key: "gotchas", def: "on", tier: "common", answers: [{ family: "gotchas", prio: "P2", mode: "replace" }], lanes: ["orc", "orc-brainstorm", "orc-claude", "orc-diy", "orc-doc", "orc-fast", "orc-learn", "orc-mini", "orc-retro", "orc-wiki"], validate: vEnum("on", "off"), options: ["on", "off"], desc: "Repair memory: record a gotcha when a repair loop goes red → green, and inject the scope-matching ones into executor slices. Never injected unfiltered; see .claude/orc/gotchas.md." },
   { key: "gotchas_max", def: 40, tier: "common", answers: [{ family: "gotchas", prio: "P2", mode: "replace" }], lanes: ["orc"], validate: vInt(5), options: [20, 40, 60, 100], desc: "Live gotcha entries kept before the lowest-value tail is archived to gotchas-archive.md (never deleted)." },
+  // --- v2.0.0 W4 — the gotchas engine (bin/gotcha.js) ---------------------------
+  // Read by the CLI (`orc gotcha card`, `import`, `sync`), never by a spine,
+  // so each `lanes[]` is empty and each key is on the seed-empty allowlist.
+  // Review learning is ALWAYS ON (DE-10): the budget is a SIZE, never a switch.
+  { key: "gotcha_card_budget", def: 600, tier: "common", answers: [{ family: "gotchas", prio: "P2", mode: "replace" }], lanes: [], validate: vCardBudget, options: [200, 400, 600, 900], desc: "The size of the reviewer card from `orc gotcha card`, in tokens. It is a SIZE, never an off switch: review learning is always on. The minimum is 200; a lower value is refused. Entries that do not fit are COUNTED in the card header, never dropped in silence." },
+  { key: "gotcha_sync_hours", def: 6, tier: "advanced", answers: [{ family: "gotchas", prio: "P2", mode: "replace" }], lanes: [], validate: vInt(1), options: [1, 6, 24], desc: "How old the last `orc gotcha sync` may be before the next review step runs it again." },
+  { key: "sonar_url", def: "", tier: "advanced", answers: [{ family: "gotchas", prio: "P2", mode: "replace" }], lanes: [], validate: vSonarUrl, desc: "The SonarQube / SonarCloud base URL for `orc gotcha import sonar` (e.g. https://sonarcloud.io). The token is NEVER a key: set SONAR_TOKEN in the environment." },
+  { key: "sonar_project", def: "", tier: "advanced", answers: [{ family: "gotchas", prio: "P2", mode: "replace" }], lanes: [], validate: vOptText, desc: "The Sonar project key for `orc gotcha import sonar`, so the import needs no flags." },
+  { key: "sonar_org", def: "", tier: "advanced", answers: [{ family: "gotchas", prio: "P2", mode: "replace" }], lanes: [], validate: vOptText, desc: "The SonarCloud organization for `orc gotcha import sonar` (empty for a self-hosted SonarQube)." },
   { key: "security_review", def: "off", tier: "common", answers: [{ family: "security", prio: "P2", mode: "replace" }], lanes: ["orc"], validate: vEnum("off", "ask", "on"), options: ["off", "ask", "on"], desc: "Opt-in Phase 5.5 security pass on runs with a task scored >= 70 (risk floor). OFF by default." },
   { key: "run_budget_dispatches", def: 0, tier: "common", answers: [{ family: "waves", prio: "P2", mode: "replace" }], lanes: ["orc", "orc-budget"], validate: vInt(0), options: [0, 8, 12, 20, 30], desc: "Subagent budget for one run. The Phase-1 forecast estimates how many subagents the run will dispatch; if that exceeds this number the run STOPS before wave 1 (a hard gate like the batch pause, not a hint) and offers proceed / a cheaper lane / re-plan smaller. 0 = off, nothing changes." },
   { key: "mock_example", def: "ask", tier: "common", answers: [{ family: "mock", prio: "P2", mode: "replace" }], lanes: ["orc", "orc-brainstorm", "orc-diy", "orc-fast", "orc-grill", "orc-mini"], validate: vEnum("ask", "on", "off"), options: ["ask", "on", "off"], desc: "Post-verify mocked runnable example (mock-examples/<slug>/, never committed): ask = offer after a green verify, on = always, off = never." },
@@ -1395,6 +1500,11 @@ const CONFIG_META = [
   // v1.8.2 W2 (G8) — the key the engine already understood and no config
   // exposed. Same `lanes: []` reason as every graph key: the CLI reads it.
   { key: "code_graph_ignore", def: "", tier: "advanced", answers: [{ family: "graph", prio: "P2", mode: "replace" }], gated_by: "code_graph", lanes: [], validate: vGlobs, options: ["", "vendor/**", "generated/**,*.gen.ts"], desc: "Extra paths the graph never indexes, as a comma-separated list of globs relative to the repository root (`vendor/**,generated/**,*.gen.ts`). The engine always skips node_modules, vendor, dist/build at the root, caches, bundles, `.d.ts` and generated files; this adds to that list. A skipped file is reported `excluded` by `orc graph coverage`, never silently. Empty = nothing extra." },
+  // v2.1.0 (DE-21) — WRITE-THROUGH. The value lives in settings.json
+  // (`statusLine.refreshInterval`), never in orc.config.yaml: `config set` calls
+  // the same core as `orc statusline refresh`, and `config list` READS it back,
+  // so the two can never disagree. 0.2 / 0.5 / 0.7 are below Claude Code's floor.
+  { key: "statusline_refresh", def: "off", tier: "advanced", answers: [{ family: "statusline", prio: "P2", mode: "replace" }], lanes: [], validate: vEnum("off", "1", "2", "3", "5", "10"), options: ["off", "1", "2", "3", "5", "10"], desc: "How often the status line redraws when nothing happens, in seconds (off = only on events). Written straight into the settings.json that holds ORC's hook (statusLine.refreshInterval) — the same as `orc statusline refresh <n>`. Claude Code runs the line at most once a second, so 0.2, 0.5 and 0.7 are refused. The timer ticks for every teammate who shares that settings file." },
   { key: "statusline_custom", def: "off", tier: "common", answers: [{ family: "statusline", prio: "P2", mode: "replace" }], lanes: [], validate: vEnum("off", "on"), options: ["off", "on"], desc: "Whether the status line renders YOUR composed layout instead of the shipped two lines. Off is byte-identical to what ships. Compose the layout in `orc ui` > CLI Hook Interface (the CLI half exists so the panel has something to shell). Turning this on with an invalid or missing layout is refused, naming the reason; a layout that later becomes unreadable falls back to the shipped lines silently and is reported by `orc doctor`." },
   { key: "wait_hop_minutes", def: 30, tier: "advanced", answers: [{ family: "wait", prio: "P2", mode: "replace" }], lanes: [], validate: vInt(1), options: [5, 10, 15, 30], desc: "How long ONE detached hop waits before ORC re-reads the window. Short on purpose: each wake-up is session activity, and session activity is the only thing that makes the statusline write a fresh reading. One long sleep wakes into a reading as stale as the sleep was long." },
   { key: "wait_max_hops", def: 5, tier: "advanced", answers: [{ family: "wait", prio: "P2", mode: "replace" }], lanes: [], validate: vInt(1), options: [1, 2, 3, 5, 8, 12], desc: "How many hops before ORC gives up and stops with the hand-back. A wrong reset time must cost you a bounded wait, never a session that never comes back." },
@@ -1442,7 +1552,7 @@ const CONFIG_META = [
   // decision with a recorded reason (the /orc-pact retirement rule).
   { key: "extra_demote_after", def: 2, tier: "common", answers: [{ family: "extra", prio: "P2", mode: "replace" }], gated_by: "extra_enabled", lanes: [], validate: vInt(0), options: [0, 2, 3, 5], desc: "Consecutive `stalled` dispatches on ONE profile, inside one run, before that profile is DEMOTED to the bottom of the ladder for the rest of the run — so `opus5_only` (or the shipped score table) becomes the effective P0 and the work stays on Claude. Only `stalled` counts: a 401 or a rate limit has its own answer (`extra_on_failure`, the vault, `extra_resume`), and demoting on one would hide a credential problem behind a routing change. A resume of the same stalled attempt is the SAME stall, never a second one. A demotion is RUN state — it never writes your config — it is ANNOUNCED before the next dispatch, and it is never auto-promoted back: `orc extra promote <run> --reason \"<why>\"`. 0 turns this clock off and leaves only extra_demote_stale_min." },
   { key: "extra_demote_stale_min", def: 20, tier: "common", answers: [{ family: "extra", prio: "P2", mode: "replace" }], gated_by: "extra_enabled", lanes: [], validate: vInt(0), options: [0, 10, 20, 45], desc: "Minutes a LIVE foreign attempt may show no observable progress before its profile is demoted. This is a different question from `extra_stall_s`, which stops ONE dispatch after 180s of silence: this clock is about the RUN — two workers in flight, both quiet, and a wave that is going nowhere — so the two have their own budgets and their own off values and neither is a simplification of the other. It reads the journal's own progress file on disk, never a remembered fact. 0 turns this clock off and leaves only extra_demote_after." },
-  { key: "opus5_only", def: false, tier: "common", answers: [{ family: "executor-band", prio: "P1", mode: "replace" }, { family: "fixed-role-model", prio: "P1", mode: "replace" }], lanes: ["orc", "orc-analyze", "orc-challenge", "orc-claude", "orc-diy", "orc-doc", "orc-fast", "orc-mini", "orc-pattern", "orc-quick", "orc-retro", "orc-wiki"], validate: vEnum("true", "false"), options: ["true", "false"], desc: "EVERY dispatched role uses ONE model — Opus 5.5 — with EFFORT as the cost dial (executors: [0,40) low · [40,80) medium · [80,100] high; each fixed role its own pinned effort). Deep SWE-benchmark work on cost vs efficiency across Claude models finds a single Opus 5.5 agent with the effort ladder the most efficient setup. It FORCES: while on it outranks a hand-written rubric_bands_override. Needs an Opus 5.5 main session or EVERY dispatch silently downgrades. Excludes the Haiku trace writer and orc-diy (compile-owned)." },
+  { key: "opus5_only", def: false, tier: "common", answers: [{ family: "executor-band", prio: "P1", mode: "replace" }, { family: "fixed-role-model", prio: "P1", mode: "replace" }], lanes: ["orc", "orc-analyze", "orc-challenge", "orc-claude", "orc-diy", "orc-doc", "orc-fast", "orc-mini", "orc-pattern", "orc-quick", "orc-retro", "orc-wiki"], validate: vEnum("true", "false"), options: ["true", "false"], desc: "EVERY dispatched role uses ONE model — Opus 5.5 — with EFFORT as the cost dial (executors: [0,90) low · [90,100] medium; each fixed role its own pinned effort). Deep SWE-benchmark work on cost vs efficiency across Claude models finds a single Opus 5.5 agent with the effort ladder the most efficient setup. It FORCES: while on it outranks a hand-written rubric_bands_override. Needs an Opus 5.5 main session or EVERY dispatch silently downgrades. Excludes the Haiku trace writer and orc-diy (compile-owned)." },
   // --- v0.46.0 — the six new lanes ------------------------------------------
   { key: "pact_gate", def: "warn", tier: "common", answers: [{ family: "pact", prio: "P2", mode: "replace" }], lanes: ["orc", "orc-pact"], validate: vEnum("off", "warn"), options: ["off", "warn"], desc: "Invariant ledger at Phase 1 + planning: warn = print the one pact line and inject a DRIFTED/BROKEN promise whose anchors intersect the plan's declared files as a planner constraint; off = nothing. NEVER blocks — a promise is advice with a receipt, not a gate. See /orc-pact." },
   { key: "pact_recheck_on_verify", def: "true", tier: "common", answers: [{ family: "pact", prio: "P2", mode: "replace" }], lanes: ["orc", "orc-pact"], validate: vEnum("true", "false"), options: ["true", "false"], desc: "Phase 6: re-run the cheap checks for ONLY the invariants the change touched (`orc pact check`), so a promise that just leaked is caught in the run that broke it." },
@@ -1477,7 +1587,23 @@ const CONFIG_META = [
   { key: "test_max_rps", def: 4, tier: "common", answers: [{ family: "test", prio: "P2", mode: "replace" }], lanes: [], validate: vInt(1), options: [1, 2, 4, 8], desc: "Requests per second the runner is allowed to send, with a fixed small concurrency beside it. The CLI PACES — this is not a suggestion, because ORC's own run must never be the incident. A 429 is a RESULT and not an error: it means rate limiting works, so the runner records it and backs off rather than pushing through." },
   { key: "test_case_budget", def: 200, tier: "common", answers: [{ family: "test", prio: "P2", mode: "replace" }], lanes: ["orc-test"], validate: vInt(1), options: [50, 100, 200, 500], desc: "Cases one run may expand to before it STOPS expanding. A PLANNED stop, not an interrupt (the wiki_refresh_budget shape): the matrix is combinatorial, and a run that silently grows to 4,000 cases against a staging box is a denial of service you wrote yourself. On reaching it the CLI names the targets it did not finish and offers `--budget`." },
   { key: "test_ui_driver", def: "playwright", tier: "common", answers: [{ family: "test", prio: "P2", mode: "replace" }], lanes: ["orc-test"], validate: vEnum("playwright", "none"), options: ["playwright", "none"], desc: "What drives the front-end half. `playwright` authors a journey SCRIPT and runs it — a step an LLM took is not a step you can re-run, and the artifacts (trace.zip, video, HAR) are the evidence. `none` skips the FE half entirely. ORC ships zero dependencies and NEVER installs Playwright into your project: an absent driver is a STATE with a named install command, not a failure." },
+  // --- v2.0.0 W2 — habits (bin/habit.js) -------------------------------------
+  // `habits` is read by the CLI, never by a lane: `orc lane config` resolves it
+  // and hands the lane a `habits{}` block (the `code_graph` answer). The other
+  // three are the offers a habit can answer; W3 wires the lanes that read them,
+  // so their `lanes[]` is empty until then. OFF by default, and off is
+  // specified as ZERO BYTES in `orc lane config` — that is a test.
+  { key: "habits", def: "off", tier: "common", answers: [{ family: "habits", prio: "P2", mode: "replace" }], lanes: [], validate: vHabits, options: ["off", "observe", "propose"], desc: "Whether ORC learns the answers you give to its questions, from the ASK lines in your run traces. off = nothing is read and nothing changes (the default). observe = ORC computes your usual answers and shows them in `orc habit show`, and never proposes one. propose = at the END of a run, at most once, ORC asks whether an answer you keep giving should become your usual. NOTHING is applied without your yes, and there is no automatic level. An accepted habit is the `learned` rank, below your own config file: `orc config set` always wins, and `orc habit forget <id>` undoes it." },
+  { key: "review_before_push", def: "ask", tier: "common", answers: [{ family: "offers", prio: "P2", mode: "replace" }], lanes: [], validate: vEnum("ask", "on", "off"), options: ["ask", "on", "off"], desc: "Whether a lane offers a code review before it pushes. ask = offer it (the default), on = always review first, off = never offer it. A habit can learn only `on`." },
+  { key: "mini_tdd", def: "ask", tier: "common", answers: [{ family: "testing", prio: "P2", mode: "replace" }], lanes: [], validate: vEnum("ask", "on", "off"), options: ["ask", "on", "off"], desc: "Whether /orc-mini asks at intake for a test-driven loop. ask = ask (the default), on = always use it, off = never. A habit can learn only `on`." },
+  { key: "quick_update_tests", def: "ask", tier: "common", answers: [{ family: "offers", prio: "P2", mode: "replace" }], lanes: [], validate: vEnum("ask", "on"), options: ["ask", "on"], desc: "Whether /orc-quick offers to update the tests after a code change. ask = offer it (the default), on = always update them. There is no `off`: tests are the careful side. It affects only the offer after the work, never the dispatch gate." },
+  // v2.0.0 W6c — Q8. The terminal bell when a turn of an ORC run ends. The hook is
+  // wired always and reads this key first, so off is byte-identical to no hook.
+  { key: "notify", def: "off", tier: "common", answers: [{ family: "notify", prio: "P2", mode: "replace" }], lanes: [], validate: vEnum("off", "bell"), options: ["off", "bell"], desc: "Whether the installed session hook rings the terminal bell when a turn of an ORC run ends. off = silent (the default). bell = one bell through the Stop hook, only while an ORC run is open in this session and only when the run moved since the last bell, so a normal chat never rings. No OS notification and no network." },
   { key: "doc_dir", def: DOC_DIR_DEFAULT, tier: "advanced", answers: [{ family: "paths", prio: "P2", mode: "replace" }], lanes: ["orc-doc"], validate: vPath, desc: "Where /orc-doc folders live. Project root, not .claude/ — a document is a deliverable a human opens, and the same call /orc-quick, /orc-brainstorm and poly-repo-implementation/ already made." },
+  // v2.0.0 W6c — DE-17. The compact rules card for orc-mini / orc-fast executors.
+  // OFF until eval E4 passes (eval/results/2.0.0/E4.md); off = today's card, byte for byte.
+  { key: "rules_card_compact", def: "on", tier: "advanced", answers: [{ family: "rules", prio: "P2", mode: "replace" }], lanes: [], validate: vEnum("off", "on"), options: ["off", "on"], desc: "Whether `orc rules slice` builds the COMPACT rules card for the orc-mini and orc-fast lanes too (orc-quick always gets it). The compact card keeps every rule id and the first line of each HARD rule, and drops the worked examples. on (the default since v2.0.2 — eval E4 passed: no new unmet[] items, no new rules_conflicts[], the smoke gate green on the first try at least as often). off = the full card, byte-identical to 2.0.0." },
   { key: "wiki_scan_tier", def: "ladder", tier: "advanced", answers: [{ family: "wiki", prio: "P2", mode: "replace" }], lanes: ["orc-wiki"], validate: vEnum("ladder", "always_deep"), desc: "Wiki scan tier: ladder picks light/deep per delta (first scan, STRUCTURAL, wide delta or a new exported symbol → deep; otherwise light), always_deep restores pre-v0.46.0 behaviour. The resolved tier is always printed — a cheaper model is never a quiet substitution." },
   { key: "wiki_tier_deep_files", def: 3, tier: "advanced", answers: [{ family: "wiki", prio: "P2", mode: "replace" }], lanes: ["orc-wiki"], validate: vInt(1), desc: "Covered files touched at or above this count send the refresh to the DEEP scanner." },
   { key: "wiki_refresh_budget", def: 0, tier: "advanced", answers: [{ family: "wiki", prio: "P2", mode: "replace" }], lanes: ["orc-wiki"], validate: vInt(0), desc: "Max scan-tasks per refresh run; 0 = no cap. A capped refresh is a PLANNED stop, not an interrupt: sync has already run, so the wiki is registered and consistent, and the remaining docs are AGING, not broken. Separate from the fixed pause-every-5 rule — do not merge them." },
@@ -1494,7 +1620,9 @@ const CONFIG_META = [
   { key: "wiki_refresh_ask_tasks", def: 3, tier: "advanced", answers: [{ family: "wiki", prio: "P2", mode: "replace" }], lanes: ["orc", "orc-wiki"], validate: vInt(1), desc: "Post-ship wiki refresh ask fires when the run's task count >= this." },
   { key: "wiki_refresh_ask_files", def: 10, tier: "advanced", answers: [{ family: "wiki", prio: "P2", mode: "replace" }], lanes: ["orc", "orc-wiki"], validate: vInt(1), desc: "…or when the run's touched-file count exceeds this (full/ultra lanes)." },
   { key: "retro_repo", def: "azure-id/orc", tier: "advanced", answers: [{ family: "retro", prio: "P2", mode: "replace" }], lanes: ["orc", "orc-retro"], validate: vRepo, desc: "GitHub owner/repo that receives /orc-retro reports (PR preferred, issue fallback)." },
-  { key: "log_dir", def: ".claude/orc/logs", tier: "advanced", answers: [{ family: "paths", prio: "P2", mode: "replace" }], lanes: ["context-combiner", "orc", "orc-aftermath", "orc-analyze", "orc-analyze-mini", "orc-boundary", "orc-brainstorm", "orc-budget", "orc-challenge", "orc-claude", "orc-diy", "orc-doc", "orc-explain", "orc-export", "orc-fast", "orc-grill", "orc-handoff", "orc-learn", "orc-mini", "orc-pact", "orc-pattern", "orc-poly", "orc-pr-driver", "orc-pr-setup", "orc-quick", "orc-retro", "orc-route", "orc-verify", "orc-wiki"], validate: vPath, desc: "Persistent trace folder (never auto-deleted)." },
+  { key: "log_dir", def: ".claude/orc/logs", tier: "advanced", answers: [{ family: "paths", prio: "P2", mode: "replace" }], lanes: ["context-combiner", "orc", "orc-aftermath", "orc-analyze", "orc-analyze-mini", "orc-boundary", "orc-brainstorm", "orc-budget", "orc-challenge", "orc-claude", "orc-diy", "orc-doc", "orc-explain", "orc-export", "orc-fast", "orc-fix", "orc-grill", "orc-handoff", "orc-learn", "orc-mini", "orc-pact", "orc-pattern", "orc-poly", "orc-pr-driver", "orc-pr-setup", "orc-quick", "orc-retro", "orc-route", "orc-verify", "orc-wiki"], validate: vPath, desc: "Persistent trace folder. Kept until you run `orc clear logs --apply`, or until the automatic sweep removes it (`log_retention_auto: on`, older than `log_retention_days`)." },
+  { key: "log_retention_days", def: 90, tier: "advanced", answers: [{ family: "paths", prio: "P2", mode: "replace" }], lanes: [], validate: vEnum(...LOG_RETENTION_DAYS.map(String)), options: LOG_RETENTION_DAYS, desc: "The age `orc clear logs` deletes at: finished traces and finished run folders (with their `refs/orc/runs/<slug>/pre` ref) whose LAST activity is older than this many days. It never deletes user data, a waiting run, the active trace, or a file younger than 6 hours. A trace with an ASK line stays for 180 days (habit evidence), and the cutoff never goes below `aftermath_window_days`." },
+  { key: "log_retention_auto", def: "off", tier: "advanced", answers: [{ family: "paths", prio: "P2", mode: "replace" }], lanes: [], validate: vEnum("off", "on"), options: ["off", "on"], desc: "on = `orc trace write` runs `orc clear logs --apply` after a lane's FINISH packet, at most once per 24 hours, and writes `last_sweep` into logs-rollup.json. It never blocks a run and never changes the exit code. off (the default) = nothing is deleted unless you run the command." },
   { key: "run_dir", def: RUN_DIR_DEFAULT, tier: "advanced", answers: [{ family: "paths", prio: "P2", mode: "replace" }], lanes: ["orc", "orc-challenge", "orc-doc", "orc-pact"], validate: vPath, desc: "Run artifact root (checkpoints/state-of-play) — outside the installer's blast radius." },
   { key: "analyzer_dir", def: ".claude/skills/orc/analyzer", tier: "advanced", answers: [{ family: "paths", prio: "P2", mode: "replace" }], lanes: ["orc", "orc-analyze"], validate: vPath, desc: "Internal analyst artifact dir." },
   { key: "planner_dir", def: ".claude/skills/orc/planner", tier: "advanced", answers: [{ family: "paths", prio: "P2", mode: "replace" }], lanes: ["orc"], validate: vPath, desc: "Internal planner artifact dir." },
@@ -1827,7 +1955,7 @@ function groupRule(title) {
 // `not-read`: a higher rank in this key's family resolved, so nobody looked;
 // `inert`: this key's master gate is off, which removes it from the
 // conversation rather than losing it a precedence contest (`design-03` §5).
-function configKeyState(m, map, claudeDir) {
+function configKeyState(m, map, claudeDir, learned) {
   const has = Object.prototype.hasOwnProperty.call(map, m.key);
   if (m.gated_by) {
     const g = metaFor(m.gated_by);
@@ -1841,18 +1969,48 @@ function configKeyState(m, map, claudeDir) {
   }
   const why = shadowReason(m.key, map, claudeDir);
   if (why) return { state: "not-read", reason: why, source: has ? "overridden" : "default" };
+  // v2.0.0 W2 — the `learned` rank: below the file, above the shipped default.
+  const l = !has && learned && learned[m.key];
+  if (l)
+    return {
+      state: "learned",
+      reason: `learned from habit ${l.id} (${l.count} of ${l.total}) — undo: orc habit forget ${l.id}`,
+      source: `learned:${l.id}`,
+      value: l.value,
+    };
   return { state: has ? "overridden" : "default", reason: null, source: has ? "overridden" : "default" };
 }
 
+// The learned values in force project-wide, or {} under `habits: off`.
+function configLearned(map, claudeDir) {
+  const H = require("./habit.js");
+  if (H.habitsMode(map) === "off") return {};
+  try {
+    return H.learnedFor(claudeDir, habitDeps(), map, null);
+  } catch (_) {
+    return {};
+  }
+}
+
 const STATE_PAINT = {
   overridden: (s) => ui.color.green(s),
   default: (s) => ui.color.gray(s),
   "not-read": (s) => ui.color.yellow(s),
   inert: (s) => ui.color.yellow(s),
+  learned: (s) => ui.color.cyan(s),
 };
 
+// v2.1.0 (DE-21) — a write-through key is READ from where it lives.
+function withLiveKeys(map, claudeDir) {
+  try {
+    const v = slRefreshInterval(slHookInfo(claudeDir, SL_BOARDS.status), SL_BOARDS.status);
+    map.statusline_refresh = v == null ? "off" : String(v);
+  } catch (_) {}
+  return map;
+}
 function configList(claudeDir) {
-  const { path: p, map } = readOverride(claudeDir);
+  const { path: p, map: raw } = readOverride(claudeDir);
+  const map = withLiveKeys(Object.assign({}, raw), claudeDir);
   console.log(
     `\nORC config  (override: ${p}${fs.existsSync(p) ? "" : "  — not created yet"})\n`
   );
@@ -1863,6 +2021,7 @@ function configList(claudeDir) {
   // UI axis and it still drives the interactive menu, so it rides along as a row
   // marker instead of being the table's spine.
   const families = laneFamilies(null, map, claudeDir);
+  const learned = configLearned(map, claudeDir);
   const byFamily = new Map();
   for (const m of CONFIG_META) {
     const f = m.answers[0].family;
@@ -1891,9 +2050,9 @@ function configList(claudeDir) {
         return (ra === -1 ? 99 : ra) - (rb === -1 ? 99 : rb);
       });
     for (const m of metas) {
-      const st = configKeyState(m, map, claudeDir);
+      const st = configKeyState(m, map, claudeDir, learned);
       const has = Object.prototype.hasOwnProperty.call(map, m.key);
-      const val = has ? map[m.key] : m.def;
+      const val = has ? map[m.key] : st.value !== undefined ? st.value : m.def;
       const src = (STATE_PAINT[st.state] || ((s) => s))(st.state.padEnd(10));
       const opts = m.options ? ` ${ui.color.gray("[options: " + m.options.join(" | ") + "]")}` : "";
       // v0.55.0 — a DEPRECATED member of a live key is marked on the row that
@@ -1923,7 +2082,7 @@ function configList(claudeDir) {
     } catch (_) {}
     console.log(ui.header("Resolve order  (highest wins)"));
     console.log(
-      "\n  extra route row  >  opus5_only  >  rubric_bands_override  >  the default 6-band table\n"
+      "\n  extra route row  >  opus5_only  >  rubric_bands_override  >  the default 5-band table\n"
     );
     if (rows.length)
       console.log(
@@ -2085,7 +2244,7 @@ function shadowReason(key, map, claudeDir) {
 // v1.0.0 W4 — TWO BANDS, not three, and the same 90 edge as the default table's
 // top two rows (D13). That symmetry is the point: once the default table's high
 // end is already Opus 5.5 with effort as the dial, the forcing mode differs from
-// it only BELOW 65, so a third band here would be a distinction the default
+// it only BELOW 41 (v2.1.0; it was 65), so a third band here would be a distinction the default
 // table stopped making.
 //
 // THIS IS THE ONLY COPY. Until W4 there were two arrays with these rows in this
@@ -2127,7 +2286,7 @@ function scoreTableJson(map, claudeDir) {
   //   an extra route row covering this score  (only for the scores it covers)
   //     > opus5_only
   //     > rubric_bands_override
-  //     > the default 6-band table
+  //     > the default 5-band table
   //
   // Extra is an OVERLAY, not a replacement, which is what makes "cheap grunt
   // work goes to DeepSeek, hard work stays on Opus 5.5" a two-command setup
@@ -2193,12 +2352,14 @@ function scoreTableJson(map, claudeDir) {
 // things only a renderer needs: the control shape (derived from the validator),
 // whether another key shadows this one, and the resolved score ladder.
 function configListJson(claudeDir) {
-  const { path: p, map } = readOverride(claudeDir);
+  const { path: p, map: raw } = readOverride(claudeDir);
+  const map = withLiveKeys(Object.assign({}, raw), claudeDir);
   const has = (k) => Object.prototype.hasOwnProperty.call(map, k);
+  const learned = configLearned(map, claudeDir);
   const keys = CONFIG_META.map((m) => {
     const v = m.validate || {};
     const why = shadowReason(m.key, map, claudeDir);
-    const st = configKeyState(m, map, claudeDir);
+    const st = configKeyState(m, map, claudeDir, learned);
     return {
       key: m.key,
       tier: m.tier,
@@ -2217,7 +2378,7 @@ function configListJson(claudeDir) {
       // The master gate that makes this key inert. A gate does not win a
       // precedence contest; it removes its dependants from the conversation.
       gated_by: m.gated_by || null,
-      value: has(m.key) ? map[m.key] : m.def,
+      value: has(m.key) ? map[m.key] : st.value !== undefined ? st.value : m.def,
       default: m.def,
       is_overridden: has(m.key),
       is_shadowed: !!why,
@@ -2228,7 +2389,7 @@ function configListJson(claudeDir) {
       // answers "does anything read it", from `LANE_RANK_STATES`' own words.
       state: st.state,
       state_reason: st.reason,
-      source: has(m.key) ? "overridden" : "default",
+      source: st.source,
       desc: m.desc,
       options: m.options || null,
       control: {
@@ -2292,7 +2453,7 @@ function configListJson(claudeDir) {
     // lane-scoped answer asks `orc lane config <lane> --json`, which is the
     // command that owns it.
     families_resolved: laneFamilies(null, map, claudeDir),
-    rank_states: LANE_RANK_STATES,
+    rank_states: require("./habit.js").habitsMode(map) !== "off" ? LANE_RANK_STATES.concat("learned") : LANE_RANK_STATES,
     // Permanently on and deliberately not a key — say so, or a reader hunts for
     // the switch (only the folder is configurable).
     behavior_trace: { always_on: true, configurable_key: "log_dir" },
@@ -2333,6 +2494,16 @@ function configSet(claudeDir, key, rawValue) {
     process.exit(1);
   }
   if (res.warn) console.error(`  ${res.warn}`);
+  if (key === "statusline_refresh") {
+    const v = String(res.value);
+    const r = slRefreshApply(claudeDir, SL_BOARDS.status, v === "off" ? null : Number(v));
+    if (!r.ok) {
+      console.error(`❌ ${r.hint}`);
+      process.exit(1);
+    }
+    console.log(`  ${ui.mark.ok(`statusline_refresh = ${v} (written to ${r.settings})`)}`);
+    return;
+  }
   // W8 (v0.51.0) — THE SETUP GATE. `extra_enabled` is the master switch on a
   // subsystem that sends this repo's source code to a third party, and arming it
   // before any connection has ever answered arms nothing: every dispatch falls
@@ -2358,6 +2529,14 @@ function configSet(claudeDir, key, rawValue) {
   // precedent: a renamed mechanism must never be a silent revert.
   if (key === "extra_roles") extraLegacyRoleWarn(res.value);
   if (key === "opus5_only") opus5Notice(String(res.value) === "true", claudeDir);
+  // DE-27 — the v0.40.0 key stays so an existing file is never silently
+  // overridden, but it is not a feature switch any more.
+  if (key === "gotchas" && String(res.value) === "off")
+    console.error(
+      "  ⚠ review learning is designed to stay on. `gotchas: off` is kept for compatibility: it stops the\n" +
+        "    gotcha block in EXECUTOR slices only. The reviewer card (`orc gotcha card`) is always built.\n" +
+        "    To make the card smaller, set gotcha_card_budget (min 200)."
+    );
   if (key === "opus5_only" || key === "extra_enabled") extraShadowNotice(claudeDir);
 }
 
@@ -2394,7 +2573,7 @@ function extraShadowNotice(claudeDir) {
     return;
   }
   const bands = rows.map((r) => `[${r.from},${r.to >= 100 ? "100]" : r.to + ")"}`).join(", ");
-  const base = isTrue(map.opus5_only) ? "opus5_only" : map.rubric_bands_override ? "rubric_bands_override" : "the default 6-band table";
+  const base = isTrue(map.opus5_only) ? "opus5_only" : map.rubric_bands_override ? "rubric_bands_override" : "the default 5-band table";
   console.error(
     `  ⚠ ${bands} ${rows.length === 1 ? "is routed to a non-Claude worker and no longer resolves" : "are routed to a non-Claude worker and no longer resolve"} on ${base}.\n` +
       "    Every other score still does — Extra is an overlay, not a replacement.\n" +
@@ -2412,8 +2591,10 @@ const OPUS5_ONLY_ROLES = [
   ["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"],
   ["pattern codify", "orc-pattern-codifier-sonnet-5-high", "orc-pattern-codifier-opus-5-med"],
-  ["wiki scan", "orc-wiki-scanner-opus-4-8-high", "orc-wiki-scanner-opus-5-med"],
-  ["claude write", "orc-claude-writer-opus-4-8-high", "orc-claude-writer-opus-5-med"],
+  // v2.1.0 (DE-1): the deep scanner is already Opus 5.5 low, so only the LIGHT
+  // half flips, and onto the deep agent. The CLAUDE.md writer is already Opus 5.5
+  // low and has no row.
+  ["wiki scan", "orc-wiki-scanner-sonnet-5-high", "orc-wiki-scanner-opus-5-low"],
   ["retro mine", "orc-retro-sonnet-5-high", "orc-retro-opus-5-med"],
 ];
 
@@ -2424,7 +2605,7 @@ const OPUS5_ONLY_ROLES = [
 function opus5Notice(on, claudeDir) {
   if (!on) {
     console.log(
-      "\n  Every role is back to its default pin (executors → the 6-band mixed-model\n" +
+      "\n  Every role is back to its default pin (executors → the 5-band mixed-model\n" +
         "  table). A hand-written rubric_bands_override is live again."
     );
     return;
@@ -2801,6 +2982,9 @@ const LANES = [
   { lane: "orc-doc", command: "orc-doc" },
   { lane: "orc-explain", command: "orc-explain" },
   { lane: "orc-export", command: "orc-export" },
+  // v2.1.0 W6 — a RIDER, like orc-wait: it opens no run and never writes
+  // `.current`. It records a fix into the run already in flight, or with none.
+  { lane: "orc-fix", command: "orc-fix" },
   { lane: "orc-fast", command: "orc-fast" },
   { lane: "orc-grill", command: "orc-grill" },
   { lane: "orc-handoff", command: "orc-handoff" },
@@ -3234,9 +3418,26 @@ function laneConfig(lane, claudeDir) {
       inert_reason: hit ? hit.reason : gate ? `${m.gated_by} is off, so nothing in its block is consulted` : null,
     };
   });
+  // v2.0.0 W2 — the `learned` rank (bin/habit.js, DE-6). `habits: off` (the
+  // default) adds ZERO BYTES: the habit keys leave `not_read`, no key gains a
+  // field, and there is no `habits` block — the answer is the one 1.9.2 gave.
+  const H = require("./habit.js");
+  const hmode = H.habitsMode(map);
+  let hab = null;
+  if (hmode !== "off") {
+    hab = H.laneBlock(claudeDir, habitDeps(), map, lane);
+    for (const k of keys) {
+      const l = !has(k.key) && hab.learned[k.key];
+      if (l) k.value = l.value;
+      k.source = has(k.key) ? "overridden" : l ? `learned:${l.id}` : "default";
+      k.state = k.is_inert ? "inert" : k.is_shadowed ? "not-read" : l ? "learned" : has(k.key) ? "overridden" : "default";
+    }
+  }
   const effective = {};
   for (const k of keys) effective[k.key] = k.value;
-  return {
+  const announce = laneAnnounce(lane, map, claudeDir, families);
+  if (hab) for (const k of keys) if (k.state === "learned") announce.push(H.announceLine(k.key, hab.learned[k.key]));
+  const out = {
     lane,
     command: (LANES.find((l) => l.lane === lane) || {}).command || null,
     command_note: (LANES.find((l) => l.lane === lane) || {}).note || null,
@@ -3247,16 +3448,37 @@ function laneConfig(lane, claudeDir) {
     effective,
     families,
     roles: laneRoles(lane, map, claudeDir),
-    announce: laneAnnounce(lane, map, claudeDir, families),
+    announce,
     stops: LANE_STOPS.filter((s) => rows.some((m) => m.key === s.key))
       .filter((s) => s.arms(has(s.key) ? map[s.key] : metaFor(s.key).def))
       .map((s) => ({ key: s.key, value: has(s.key) ? map[s.key] : metaFor(s.key).def, when: s.when, action: s.action })),
     // The keys this lane deliberately ignores. An empty answer is an ANSWER
     // (v0.43.0): "this lane does not read doc_language" is information, and it
     // is what makes the two-way lint possible at all.
-    not_read: CONFIG_META.filter((m) => !(m.lanes || []).includes(lane)).map((m) => m.key),
-    rank_states: LANE_RANK_STATES,
+    not_read: CONFIG_META.filter((m) => !(m.lanes || []).includes(lane))
+      .filter((m) => hab || !H.HABIT_KEYS.includes(m.key))
+      .map((m) => m.key),
+    rank_states: hab ? LANE_RANK_STATES.concat("learned") : LANE_RANK_STATES,
   };
+  if (hab) out.habits = hab.block;
+  else for (const f of H.HABIT_FAMILIES) delete out.families[f];
+  return out;
+}
+
+// The helpers `bin/habit.js` borrows, so it REUSES the trace listing and the
+// timestamp parser `orc stats` / `orc run list` already use.
+function runUndoDeps() {
+  return { args, wantsJson, emitJson, resolveClaudeDir, resolveRunDir, ensureRunDir, repoRootOf };
+}
+
+function habitDeps() {
+  return { flag, positionals, emitJson, wantsJson, resolveClaudeDir, readOverride, listTraces, traceTs };
+}
+
+// v2.1.0 W7 — `orc clear logs` and the FINISH sweep (bin/clear-logs.js) REUSE
+// the trace-name parser and the per-trace counts `orc stats` adds up.
+function clearLogsDeps() {
+  return { flag, positionals, emitJson, wantsJson, resolveClaudeDir, resolveLogDir, resolveRunDir, readOverride, traceNameInfo, traceCountsOf, LOG_RETENTION_DAYS };
 }
 
 function laneList(claudeDir) {
@@ -3316,7 +3538,7 @@ const LANE_CALLS = {
     on_absent: "exit ≠ 0 → say the CLI is unavailable and use the documented defaults, out loud, treating every P0 forcing mode as OFF",
     canonical: "_shared/config-precedence.md",
     never: "never merge `.claude/orc.config.yaml` yourself, and never re-derive a precedence — the answer already carries it",
-    lanes: ["context-combiner", "orc", "orc-aftermath", "orc-analyze", "orc-analyze-mini", "orc-boundary", "orc-brainstorm", "orc-budget", "orc-challenge", "orc-claude", "orc-diy", "orc-doc", "orc-explain", "orc-export", "orc-fast", "orc-grill", "orc-handoff", "orc-learn", "orc-mini", "orc-pact", "orc-pattern", "orc-poly", "orc-pr-driver", "orc-pr-setup", "orc-quick", "orc-retro", "orc-route", "orc-test", "orc-verify", "orc-wiki"],
+    lanes: ["context-combiner", "orc", "orc-aftermath", "orc-analyze", "orc-analyze-mini", "orc-boundary", "orc-brainstorm", "orc-budget", "orc-challenge", "orc-claude", "orc-diy", "orc-doc", "orc-explain", "orc-export", "orc-fast", "orc-fix", "orc-grill", "orc-handoff", "orc-learn", "orc-mini", "orc-pact", "orc-pattern", "orc-poly", "orc-pr-driver", "orc-pr-setup", "orc-quick", "orc-retro", "orc-route", "orc-test", "orc-verify", "orc-wiki"],
   },
   "run-inflight": {
     cmd: "orc run inflight [--json]",
@@ -3330,6 +3552,19 @@ const LANE_CALLS = {
     never: "never read `clear` as proof that an AD-HOC dispatch finished — the hook writes no SPAWN for one, so no record exists",
     lanes: ["orc", "orc-doc", "orc-fast", "orc-mini", "orc-quick", "orc-test", "orc-wiki"],
   },
+  // v2.0.0 T21 — the CLI holds the trace pen: one packet → the .txt AND the .jsonl.
+  "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" },
+    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)",
+    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"],
+  },
   "lane-phases": {
     cmd: "orc lane phases <lane> [--json]",
     what: "which SHARED phases this lane runs, in order — the file, the layers to read, and when",
@@ -3385,6 +3620,37 @@ const LANE_CALLS = {
     never: "never inject the ledger unfiltered — only the entries whose `scope` glob matches the slice",
     lanes: ["orc", "orc-boundary", "orc-brainstorm", "orc-fast", "orc-grill", "orc-mini", "orc-retro", "orc-route"],
   },
+  // v2.1.0 — the review-close record. It was shared PROSE only and every spine
+  // says "make no other call", so no lane made it and Review Quality read
+  // "0 so far". `orc gotcha quality` now also counts reviews from the traces;
+  // this row is what gives a lane the call for the acceptance half.
+  "gotcha-observe": {
+    cmd: "orc gotcha observe - [--json]",
+    what: "record ONE finding outcome (stdin: one JSON object) — the only writer of observations.jsonl",
+    exits: { 0: "appended, promotion ran", 2: "malformed — the reply names the field" },
+    states: null,
+    cost: "free",
+    when: "at review close, once per finding, after the fixes — `run` is required when author is orc",
+    on_absent: "exit 2 → say it once and go on; it never blocks a run",
+    canonical: "_shared/gotchas.md",
+    never: "never edit `.claude/orc/observations.jsonl` by hand, and never record a clean review here — the trace `FINDING-OUTCOME` line already counts it",
+    lanes: ["orc", "orc-mini", "orc-quick"],
+  },
+  // v2.1.0 — the project review rule. A lane never names it: the answer reaches
+  // the lane as the `review-policy` probe inside `orc lane config`, so this row
+  // is a USER command (`lanes: []`, the `orc graph audit` shape).
+  "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)" },
+    states: ["orc", "project"],
+    cost: "free",
+    when: "at preflight, through the `review-policy` probe of `orc lane config`",
+    on_absent: "`policy: orc` and `line: null` — no rule, nothing to ask",
+    canonical: "_shared/review-slice.md",
+    never: "never let the rule pick the reviewer — it only adds an OPTION to the §0 question the user answers",
+    lanes: [],
+  },
   // v1.8.0 — the code graph. Every row carries `--if-enabled`: the CLI resolves
   // `code_graph`, so no lane reads the key (and /orc-quick can take part).
   "graph-status": {
@@ -3849,7 +4115,7 @@ const LANE_CALLS = {
     // declared far below this catalogue, and reading it here is a temporal dead
     // zone that crashes the CLI on every command. `test/cli/rules.test.js`
     // asserts the two agree.
-    lanes: ["context-combiner", "orc", "orc-aftermath", "orc-analyze", "orc-analyze-mini", "orc-boundary", "orc-brainstorm", "orc-budget", "orc-challenge", "orc-claude", "orc-diy", "orc-explain", "orc-export", "orc-fast", "orc-grill", "orc-handoff", "orc-learn", "orc-mini", "orc-pact", "orc-poly", "orc-pr-driver", "orc-pr-setup", "orc-quick", "orc-retro", "orc-route", "orc-test", "orc-verify", "orc-wiki"],
+    lanes: ["context-combiner", "orc", "orc-aftermath", "orc-analyze", "orc-analyze-mini", "orc-boundary", "orc-brainstorm", "orc-budget", "orc-challenge", "orc-claude", "orc-diy", "orc-explain", "orc-export", "orc-fast", "orc-fix", "orc-grill", "orc-handoff", "orc-learn", "orc-mini", "orc-pact", "orc-poly", "orc-pr-driver", "orc-pr-setup", "orc-quick", "orc-retro", "orc-route", "orc-test", "orc-verify", "orc-wiki"],
   },
 };
 
@@ -3938,7 +4204,7 @@ function laneCallsCmd(lane, claudeDir) {
 //
 // Per phase: \`file\` + \`layers\` (never a line number — /orc-doc rule 2, a
 // stored line number is a wrong line number one edit later), \`when\` and
-// \`read\` (the partial-read declarations registered in \`_shared/read-ladder.md\`
+// \`read\` (the partial-read declarations registered in \`_shared/phases/README.md\`
 // at W10), \`optional_when\` (a config KEY, resolved through the priority ladder
 // by \`orc lane config\`, never read raw), and \`calls\` — catalogue ids from
 // \`LANE_CALLS\`, DERIVED rather than restated, so a lane can ask for one
@@ -3966,9 +4232,25 @@ const PHASE_FILES = {
     why_single_layer: null,
     why_two_layers:
       "every other lane READS the protocol; orc-diy STITCHES a flow-shaped restatement of it into FLOW-COMPILED.md, and a composed flow owes one packet per ENABLED phase group rather than per phase",
+    // v2.0.0 T1 — the verbs are NOT here: every lane owes TRACE_ALWAYS_VERBS,
+    // and the rest arrive with the phase that emits them.
+    trace_verbs: [],
+  },
+  // v2.0.0 T1 — the full human verb table, split out of trace.md so a run
+  // stops reading ~30 KB of grammar it never emits. `when: on-demand`: a lane
+  // opens it only for a verb its `trace_grammar` does not carry. `via` names
+  // the phase file that points at it — the lint accepts that pointer instead
+  // of one per lane spine.
+  "trace-verbs": {
+    file: "_shared/phases/trace-verbs.md",
+    layers: ["core"],
+    via: "trace",
+    why_single_layer: "it is a reference table, and TRACE_VERBS in bin/cli.js is the data behind it; a lane reads its own rows from `trace_grammar`",
+    trace_verbs: [],
   },
   preflight: {
     file: "_shared/phases/preflight.md",
+    trace_verbs: ["GATE", "GRAPH-CONSULT"],
     layers: ["core", "full"],
     // W13 moved this off a hardcoded `lane !== "orc"` branch and onto the same
     // lane->layer map the build phases use — one mechanism, not two.
@@ -3983,6 +4265,7 @@ const PHASE_FILES = {
   },
   "plan-handoff": {
     file: "_shared/phases/plan-handoff.md",
+    trace_verbs: ["PHASE", "GATE"],
     layers: ["core"],
     why_single_layer:
       "executing a plan another session wrote is one procedure, and /orc-route READS it to define what a plan is — a second definition is drift the lint cannot see (v0.42.0)",
@@ -3994,12 +4277,14 @@ const PHASE_FILES = {
   },
   "analyst-gates": {
     file: "_shared/phases/analyst-gates.md",
+    trace_verbs: ["GATE"],
     layers: ["core"],
     why_single_layer:
       "these are the orchestrator-side gates on a returned analysis or plan, and a trimmed lane runs fewer of them rather than different ones",
   },
   "wiki-consult": {
     file: "_shared/phases/wiki-consult.md",
+    trace_verbs: ["WIKI-CONSULT", "CROSSLINK"],
     layers: ["core"],
     why_single_layer: "the precedence ladder (code > fresh wiki > stale wiki > model priors) does not bend for a faster lane",
   },
@@ -4024,6 +4309,7 @@ const PHASE_FILES = {
   },
   "stop-resume": {
     file: "_shared/phases/stop-resume.md",
+    trace_verbs: ["GATE"],
     layers: ["core"],
     why_single_layer:
       "the stop sequence is identical in every lane that stops; which moments are MANDATORY stops is already a per-lane rule in the spine",
@@ -4031,6 +4317,7 @@ const PHASE_FILES = {
 
   "planning": {
     file: "_shared/phases/planning.md",
+    trace_verbs: ["PHASE", "CONFIG", "WIKI-CONSULT", "CROSSLINK", "GRAPH-MAP", "GRAPH-COCHANGE", "GATE", "PACT"],
     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;
@@ -4043,6 +4330,7 @@ const PHASE_FILES = {
   },
   "scoring": {
     file: "_shared/phases/scoring.md",
+    trace_verbs: ["PHASE", "SCORE"],
     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;
@@ -4055,6 +4343,7 @@ const PHASE_FILES = {
   },
   "execution": {
     file: "_shared/phases/execution.md",
+    trace_verbs: ["PHASE", "GATE", "OUTCOME", "TDD-RED", "TDD-GREEN", "REPRO", "REPLAN", "QUESTION", "CONTEXT-GAP", "BOUNDARY", "EXTRA", "GRAPH-UPDATE", "GRAPH-NOTES", "GRAPH-HINT"],
     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;
@@ -4067,6 +4356,7 @@ const PHASE_FILES = {
   },
   "review": {
     file: "_shared/phases/review.md",
+    trace_verbs: ["PHASE", "FINDING", "GRAPH-CHANGES", "REVIEW-WHICH"],
     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;
@@ -4091,6 +4381,7 @@ const PHASE_FILES = {
   },
   "verify": {
     file: "_shared/phases/verify.md",
+    trace_verbs: ["PHASE", "VERDICT", "PACT"],
     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;
@@ -4115,6 +4406,7 @@ const PHASE_FILES = {
   },
   "mock-example": {
     file: "_shared/phases/mock-example.md",
+    trace_verbs: ["PHASE", "DRIFT"],
     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;
@@ -4127,6 +4419,7 @@ const PHASE_FILES = {
   },
   "ship": {
     file: "_shared/phases/ship.md",
+    trace_verbs: ["PHASE", "GATE", "GRAPH-UPDATE", "GRAPH-GAIN"],
     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;
@@ -4139,6 +4432,7 @@ const PHASE_FILES = {
   },
   "summary": {
     file: "_shared/phases/summary.md",
+    trace_verbs: ["PHASE", "FINDING-OUTCOME"],
     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;
@@ -4169,12 +4463,220 @@ const PREFLIGHT_CALL_IDS = new Set([
   "run-list",
 ]);
 
+// ── v2.0.0 T20 — `probes{}`: one preflight call instead of 4–6 ──────────────
+//
+// W0 counted 2–6 CLI calls at preflight before the first dispatch, each one a
+// round trip that re-sends the whole cached session. `orc lane config` is
+// already the one call every lane makes first, so it now carries the ANSWERS of
+// the probes that lane makes at start.
+//
+// Each probe runs the stand-alone command's OWN code, in this process, with its
+// own argv: the same function, the same exit code, the same fields — so the
+// entry cannot drift from the command. The entry is BRIEF (T17): `exit`, `line`
+// and the fields a lane branches on. `--probes-full` adds the whole stand-alone
+// answer as `full`; `--no-probes` leaves the block out.
+//
+// READ-ONLY, always. `graph status` runs WITHOUT `--heal` (a heal builds or
+// writes the index) — `heal_needed: true` says the lane still makes that one
+// call. `extra resolve` runs without the `orc extra` credential sweep (a
+// delete). A probe that throws or gives no answer is `{exit, error}` — never a
+// thrown error, and never a change to `lane config`'s own exit code.
+//
+// The set per lane is DERIVED: PREFLIGHT_CALL_IDS ∩ the lane's LANE_CALLS rows,
+// plus `graph-status` and `rules-slice` where the lane makes them, plus
+// /orc-quick's slot probe. `challenge-status` needs a slug, so it is not here.
+const PROBE_DEFS = {
+  "wiki-status": {
+    argv: () => ["wiki", "status"],
+    run: () => wiki(),
+    pick: ["state", "tier", "docs", "distance", "last_scan"],
+    line: (j) =>
+      j.state === "none"
+        ? "wiki: none — no wiki yet"
+        : j.state === "registered"
+          ? `wiki: ${j.tier || "tier unknown"}${j.distance === null ? "" : ` (${j.distance}c)`} — ${plural(j.docs, "doc")} · last scan ${j.last_scan || "?"}`
+          : `wiki: ${String(j.state).toUpperCase()} — ${plural(j.docs, "doc")} (run: orc wiki sync)`,
+  },
+  "pattern-status": {
+    argv: () => ["pattern", "status"],
+    run: () => pattern(),
+    pick: ["cached"],
+    derive: (j) => ({ langs: (j.patterns || []).map((p) => p.lang) }),
+    line: (j) => (j.cached ? `pattern: cached — ${(j.patterns || []).map((p) => p.lang).join(", ")}` : "pattern: none cached"),
+  },
+  "gotcha-status": {
+    argv: () => ["gotcha", "status"],
+    run: () => gotcha(),
+    pick: ["count", "gotchas_max"],
+    line: (j) => (j.count ? `gotchas: ${j.count} live (cap ${j.gotchas_max})` : "gotchas: none recorded — nothing to inject"),
+  },
+  "pact-status": {
+    argv: () => ["pact", "status"],
+    run: () => pact(),
+    pick: ["ok", "reason", "entries", "counts"],
+    line: (j) => j.line || "pact: no ledger yet — a first run",
+  },
+  "boundary-status": {
+    argv: () => ["boundary", "status"],
+    run: () => boundary(),
+    pick: ["ok", "reason", "counts", "stale"],
+    line: (j) => j.line || "boundary: no cards yet — every area is UNKNOWN, never assumed safe",
+  },
+  "aftermath-status": {
+    argv: () => ["aftermath", "status"],
+    run: () => aftermath(),
+    pick: ["ok", "reason", "window_days", "counts"],
+    line: (j) =>
+      j.ok
+        ? `aftermath: ${plural((j.runs || []).length, "run")} in the last ${j.window_days} days · ${Object.entries(j.counts || {}).map(([k, v]) => `${v} ${k}`).join(" · ") || "no grade"}`
+        : j.reason === "shallow"
+          ? `aftermath: no runs in the last ${j.window_days} days — too shallow to grade`
+          : `aftermath: ${j.reason}`,
+  },
+  "diy-status": {
+    argv: () => ["diy", "status"],
+    run: () => diy(),
+    pick: ["state", "reason"],
+    line: (j) => `diy: ${j.state}${j.reason ? " — " + j.reason : ""}`,
+  },
+  "run-list": {
+    argv: () => ["run", "list"],
+    run: () => runCmd(),
+    pick: ["total"],
+    line: (j) => `runs: ${j.total}`,
+  },
+  "graph-status": {
+    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")) }),
+    line: (j) => j.line,
+  },
+  "rules-slice": {
+    argv: (lane) => ["rules", "slice", "--lane", lane],
+    run: () => rulesCmd(),
+    pick: ["packs", "overrides"],
+    line: (j) => j.line,
+  },
+  // v2.1.0 — the project's own review rule. The line reaches the lane only when a
+  // rule exists (preflight prints one line per probe), so it costs no
+  // always-loaded byte and no spine text.
+  "review-policy": {
+    argv: () => ["review", "policy"],
+    run: () => reviewCmd(),
+    pick: ["policy", "found"],
+    // Every probe carries ONE line (preflight prints one per probe). With no rule
+    // the line says so and the lane changes nothing.
+    line: (j) => j.line || "review: ORC review — no project review rule found",
+  },
+  "extra-slot": {
+    argv: () => ["extra", "resolve", "--slot", "quick-executor"],
+    run: () => extraResolveCmd(resolveClaudeDir(), undefined),
+    pick: ["resolved", "via", "slot", "needs_reping", "held_back"],
+    line: (j) => (j.resolved === "extra" ? `extra: ${j.announce}` : `extra: ${j.slot} → claude ${(j.claude && j.claude.agent) || ""}`.trim()),
+  },
+};
+
+function laneProbeIds(lane) {
+  const ids = Object.entries(LANE_CALLS)
+    .filter(([id, c]) => id !== "lane-config" && PREFLIGHT_CALL_IDS.has(id) && c.lanes.includes(lane) && PROBE_DEFS[id])
+    .map(([id]) => id);
+  if (LANE_CALLS["graph-status"].lanes.includes(lane)) ids.push("graph-status");
+  if (LANE_CALLS["rules-slice"].lanes.includes(lane)) ids.push("rules-slice");
+  if (lane === "orc-quick") ids.push("extra-slot");
+  if (REVIEW_POLICY_LANES.includes(lane)) ids.push("review-policy");
+  return ids;
+}
+// v2.1.0 (DE-8 a) — every coding lane that can change code asks "which review"
+// before ship when the project names its own review, so every one carries it.
+const REVIEW_POLICY_LANES = ["orc", "orc-mini", "orc-fast", "orc-quick", "orc-diy"];
+
+// Run ONE stand-alone command in this process and take its answer. The argv is
+// swapped in for the call and put back after it; stdout, stderr and exit are
+// caught, so nothing reaches the terminal and nothing ends this process.
+function runProbe(argv, fn) {
+  const saved = args.slice();
+  const pass = [];
+  const di = saved.indexOf("--dir");
+  if (di !== -1 && saved[di + 1] !== undefined) pass.push("--dir", saved[di + 1]);
+  if (saved.includes("--global")) pass.push("--global");
+  args.splice(0, args.length, ...argv, "--json", ...pass);
+  const cap = { obj: null, text: [], err: [] };
+  const SENT = { probe: true };
+  let code = null;
+  let error = null;
+  const keep = { exit: process.exit, log: console.log, error: console.error, warn: console.warn };
+  process.exit = (c) => {
+    code = c === undefined ? 0 : c;
+    throw SENT;
+  };
+  console.log = (...a) => cap.text.push(a.map(String).join(" "));
+  console.error = console.warn = (...a) => cap.err.push(a.map(String).join(" "));
+  PROBE_CAPTURE = cap;
+  try {
+    fn();
+    if (code === null) code = 0;
+  } catch (e) {
+    if (e !== SENT) {
+      error = String((e && e.message) || e).split("\n")[0];
+      if (code === null) code = 1;
+    }
+  } finally {
+    PROBE_CAPTURE = null;
+    process.exit = keep.exit;
+    console.log = keep.log;
+    console.error = keep.error;
+    console.warn = keep.warn;
+    args.splice(0, args.length, ...saved);
+  }
+  let obj = cap.obj;
+  if (!obj && cap.text.length) {
+    try {
+      obj = JSON.parse(cap.text.join("\n"));
+    } catch (_) {}
+  }
+  if (!obj && !error) error = String(cap.err.find((l) => l.trim()) || "no answer").trim().split("\n")[0];
+  return { exit: code, obj, error };
+}
+
+function laneProbes(lane, full) {
+  const out = {};
+  for (const id of laneProbeIds(lane)) {
+    const def = PROBE_DEFS[id];
+    const r = runProbe(def.argv(lane), def.run);
+    if (r.error || !r.obj) {
+      out[id] = { exit: r.exit, error: r.error };
+      continue;
+    }
+    const j = r.obj;
+    let line;
+    try {
+      line = def.line(j);
+    } catch (e) {
+      line = null;
+    }
+    const e = { exit: r.exit, line };
+    for (const k of def.pick) if (Object.prototype.hasOwnProperty.call(j, k)) e[k] = j[k];
+    if (def.derive) Object.assign(e, def.derive(j));
+    if (full) e.full = j;
+    out[id] = e;
+  }
+  return out;
+}
+
 // tier + packet cadence per trace-owning lane. This is the same data the tier
 // table in \`_shared/phases/trace.md\` renders for a human; the lint asserts the
 // two agree, so a lane cannot be in one and absent from the other.
 const LANE_TRACE = {
-  orc: { tier: "Build lanes", token: "orc" },
-  "orc-mini": { tier: "Build lanes", token: "mini" },
+  // `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"] },
+  "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"],
+  },
   "orc-fast": { tier: "Build lanes", token: "fast" },
   "orc-wiki": { tier: "Multi-dispatch", token: "wiki" },
   "orc-pr-driver": { tier: "Multi-dispatch", token: "prdriver" },
@@ -4202,12 +4704,98 @@ const LANE_TRACE = {
   "orc-export": { tier: "Single-dispatch", token: "export" },
 };
 
+// v2.0.0 T1 — the CLOSED trace verb set, as DATA (the `LANE_CALLS` shape).
+// `_shared/phases/trace-verbs.md` renders this table for a human, and
+// `bin/verify-contracts.js` holds the two together BOTH ways, plus every
+// `trace_verbs` / `spine_verbs` entry in the phase manifest: a verb a phase
+// lists that this registry lacks FAILS. `orc lane phases <lane> --json` hands a
+// lane `trace_grammar` = the grammar lines of exactly the verbs its phases emit
+// plus TRACE_ALWAYS_VERBS, so a run never reads the whole table.
+//
+// grammar — the line shape; ` · ` separates the sub-forms of one verb.
+// emitter — who produces it: `orc → writer` is a packet event, `hook` needs
+//           no cooperation, `X→orc → writer` is a subagent-returned marker.
+// meaning — ONE line. The detail lives at `owner`.
+const TRACE_VERBS = {
+  PHASE: { grammar: "PHASE <name> start|end", emitter: "orc → writer", meaning: "phase transition", owner: "_shared/phases/trace.md" },
+  "PHASE-EDGE": { grammar: "PHASE-EDGE <role-family> :: first=<agent>", emitter: "hook", meaning: "deterministic phase inference: a SPAWN whose role family differs from the previous one opens an edge", owner: "hooks/orc-trace.js" },
+  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-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-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-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" },
+  DISPATCH: { grammar: "DISPATCH <agent> :: <task> expect=<model>/<effort>[ via=extra:<profile>]", emitter: "orc → writer", meaning: "orchestrator dispatched a named agent (the claim)", owner: "_shared/phases/trace-verbs.md" },
+  SCORE: { grammar: "SCORE task=<id> score=<n> band=<range> model=<m> facets=<compact-vector>[ via=extra:<profile>] :: <reason>", emitter: "orc → writer", meaning: "scoring decision (tunes the rubric); a fix cycle emits `task=fix-<n>`", owner: "_shared/phases/scoring.md" },
+  VERIFY: { grammar: "VERIFY <task> actual=<model>/<effort> ✅ MATCH · VERIFY <task> actual=<model>/<effort> ⛔ DOWNGRADE expected=<m>/<e>", emitter: "orc → writer", meaning: "claimed-vs-actual model check; surface a downgrade to the user, not just the trace", owner: "_shared/return-validation.md" },
+  ASK: { grammar: "ASK <qid> :: offered=<o1|o2|…> rec=<o|none> chose=<o|other> by=<user|ledger|learned|config|default> [pre=<o>] [ctx=<k=v,…>]", emitter: "orc → writer", meaning: "one answered decision point — what `orc habit` learns from; the free text of an `other` answer is never stored", owner: "_shared/phases/trace-verbs.md" },
+  QUESTION: { grammar: "QUESTION count=<n> :: <topic>", emitter: "subagent→orc → writer", meaning: "stopped to ask the user", owner: "_shared/phases/trace-verbs.md" },
+  "CONTEXT-GAP": { grammar: "CONTEXT-GAP :: <what was already known>", emitter: "subagent→orc → writer", meaning: "asked/re-derived something already in context", owner: "_shared/phases/trace-verbs.md" },
+  REPLAN: { grammar: "REPLAN wave=<n> :: <reason>", emitter: "orc → writer", meaning: "re-planned after a conflict/failure", owner: "_shared/phases/trace-verbs.md" },
+  GATE: { grammar: "GATE <grounding|coverage|graph|evidence|derivation|facet|schema|judgment|wave-boundary|budget|stack-gate|stack-certainty|layer-green> pass|bounce|escalate :: <detail>", emitter: "orc → writer", meaning: "exit-gate result; `escalate` is judgment-only; bounce detail lists the misses", owner: "_shared/phases/trace-verbs.md" },
+  ADVISE: { grammar: "ADVISE :: brief=<path> questions=<n>", emitter: "orc → writer", meaning: "ultra Phase U0 — advisor brief received, clarification round relayed", owner: "orc/references/ultra-mode.md" },
+  JUDGE: { grammar: "JUDGE <analysis|plan|implementation> <verdict> round=<n> blocking=<n> advisory=<n> downgraded=<n>", emitter: "orc → writer", meaning: "ultra judgment verdict", owner: "orc/references/ultra-mode.md" },
+  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" },
+  "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" },
+  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" },
+  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" },
+};
+
+// The verbs EVERY trace-owning lane owes, whatever its phases list. Every lane
+// sends at least the ONE end-of-run packet, and trace.md makes each of these
+// part of it: DISPATCH + VERIFY (the main return is dispatched and checked),
+// NOTE (the packet's `decisions`), STATS (every trace-owning lane emits it, not
+// just `orc`) and FINISH (mandatory, even on an abort). PHASE and CONFIG are
+// NOT here: a single-dispatch lane closes no named phase, and CONFIG is the
+// build lanes' Phase-1 line — both come in through the phase rows that emit them.
+const TRACE_ALWAYS_VERBS = ["DISPATCH", "VERIFY", "NOTE", "STATS", "FINISH"];
+
+// `trace_grammar` for one lane: TRACE_VERBS order, hook verbs left out (a lane
+// never emits them), `null` for a lane that owns no trace.
+function laneTraceGrammar(lane) {
+  const t = LANE_TRACE[lane];
+  if (!t) return null;
+  const want = new Set(TRACE_ALWAYS_VERBS);
+  for (const id of LANE_PHASE_ORDER[lane] || PHASE_ORDER)
+    if ((LANE_PHASES[id] || []).includes(lane)) for (const v of PHASE_FILES[id].trace_verbs || []) want.add(v);
+  for (const p of LANE_OWN_PHASES[lane] || []) for (const v of p.trace_verbs || []) want.add(v);
+  for (const v of t.spine_verbs || []) want.add(v);
+  const out = {};
+  for (const [v, d] of Object.entries(TRACE_VERBS)) if (want.has(v) && d.emitter !== "hook") out[v] = d.grammar;
+  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
 // is a PHASE of the analyze run, not a lane (v0.42.0).
 const LANE_PHASES = {
   trace: Object.keys(LANE_TRACE),
+  // v2.0.0 T1 — the verb table, ON DEMAND. Every lane that traces may need a
+  // verb its `trace_grammar` does not carry, and it reaches the table through
+  // trace.md (`via` in PHASE_FILES), never through its own spine.
+  "trace-verbs": Object.keys(LANE_TRACE),
   preflight: [
     "orc",
     "orc-boundary",
@@ -4237,7 +4825,7 @@ const LANE_PHASES = {
   rules: [
     "context-combiner", "orc", "orc-aftermath", "orc-analyze", "orc-analyze-mini",
     "orc-boundary", "orc-brainstorm", "orc-budget", "orc-challenge", "orc-claude",
-    "orc-diy", "orc-explain", "orc-export", "orc-fast", "orc-grill", "orc-handoff",
+    "orc-diy", "orc-explain", "orc-export", "orc-fast", "orc-fix", "orc-grill", "orc-handoff",
     "orc-learn", "orc-mini", "orc-pact", "orc-poly", "orc-pr-driver", "orc-pr-setup",
     "orc-quick", "orc-retro", "orc-route", "orc-test", "orc-verify", "orc-wiki",
   ],
@@ -4262,6 +4850,7 @@ const LANE_PHASES = {
 const PHASE_ORDER = [
   "preflight",
   "trace",
+  "trace-verbs",
   "intake",
   "plan-handoff",
   "wiki-consult",
@@ -4296,6 +4885,7 @@ const PHASE_ORDER = [
 const LANE_PHASE_ORDER = {
   "orc-diy": [
     "trace",
+    "trace-verbs",
     "intake",
     "planning",
     "wave-grouping",
@@ -4320,7 +4910,7 @@ const LANE_PHASE_ORDER = {
 // A row names a FILE and, when the phase still lives in that lane's spine, the
 // HEADING inside it (plan rule: a manifest names a file, a layer and at most a
 // heading — never a line number, /orc-doc rule 2). `read: "section"` is the
-// partial-read declaration registered in `_shared/read-ladder.md`.
+// partial-read declaration registered in `_shared/phases/README.md`.
 //
 // WHY MOST ROWS NAME A HEADING RATHER THAN A FILE (v1.0.0 W14, measured):
 // moving a phase into its own file pays only when a run does NOT reach it —
@@ -4412,7 +5002,7 @@ const LANE_OWN_PHASES = {
     { ord: 2, id: "phase-f2", file: "orc-fast/SKILL.md", heading: "## Phase F2 — Slice build + dispatch (ONE executor)", read: "section", trace_verbs: ["GATE", "VERIFY", "WIKI-CONSULT"] },
     { ord: 3, id: "phase-f3", file: "orc-fast/SKILL.md", heading: "## Phase F3 — Smoke gate (build + test; blocks ship on red)", read: "section", trace_verbs: [] },
     { ord: 4, id: "phase-f3-5", file: "orc-fast/SKILL.md", heading: "## Phase F3.5 — Mock example (config `mock_example`, default ask)", read: "section", trace_verbs: ["DRIFT", "PHASE"] },
-    { ord: 5, id: "phase-f4", file: "orc-fast/SKILL.md", heading: "## Phase F4 — Ship", read: "section", trace_verbs: ["FINISH", "OUTCOME"] },
+    { ord: 5, id: "phase-f4", file: "orc-fast/SKILL.md", heading: "## Phase F4 — Ship", read: "section", trace_verbs: ["FINISH", "OUTCOME", "REVIEW-WHICH"] },
   ],
   "orc-learn": [
     { ord: 0, id: "mode-a", file: "orc-learn/SKILL.md", heading: "## Mode A — INIT", read: "section", trace_verbs: ["DISPATCH", "FINISH", "VERIFY", "WIKI-CONSULT"] },
@@ -4463,7 +5053,7 @@ const LANE_OWN_PHASES = {
     { 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: 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", "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", "GRAPH-GAIN", "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: [] },
@@ -4493,20 +5083,22 @@ function lanePhaseRows(lane) {
       file: def.file,
       layers,
       read: "whole",
-      // `always` must be justified (read-ladder.md, W10): a lane reads the
+      // `always` must be justified (phases/README.md, W10): a lane reads the
       // config resolver and opens its trace pointer before it can do anything
       // at all. Every other phase is `on-phase` — most runs skip most phases.
       // `compile-time` is orc-diy and only orc-diy: it opens none of these
       // during a run. `orc diy compile` reads the `composed` layer once and
       // stitches it into FLOW-COMPILED.md, which is the only spine that run
       // follows. Calling that `on-phase` would describe a read that never
-      // happens (read-ladder.md rule 5).
+      // happens (phases/README.md rule 5).
       when:
         lane === "orc-diy" && (PHASE_FILES[id].lane_layers || {})["orc-diy"]
           ? "compile-time"
           : id === "preflight" || id === "trace"
             ? "always"
-            : "on-phase",
+            : PHASE_FILES[id].via
+              ? "on-demand"
+              : "on-phase",
       optional_when: null,
       // v1.7.0 — `rules` names its own call for the same reason `preflight`
       // does: the phase IS that command, and a phase row reading "none
@@ -4654,8 +5246,10 @@ function laneRailsManifest() {
     // is an answer, not a gap.
     if (!t || !t.token) continue;
     const rows = [];
+    // An `on-demand` row is a reference a lane MAY open, never a phase a run
+    // is IN — a rail step for it would be a phase the statusline can never show.
     for (const p of lanePhaseRows(lane))
-      rows.push({ id: p.id, label: railLabel(p), kind: railKind(p), verbs: [] });
+      if (p.when !== "on-demand") rows.push({ id: p.id, label: railLabel(p), kind: railKind(p), verbs: [] });
     for (const p of LANE_OWN_PHASES[lane] || [])
       rows.push({
         id: p.id,
@@ -4700,6 +5294,9 @@ function lanePhasesCmd(lane, claudeDir) {
       lane: l,
       trace_tier: t ? t.tier : null,
       trace_token: t ? t.token : null,
+      // v2.0.0 T1 — the grammar line of every verb this lane's phases emit,
+      // plus TRACE_ALWAYS_VERBS. A verb not here → `_shared/phases/trace-verbs.md`.
+      trace_grammar: laneTraceGrammar(l),
       phases,
       shared_phase_count: phases.length,
       // `null` is NOT `[]`: a lane whose own pipeline is still declared in its
@@ -4730,6 +5327,11 @@ function lanePhasesCmd(lane, claudeDir) {
           ? ui.color.gray(`tier ${r.trace_tier} · lane token \`${r.trace_token}\``)
           : ui.color.gray("this lane owns no trace (it is not a run entry point)"))
     );
+    if (r.trace_grammar)
+      console.log(
+        "  trace grammar  " +
+          ui.color.gray(`${Object.keys(r.trace_grammar).length} verbs: ${Object.keys(r.trace_grammar).join(" · ")}  (--json → trace_grammar)`)
+      );
     if (!r.phases.length) {
       // An empty answer is an ANSWER: this lane runs no SHARED phase yet.
       console.log(
@@ -4800,6 +5402,9 @@ function laneConfigCmd(lane, claudeDir) {
     return 2;
   }
   const d = laneConfig(lane, claudeDir);
+  // v2.0.0 T20 — the preflight probes' answers ride on this one call. LAST, so
+  // every 1.9.2 field keeps its position.
+  if (!args.includes("--no-probes")) d.probes = laneProbes(lane, args.includes("--probes-full"));
   if (wantsJson()) {
     emitJson({ ok: true, ...d });
     return 0;
@@ -4816,6 +5421,31 @@ function laneConfigCmd(lane, claudeDir) {
     console.log("");
   }
 
+  // v2.0.0 T20 — the probes this lane makes at start, one line each.
+  if (d.probes && Object.keys(d.probes).length) {
+    console.log(ui.header("Probes  (the preflight answers — exit code is data)"));
+    const pw = Math.max(...Object.keys(d.probes).map((k) => k.length));
+    for (const [id, p] of Object.entries(d.probes))
+      console.log(`  ${ui.color.cyan(id.padEnd(pw))}  exit ${p.exit}  ${p.error ? ui.color.yellow("error: " + p.error) : p.line}`);
+    console.log("");
+  }
+
+  // v2.0.0 W2 — only when `habits` is not off; off prints nothing new.
+  if (d.habits) {
+    const h = d.habits;
+    console.log(ui.header("Habits"));
+    console.log("  " + h.line);
+    for (const l of h.learned) console.log(`  learned  ${l.key}: ${l.value}  (${l.id}, ${l.count} of ${l.total})  undo: ${l.undo}`);
+    for (const x of h.suggestions) console.log(`  usual    ${x.qid}: ${x.option}  ${x.mark}  (${x.id})`);
+    if (h.proposal) {
+      console.log(`  proposal ${h.proposal.id} (${h.proposal.kind}) — show at the END of the run only:`);
+      console.log("    " + h.proposal.line);
+      console.log(ui.color.gray(`    yes: ${h.proposal.yes}${h.proposal.keep ? "   keep: " + h.proposal.keep : ""}${h.proposal.later ? "   not now: " + h.proposal.later : ""}   never: ${h.proposal.never}`));
+      console.log(ui.color.gray(`    trace: ${h.proposal.trace}`));
+    }
+    console.log("");
+  }
+
   console.log(ui.header(`Keys this lane reads  (${d.keys.length})`));
   if (!d.keys.length) console.log(ui.color.gray("  none — this lane reads no config key."));
   const pad = d.keys.length ? Math.max(...d.keys.map((k) => k.key.length)) : 0;
@@ -4826,7 +5456,9 @@ function laneConfigCmd(lane, claudeDir) {
         ? ui.color.yellow("  shadowed")
         : k.is_overridden
           ? ui.color.green("  overridden")
-          : ui.color.gray("  default");
+          : k.state === "learned"
+            ? ui.color.cyan("  learned") + ui.color.gray(` (${k.source})`)
+            : ui.color.gray("  default");
     console.log(`  ${ui.color.cyan(k.key.padEnd(pad))}  ${String(k.value).padEnd(24)} ${k.prio} ${k.family}${mark}`);
     if (k.inert_reason) console.log(ui.color.gray(`      ↳ ${k.inert_reason}`));
     else if (k.shadow_reason) console.log(ui.color.gray(`      ↳ ${k.shadow_reason}`));
@@ -4984,10 +5616,11 @@ const sha256 = (s) => crypto.createHash("sha256").update(s).digest("hex");
 // The tier-clip roster. It must contain EVERY agent the default table names —
 // `diyScoreTable()` looks each row's agent up here, so a table row naming an
 // agent this map does not know is a crash, not a fallback. v1.0.0 W4 added the
-// two Opus 5.5 rows for exactly that reason.
+// two Opus 5.5 rows for exactly that reason, and v2.1.0 the two Sonnet 5 rows
+// (`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 four agents no band names reachable (D14).
+// — which is what keeps the seven 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,
@@ -4996,6 +5629,8 @@ const DIY_EXECUTORS = {
   "orc-executor-haiku-4-5": { model: 1, effort: 1 },
   "orc-executor-sonnet-4-6-med": { model: 2, effort: 1 },
   "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 },
   "orc-executor-sonnet-5-high": { model: 3, effort: 2 },
   "orc-executor-opus-4-7-med": { model: 4, effort: 1 },
   "orc-executor-opus-4-7-high": { model: 4, effort: 2 },
@@ -5269,7 +5904,7 @@ function diyValidate(cfg) {
   return { errors, warnings };
 }
 
-// The single canonical 6-band score->model table (mirrors skills/orc/config.md
+// The single canonical 5-band score->model table (mirrors skills/orc/config.md
 // — documented drift). No more narrow/wide preset: rubric_bands is granularity
 // only, and this one table maps every score.
 //
@@ -5283,15 +5918,19 @@ function diyValidate(cfg) {
 // TABLE change, and an agent's model change is always a rename — conflating the
 // two is how a downgrade check breaks.
 //
-// THE EDGE IS 90, AND IT IS ROUND (D13). Every other edge in this table is
-// round and half-open, so `[65,90)` and `[90,101]` keep the shape; a score of
-// exactly 90 resolves to `med`.
+// THE EDGE IS 90, AND IT IS ROUND (D13). `[41,90)` and `[90,101]` keep the
+// half-open shape; a score of exactly 90 resolves to `med`.
+//
+// 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
+// named by no band now and STAY ON DISK (the same D14 rule as above).
 const DIY_SCORE_TABLE = [
-  [0, 30, "orc-executor-haiku-4-5"],
-  [30, 40, "orc-executor-sonnet-4-6-med"],
-  [40, 55, "orc-executor-sonnet-4-6-high"],
-  [55, 65, "orc-executor-sonnet-5-high"],
-  [65, 90, "orc-executor-opus-5-low"],
+  [0, 21, "orc-executor-sonnet-5-low"],
+  [21, 31, "orc-executor-sonnet-5-med"],
+  [31, 41, "orc-executor-sonnet-5-high"],
+  [41, 90, "orc-executor-opus-5-low"],
   [90, 101, "orc-executor-opus-5-med"],
 ];
 
@@ -5358,8 +5997,18 @@ function diyExtraRows(cfg, claudeDir) {
   }
   if (!ledger || !ledger.routes.length) return null;
   const rows = [];
+  const table = isTrue(map.opus5_only) ? OPUS5_SCORE_TABLE : DIY_SCORE_TABLE;
   for (const r of ledger.routes) {
     const res = extraResolveFor(claudeDir, r.from, { role: "executor" });
+    // v2.1.0 — a user row can span more than one Claude band (a 40-55 row covers
+    // [31,41) AND [41,90) of the five-band table). Name EVERY agent its scores
+    // would fall back to, never only the agent at its first score.
+    const fallbacks = [res.claude.agent];
+    for (const [lo] of table)
+      if (lo > r.from && lo < r.to) {
+        const a = extraResolveFor(claudeDir, lo, { role: "executor" }).claude.agent;
+        if (a && !fallbacks.includes(a)) fallbacks.push(a);
+      }
     rows.push({
       from: r.from,
       to: r.to,
@@ -5368,7 +6017,7 @@ function diyExtraRows(cfg, claudeDir) {
       model: r.model,
       routes: res.resolved === "extra",
       why_short: res.held_back || "not routed",
-      claude_agent: res.claude.agent,
+      claude_agent: fallbacks.join(" / "),
     });
   }
   // A gap is not a hole — it is Claude, split at the Claude table's own edges by
@@ -7625,20 +8274,19 @@ function usageFor(usage, file) {
 }
 
 // ── the scan tier ladder (B5) — the biggest single cut ───────────────────────
-// Every scan-task used to dispatch `orc-wiki-scanner-opus-4-8-high` whether the
+// Every scan-task used to dispatch `orc-wiki-scanner-opus-5-low` whether the
 // delta was 2 lines or 2000. The ladder sends a small, no-new-surface delta to
 // the LIGHT scanner instead. Five rows, in order; first match wins.
 //
 // NEVER SILENT: the resolved tier is printed in `orc wiki plan` and in the
 // refresh confirmation. A cheaper model is a decision the user sees, never a
 // quiet substitution.
-const WIKI_SCANNER_DEEP = "orc-wiki-scanner-opus-4-8-high";
+const WIKI_SCANNER_DEEP = "orc-wiki-scanner-opus-5-low";
 const WIKI_SCANNER_LIGHT = "orc-wiki-scanner-sonnet-5-high";
-// `opus5_only` already forces the wiki scanner to the shipped
-// orc-wiki-scanner-opus-5-med, so BOTH tiers collapse to that one agent while
-// the flag is on. That is why the ladder adds NO row to OPUS5_ONLY_ROLES and no
-// new agent pair: see _shared/opus5-only.md.
-const WIKI_SCANNER_OPUS5 = "orc-wiki-scanner-opus-5-med";
+// `opus5_only` forces the wiki scanner to the deep agent: since v2.1.0 the deep
+// scanner is already Opus 5.5 low, so BOTH tiers collapse onto it while the flag
+// is on. The ladder adds no new agent pair: see _shared/opus5-only.md.
+const WIKI_SCANNER_OPUS5 = "orc-wiki-scanner-opus-5-low";
 
 const WIKI_TIER_LADDER = [
   { id: "first-scan", tier: "deep", why: "first scan of this area (no doc yet)" },
@@ -8404,6 +9052,11 @@ function gotchaStatus(claudeDir, verbose) {
           trigger: e.fields.trigger || null,
           fields: e.fields,
         })),
+        // v2.0.0 W7 — the Behaviour panel's Gotchas tab: source, computed
+        // status and a 7-week hits line per entry, plus the last sync state.
+        // It READS the sync file; it never runs a sync.
+        // `status` (a lane preflight) skips it: only `list` pays for the git call.
+        ...(verbose ? { panel: require("./gotcha.js").panelView(claudeDir, gotchaDeps(), entries) } : {}),
       },
       entries.length ? 0 : 1
     );
@@ -9752,6 +10405,18 @@ ${line || ""}`;
   process.exit(1);
 }
 
+// The helpers `bin/gotcha.js` borrows: the v1 parser and paths stay HERE, so
+// `GOTCHA_HEAD` has one home and a 1.9.2 CLI still reads a 2.0 file.
+function gotchaDeps() {
+  return { args, flag, positionals, emitJson, wantsJson, resolveClaudeDir, readOverride, repoRootOf, parseGotchas, gotchasPath, gotchasArchivePath, GOTCHA_HEAD, listTraces };
+}
+
+// An async importer that throws: one line, exit 1, never a stack in a lane.
+function asyncFail(e) {
+  console.error("❌ " + ((e && e.message) || String(e)));
+  process.exit(1);
+}
+
 function gotcha() {
   if (flag("--global")) {
     console.error("❌ orc gotcha is project-scoped — the memory is this repo's. Run it from the project (or with --dir <path>).");
@@ -9765,7 +10430,8 @@ function gotcha() {
       gotchaStatus(claudeDir, false);
       break;
     case "list":
-      if (args.includes("--archived")) gotchaArchived(claudeDir);
+      if (args.includes("--candidates")) require("./gotcha.js").gotchaCmd(gotchaDeps(), "list");
+      else if (args.includes("--archived")) gotchaArchived(claudeDir);
       else gotchaStatus(claudeDir, true);
       break;
     case "show":
@@ -9777,13 +10443,35 @@ function gotcha() {
       if (args.includes("--dry-run")) gotchaPruneDryRun(claudeDir);
       else gotchaPrune(claudeDir);
       break;
+    // v2.0.0 W4 — the gotchas engine (bin/gotcha.js): the CLI assigns ids,
+    // dedupes, matches, builds the reviewer card and computes promotion.
+    case "add":
+    case "match":
+    case "card":
+    case "filter":
+    case "observe":
+    case "accept":
+    case "quality":
+    case "why":
+    case "export":
+      require("./gotcha.js").gotchaCmd(gotchaDeps(), pos[1]);
+      break;
+    // v2.0.0 W6a — the importers and the review-step sync (bin/gotcha-import.js).
+    // They FEED `observe`; they never write a gotchas.md entry themselves.
+    case "import":
+      require("./gotcha-import.js").importCmd(gotchaDeps()).catch(asyncFail);
+      break;
+    case "sync":
+      require("./gotcha-import.js").syncCmd(gotchaDeps()).catch(asyncFail);
+      break;
     default:
       console.error(
         `Unknown: orc gotcha ${pos[1]}\n` +
           "Usage: orc gotcha status | list [--archived]   repair memory (exit 0 = entries, 1 = none)\n" +
           "       orc gotcha show <id>                    ONE entry, every field (exit 0 / 3 unknown id)\n" +
           "       orc gotcha prune [--dry-run]            archive the low-value tail down to gotchas_max.\n" +
-          "                                               --dry-run NAMES every entry and writes nothing"
+          "                                               --dry-run NAMES every entry and writes nothing\n" +
+          require("./gotcha.js").USAGE.replace(/^Usage: /, "       ")
       );
       process.exit(1);
   }
@@ -10227,9 +10915,12 @@ function pr(alias) {
   // alias `orc pr-stack-template [<slug>]`.
   if (alias === "pr-stack-template") return stackTemplate(claudeDir, pos[1]);
   if (alias === "pr-stack-status") return stackStatus(claudeDir, pos[1]);
+  // v2.0.0 W6a (Q1) — the unresolved review threads, read-only, via `gh`.
+  if (pos[1] === "threads") return require("./gotcha-import.js").prThreadsCmd(gotchaDeps());
   const usage =
     "Usage: orc pr stack template [<slug>]   write a fill-in stack-plan skeleton\n" +
     "       orc pr stack status [<slug>]     is a plan READY? (exit 0 ready / 1 absent-or-unfilled)\n" +
+    "       orc pr threads <n> [--all]       the unresolved review threads (read-only; exit 0 · 1 none open · 5 gh missing/not authed)\n" +
     "       (aliases: orc pr-stack-template, orc pr-stack-status)";
   if (pos[1] !== "stack") {
     console.error(`Unknown: orc ${pos.slice(1).join(" ") || ""}\n${usage}`);
@@ -10943,8 +11634,10 @@ function wiki() {
 
 // ── Run state: `orc resume`, `orc run list|show`, `orc stats` (v0.42.0) ─────
 // Three read-only commands over state ORC already writes. The design constraint
-// shared by all three is SCALE: `log_dir` and `run_dir` are never auto-deleted
-// by design, so 100+ runs is a normal working directory, and a command that
+// shared by all three is SCALE: `log_dir` and `run_dir` are kept until you run
+// `orc clear logs --apply`, or until the automatic sweep removes them
+// (`log_retention_auto: on`, older than `log_retention_days`), so 100+ runs is
+// a normal working directory, and a command that
 // opened every file to build a list would get slower forever. So: enumerate with
 // readdir + stat ONLY, sort, then read a bounded HEAD of just the page being
 // displayed. `checkpoint.json` is never read for a listing — only `run show`
@@ -11386,6 +12079,9 @@ function runCmd() {
   // Read-only, and the ONE reader of the pending sidecar. 0 clear / 1 in-flight / 2 unknown.
   if (sub === "inflight") return runInflightCmd(claudeDir);
 
+  // v2.0.0 W6b (Q2)  the pre-run tree, so `orc undo` can never eat a user edit.
+  if (sub === "snapshot") return require("./run-undo.js").snapshotCmd(runUndoDeps());
+
   if (sub === "show") {
     const arg = pos[2];
     const pick = /^\d+$/.test(String(arg)) ? runs[Number(arg) - 1] : runs.find((r) => r.slug === arg);
@@ -11473,7 +12169,7 @@ function runCmd() {
   if (sub !== "list") {
     console.error(
       `Unknown subcommand: orc run ${sub}\n` +
-        `Try: orc run list | orc run show <slug|n> | orc run close <slug> --reason "<why>" | orc run reopen <slug>`
+        `Try: orc run list | orc run show <slug|n> | orc run close <slug> --reason "<why>" | orc run reopen <slug> | orc run snapshot --run <slug>`
     );
     process.exit(1);
   }
@@ -11641,6 +12337,57 @@ function bar(n, max, width = 12) {
   return "█".repeat(Math.max(1, Math.round((n / max) * width)));
 }
 
+// Lane and date from a trace NAME alone (no file read), or null for a file
+// `orc stats` does not count.
+function traceNameInfo(name) {
+  const m = TRACE_NAME.exec(name);
+  const g = m ? null : TRACE_GENERIC.exec(name);
+  if (!m && !g) return null;
+  return { lane: m ? m[1] : "unknown", date: traceDateIso(m ? m[3] : g[1]) };
+}
+
+// v2.1.0 — ONE trace's counts, exactly as `orc stats` adds them up. Shared
+// with `orc clear logs` (bin/clear-logs.js), which folds these counts into
+// logs-rollup.json BEFORE it deletes the trace, so the totals do not drop.
+function traceCountsOf(dir, name) {
+  const info = traceNameInfo(name);
+  if (!info) return null;
+  const out = { lane: info.lane, date: info.date, dispatches: 0, downgrades: 0, unfinished: 0, agents: {} };
+  const addAgent = (a) => {
+    const key = a.replace(/^\S+\s+/, "").replace(/-(haiku|sonnet|opus|fable)-.*$/, "");
+    out.agents[key] = (out.agents[key] || 0) + 1;
+  };
+  const tail = readTail(path.join(dir, name));
+  const st = parseStatsLine(tail);
+  if (st) {
+    out.dispatches += Number(st.dispatches) || 0;
+    out.downgrades += Number(st.downgrades) || 0;
+    for (const a of tail.match(/\bDISPATCH\s+(orc-[\w.-]+)/g) || []) addAgent(a);
+  } else {
+    // Legacy fallback: count DISPATCH lines. Cheaper detail, same headline.
+    let body = "";
+    try { body = fs.readFileSync(path.join(dir, name), "utf8"); } catch (_) {}
+    out.dispatches += (body.match(/\bDISPATCH\s+\S/g) || []).length;
+    out.downgrades += (body.match(/⛔ DOWNGRADE/g) || []).length;
+    for (const a of body.match(/\bDISPATCH\s+(orc-[\w.-]+)/g) || []) addAgent(a);
+  }
+  if (!/\bFINISH\b/.test(tail)) out.unfinished = 1;
+  return out;
+}
+
+const LOGS_ROLLUP_FILE = "logs-rollup.json";
+
+// The rollup `orc clear logs --apply` writes (DE-19 a). Class b: never deleted,
+// never in the install manifest. `null` when absent or unreadable.
+function readLogsRollup(claudeDir) {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(claudeDir, "orc", LOGS_ROLLUP_FILE), "utf8"));
+    return j && typeof j === "object" ? j : null;
+  } catch (_) {
+    return null;
+  }
+}
+
 function stats() {
   const claudeDir = resolveClaudeDir();
   const dir = resolveLogDir(claudeDir);
@@ -11653,7 +12400,7 @@ function stats() {
   const empty = (msg) => {
     if (asJson)
       emitJson(
-        { log_dir: dir, runs: 0, from: null, to: null, lanes: {}, agents: {}, dispatches: 0, downgrades: 0, unfinished: 0, unknown_lane: 0, graph: statsGraph(claudeDir) },
+        { log_dir: dir, runs: 0, from: null, to: null, lanes: {}, agents: {}, dispatches: 0, downgrades: 0, unfinished: 0, unknown_lane: 0, pruned_runs: 0, graph: statsGraph(claudeDir), questions: null },
         1
       );
     console.log(msg);
@@ -11661,60 +12408,63 @@ function stats() {
   };
 
   let names = [];
+  let noDir = false;
   try {
     names = fs.readdirSync(dir).filter((f) => f.endsWith(".txt"));
   } catch (_) {
-    empty(`No traces yet under ${dir}. Run any ORC lane and they appear here.`);
+    noDir = true;
   }
 
   const lanes = new Map();
   const agents = new Map();
-  let total = 0, dispatches = 0, downgrades = 0, unfinished = 0, unknownLane = 0;
+  let total = 0, dispatches = 0, downgrades = 0, unfinished = 0, unknownLane = 0, prunedRuns = 0;
   let firstDate = null, lastDate = null;
+  const sinceOk = (date) => !(typeof since === "string" && since && date < since);
+  const add = (c, runs) => {
+    total += runs;
+    if (c.lane === "unknown") unknownLane += runs;
+    lanes.set(c.lane, (lanes.get(c.lane) || 0) + runs);
+    if (c.from && (!firstDate || c.from < firstDate)) firstDate = c.from;
+    if (c.to && (!lastDate || c.to > lastDate)) lastDate = c.to;
+    dispatches += Number(c.dispatches) || 0;
+    downgrades += Number(c.downgrades) || 0;
+    unfinished += Number(c.unfinished) || 0;
+    for (const [a, n] of Object.entries(c.agents || {})) agents.set(a, (agents.get(a) || 0) + (Number(n) || 0));
+  };
 
   for (const name of names) {
-    const m = TRACE_NAME.exec(name);
-    const g = m ? null : TRACE_GENERIC.exec(name);
-    if (!m && !g) continue;
-    const date = traceDateIso(m ? m[3] : g[1]);
+    const info = traceNameInfo(name);
+    if (!info) continue;
     // --since filters on the FILENAME date, before any file is opened.
-    if (typeof since === "string" && since && date < since) continue;
-
-    const lane = m ? m[1] : "unknown";
-    if (!m) unknownLane++;
-    total++;
-    lanes.set(lane, (lanes.get(lane) || 0) + 1);
-    if (!firstDate || date < firstDate) firstDate = date;
-    if (!lastDate || date > lastDate) lastDate = date;
-
-    const tail = readTail(path.join(dir, name));
-    const st = parseStatsLine(tail);
-    if (st) {
-      dispatches += Number(st.dispatches) || 0;
-      downgrades += Number(st.downgrades) || 0;
-    } else {
-      // Legacy fallback: count DISPATCH lines. Cheaper detail, same headline.
-      const body = fs.readFileSync(path.join(dir, name), "utf8");
-      dispatches += (body.match(/\bDISPATCH\s+\S/g) || []).length;
-      downgrades += (body.match(/⛔ DOWNGRADE/g) || []).length;
-      for (const a of body.match(/\bDISPATCH\s+(orc-[\w.-]+)/g) || []) {
-        const key = a.replace(/^\S+\s+/, "").replace(/-(haiku|sonnet|opus|fable)-.*$/, "");
-        agents.set(key, (agents.get(key) || 0) + 1);
-      }
-    }
-    if (st) {
-      for (const a of tail.match(/\bDISPATCH\s+(orc-[\w.-]+)/g) || []) {
-        const key = a.replace(/^\S+\s+/, "").replace(/-(haiku|sonnet|opus|fable)-.*$/, "");
-        agents.set(key, (agents.get(key) || 0) + 1);
-      }
-    }
-    if (!/\bFINISH\b/.test(tail)) unfinished++;
+    if (!sinceOk(info.date)) continue;
+    const c = traceCountsOf(dir, name);
+    add(Object.assign(c, { from: c.date, to: c.date }), 1);
+  }
+
+  // v2.1.0 (DE-19 a) — the runs `orc clear logs --apply` pruned. Their counts
+  // were folded into logs-rollup.json before the delete, per lane and month.
+  // Under --since a bucket counts only when its FIRST run is on or after it.
+  const rollup = readLogsRollup(claudeDir);
+  for (const b of Object.values((rollup && rollup.buckets) || {})) {
+    if (!b || !(Number(b.runs) > 0) || !b.from || !sinceOk(b.from)) continue;
+    add(b, Number(b.runs));
+    prunedRuns += Number(b.runs);
   }
 
-  if (!total) empty(since ? `No traces on or after ${since}.` : `No traces yet under ${dir}.`);
+  if (!total)
+    empty(
+      since ? `No traces on or after ${since}.` : noDir ? `No traces yet under ${dir}. Run any ORC lane and they appear here.` : `No traces yet under ${dir}.`
+    );
 
   const laneRows = [...lanes.entries()].sort((a, b) => b[1] - a[1]);
   const agentRows = [...agents.entries()].sort((a, b) => b[1] - a[1]);
+  // v2.0.0 W6b (Q7) — questions per run, from the habit engine's ONE pass over
+  // the ASK / QUESTION lines. null = it could not be computed, never a guess.
+  let questions = null;
+  try {
+    const H = require("./habit.js");
+    questions = H.questionStats(H.collect(claudeDir, habitDeps()), { since: typeof since === "string" && since ? since : null });
+  } catch (_) {}
 
   if (asJson) {
     console.log(
@@ -11730,7 +12480,9 @@ function stats() {
           downgrades,
           unfinished,
           unknown_lane: unknownLane,
+          pruned_runs: prunedRuns,
           graph: statsGraph(claudeDir),
+          questions,
         },
         null,
         2
@@ -11740,6 +12492,7 @@ function stats() {
   }
 
   console.log(ui.header(`ORC usage — ${plural(total, "run")}, ${firstDate} to ${lastDate}`));
+  if (prunedRuns) console.log(ui.color.gray(`includes ${plural(prunedRuns, "pruned run")} (counted in ${LOGS_ROLLUP_FILE} before \`orc clear logs\` deleted the trace)`));
   console.log("\n" + ui.color.bold("Lanes"));
   const maxLane = laneRows[0][1];
   for (const [lane, n] of laneRows) {
@@ -11768,6 +12521,20 @@ function stats() {
       ["retrieval probably kept out", `~${kTok(gr.avoided_low)} – ${kTok(gr.avoided_high)}   (an ESTIMATE — see \`orc graph gain\`)`],
     ]));
   }
+  // Q7 — "fewer questions", measured. Every field --json carries is printed.
+  if (questions && questions.runs) {
+    console.log("\n" + ui.color.bold("Questions") + `          ${questions.asked} asked · ${questions.answered_for_you} answered for you`);
+    console.log(ui.kv([
+      ["per run (median)", String(questions.per_run_p50)],
+      ["asked by a subagent", String(questions.subagent_questions)],
+      ["how each was answered", Object.entries(questions.by).map(([k, v]) => `${k} ${v}`).join(" · ")],
+      ["last runs, oldest first", questions.per_run_trend.map((r) => r.asked).join(" ")],
+    ]));
+    for (const [l, r] of Object.entries(questions.by_lane).sort((a, b) => b[1].asked - a[1].asked))
+      console.log(`  /${l.padEnd(18)} ${String(r.asked).padStart(3)} asked in ${plural(r.runs, "run")} · median ${r.per_run_p50} · ${r.answered_for_you} answered for you`);
+    const pts = Object.entries(questions.by_point).sort((a, b) => b[1].asked - a[1].asked);
+    for (const [q, r] of pts) console.log(ui.color.gray(`    ${q.padEnd(34)} ${r.asked} asked · ${r.answered_for_you} answered for you`));
+  }
   console.log("\n" + ui.color.bold("Health"));
   console.log(ui.kv([
     ["model downgrades", String(downgrades)],
@@ -11778,8 +12545,10 @@ function stats() {
     "\n" +
       ui.color.gray(
         "Counts only what traces record. `/orc-retro` and `/orc-explain` never write one,\n" +
-          "so they never appear here. Deleting or moving log_dir resets these numbers;\n" +
-          "nothing auto-prunes traces."
+          "so they never appear here. Deleting or moving log_dir resets these numbers.\n" +
+          "Traces are kept until you run `orc clear logs --apply`, or until the automatic\n" +
+          "sweep removes them (`log_retention_auto: on`, older than `log_retention_days`);\n" +
+          "a pruned run still counts here."
       )
   );
 }
@@ -12256,7 +13025,7 @@ function scoreFromFacets(f, fanIn, fanOut) {
 }
 
 // The resolved score→model table. `opus5_only` outranks everything (3 bands);
-// otherwise the default 6-band table. A hand-written `rubric_bands_override` is
+// otherwise the default 5-band table. A hand-written `rubric_bands_override` is
 // registry-less by design, so the forecast reports it as UNKNOWN rather than
 // pretending to resolve it.
 // v1.0.0 W4 — an ALIAS, not a second array. See OPUS5_SCORE_TABLE's comment:
@@ -12366,8 +13135,8 @@ 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-med", "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-med", "orc-verifier-opus-5-med", "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-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"],
 };
@@ -13804,6 +14573,82 @@ function exportCmd() {
 
 const IMPORT_CANDIDATES = ["AGENTS.md", "CLAUDE.md", ".cursorrules", ".github/copilot-instructions.md"];
 
+// ── v2.1.0 — `orc review policy`: does the PROJECT ask for its own review? ──
+//
+// Read-only and zero-token. It reads the instruction files `orc export` already
+// knows plus `.claude/CLAUDE.md`, and finds a line that has ALL of: a review
+// word, a duty word, and a NAME (a slash command, a `plugin:skill` id, a
+// backticked name, or "skill"/"command" next to a name). Fenced code is skipped,
+// and a line that names ORC's own reviewer or an ORC command does not count.
+//
+// It is a heuristic, so it NEVER answers anything: house rules "can never change
+// how a lane RUNS". It only adds an OPTION to the question the lane asks before
+// ship (`_shared/review-slice.md` §0). Exit 0 in every state.
+const REVIEW_POLICY_FILES = IMPORT_CANDIDATES.concat([".claude/CLAUDE.md"]);
+const RP_REVIEW = /\b(?:code[- ]?review|reviews?|reviewed)\b|\bCR\b/i;
+const RP_DUTY = /\b(?:must|always|required|needs?|should|only|use)\b/i;
+function reviewPolicyNames(text) {
+  const names = [];
+  const add = (n) => {
+    if (!n) return;
+    const v = n.replace(/[.,;:)]+$/, "");
+    if (/^\/?orc(?:-|$)/.test(v) || /orc-reviewer-/.test(v)) return;
+    if (!names.includes(v)) names.push(v);
+  };
+  for (const m of text.matchAll(/(?:^|[\s(`"'])(\/[a-z][\w:-]*)/g)) add(m[1]);
+  for (const m of text.matchAll(/(?:^|[\s(`"'])([a-z0-9-]+:[a-z0-9-]+)(?=[\s`"').,;]|$)/g)) if (!/^https?:/.test(m[1])) add(m[1]);
+  for (const m of text.matchAll(/`([^`\s]{2,60})`/g)) add(m[1]);
+  for (const m of text.matchAll(/\b(?:skill|command)\s+["']?([a-z][\w:-]{1,60})/gi)) add(m[1]);
+  for (const m of text.matchAll(/\b([a-z][\w:-]{1,60})\s+(?:skill|command)\b/gi)) if (!/^(?:the|a|an|this|that|our|your|its)$/i.test(m[1])) add(m[1]);
+  return names;
+}
+function reviewPolicyCompute(claudeDir) {
+  const root = repoRootOf(claudeDir);
+  const found = [];
+  for (const rel of REVIEW_POLICY_FILES) {
+    let text;
+    try {
+      text = fs.readFileSync(path.join(root, rel), "utf8");
+    } catch (_) {
+      continue;
+    }
+    let fence = false;
+    text.split(/\r?\n/).forEach((raw, i) => {
+      if (/^\s*(```|~~~)/.test(raw)) {
+        fence = !fence;
+        return;
+      }
+      if (fence) return;
+      if (/orc-reviewer-/.test(raw) || !RP_REVIEW.test(raw) || !RP_DUTY.test(raw)) return;
+      const names = reviewPolicyNames(raw);
+      if (!names.length) return;
+      found.push({ file: rel, line: i + 1, quote: raw.trim().slice(0, 200), names });
+    });
+  }
+  const first = found[0];
+  return {
+    ok: true,
+    policy: found.length ? "project" : "orc",
+    found,
+    line: first
+      ? `review: ${first.file}:${first.line} names ${first.names[0]} — before ship, ask which review (_shared/review-slice.md §0)`
+      : null,
+  };
+}
+function reviewCmd() {
+  const pos = positionals();
+  if (pos[1] !== "policy") {
+    if (wantsJson()) emitJson({ ok: false, reason: "usage", message: "usage: orc review policy [--json]" }, 1);
+    console.error("usage: orc review policy [--json]");
+    process.exit(1);
+  }
+  const r = reviewPolicyCompute(resolveClaudeDir());
+  if (wantsJson()) emitJson(r, 0);
+  if (!r.found.length) console.log("review: no project review rule found — ORC review is the default");
+  else for (const f of r.found) console.log(`review: ${f.file}:${f.line} names ${f.names.join(", ")} — "${f.quote}"`);
+  process.exit(0);
+}
+
 function exportImport(claudeDir) {
   const asJson = wantsJson();
   const root = repoRootOf(claudeDir);
@@ -25888,8 +26733,8 @@ const EXTRA_SLOTS = [
   {
     slot: "wiki-scanner-deep",
     lane: "/orc-wiki",
-    claude: ["orc-wiki-scanner-opus-4-8-high"],
-    claude_opus5: ["orc-wiki-scanner-opus-5-med"],
+    claude: ["orc-wiki-scanner-opus-5-low"],
+    claude_opus5: null,
     asks: false,
     announce: "per scan-batch, beside the resolved tier",
     why: "a scanner returns an evidence-anchored doc body the orchestrator writes; every claim in it is anchored to a file you can open.",
@@ -25898,7 +26743,7 @@ const EXTRA_SLOTS = [
     slot: "wiki-scanner-light",
     lane: "/orc-wiki",
     claude: ["orc-wiki-scanner-sonnet-5-high"],
-    claude_opus5: ["orc-wiki-scanner-opus-5-med"],
+    claude_opus5: ["orc-wiki-scanner-opus-5-low"],
     asks: false,
     announce: "per scan-batch, beside the resolved tier",
     why: "the LIGHT tier is already a small no-new-surface delta on an existing doc — the cheapest work the wiki does.",
@@ -34251,7 +35096,7 @@ function doctor() {
           "global-skew",
           `GLOBAL install ~/.claude is ${globalV} but this project is ${localV} — ` +
             "the global copy can win skill resolution; run `orc update --global`",
-          { global_version: globalV, local_version: localV }
+          { global_version: globalV, local_version: localV, fix_command: "orc update --global" }
         );
       } else ok(`global install ~/.claude matches (${globalV})`);
       // Agent files the global install still carries that this payload no
@@ -34401,6 +35246,10 @@ function doctor() {
         }
       })();
       const v = slValidate(slLoadOrDefault(claudeDir));
+      const hk = slHookInfo(claudeDir, SL_BOARDS.status);
+      const skew = !hk.match && hk.fix;
+      if (skew)
+        warn("statusline-hook-skew", slHookSentence(hk), { fix: hk.fix, fix_command: hk.fix });
       // An ORPHANED component — a layout naming an id this ORC no longer ships
       // — is REPORTED, NEVER AUTO-REPAIRED, and the fix names the item. Which
       // component replaces a retired one is a design decision, not a repair.
@@ -34415,9 +35264,36 @@ function doctor() {
         });
       else if (st && st.finding && Date.now() - (st.at || 0) < 24 * 60 * 60 * 1000)
         warn("statusline-layout-unreadable", `status line: the hook fell back to ORC's built-in lines (${st.finding})`, {
-          fix: "orc statusline compile",
+          fix: hk.fix || "orc statusline compile",
+          fix_command: hk.fix || "orc statusline compile",
         });
-      else ok("custom status line armed and valid");
+      else if (!skew) ok("custom status line armed and valid");
+    }
+  } catch (_) {}
+
+  // 5a-ter) the refresh timer (v2.1.0 W8). Three checks, each a fact about the
+  // settings file: a hand-edited value under Claude Code's 1 s floor (it never
+  // starts the timer), a layout that MOVES with no timer to move it, and a timer
+  // on the sub-agent board, where Claude Code documents no refreshInterval.
+  try {
+    for (const b of [SL_BOARDS.status, SL_BOARDS.subagent]) {
+      const hk = slHookInfo(claudeDir, b);
+      const st = hk && hk.settings ? slReadJson(hk.settings) : null;
+      const raw = st && st[b.setting] ? st[b.setting].refreshInterval : undefined;
+      if (b === SL_BOARDS.subagent) {
+        if (raw !== undefined)
+          warn("statusline-subagent-refresh", `${b.setting}.refreshInterval is set (${raw}), but Claude Code documents no refresh timer for the sub-agent board — it may do nothing`, { fix: `remove refreshInterval from ${b.setting} in ${hk.settings}` });
+        continue;
+      }
+      if (typeof raw === "number" && raw < SL_REFRESH_FLOOR_S)
+        warn("statusline-refresh-below-floor", `statusLine.refreshInterval is ${raw} — below the Claude Code floor (1 s), so the timer never starts`, { fix: "orc statusline refresh 1", fix_command: "orc statusline refresh 1" });
+      let lock = null;
+      try {
+        lock = JSON.parse(fs.readFileSync(slPaths(claudeDir, b).lock, "utf8"));
+      } catch (_) {}
+      const need = lock && lock.needs_refresh_interval;
+      if (need && raw === undefined && String(resolvedConfig(claudeDir).statusline_custom || "off") === "on")
+        warn("statusline-refresh-needed", `your status line layout moves or shows the time, but no refresh timer is set — it changes only on events`, { fix: `orc statusline refresh ${need}`, fix_command: `orc statusline refresh ${need}` });
     }
   } catch (_) {}
 
@@ -34471,6 +35347,37 @@ function doctor() {
     }
   } catch (_) {}
 
+  // 5a-bis2) the session hook (v2.0.0 Q8/Q9). TWO entries: `Stop` (the bell,
+  // armed only by `notify: bell`) and `SessionStart` on `compact` (the run
+  // pointer after a compaction, always armed). One finding when either is missing.
+  try {
+    const cfg = resolvedConfig(claudeDir);
+    let hk = {};
+    try {
+      hk = (JSON.parse(fs.readFileSync(path.join(claudeDir, "settings.json"), "utf8")) || {}).hooks || {};
+    } catch (_) {}
+    const wiredOn = (event, matcher) =>
+      Array.isArray(hk[event]) &&
+      hk[event].some((e) => (e.matcher || null) === (matcher || null) && (e.hooks || []).some((h) => String(h.command || "").includes("orc-session-hook")));
+    const missing = [["Stop", null], ["SessionStart", "compact"], ["SubagentStart", null]].filter(([e, m]) => !wiredOn(e, m)).map(([e, m]) => (m ? `${e} ${m}` : e));
+    const bell = String(cfg.notify || "off") === "bell";
+    if (missing.length)
+      warn(
+        "session-hook-unwired",
+        `session hook not wired on ${missing.join(", ")} — ` +
+          [
+            missing.includes("SessionStart compact") ? "a compacted session is not told which run is in flight" : null,
+            missing.includes("Stop") ? (bell ? "notify is bell, but the bell never rings" : "the bell cannot ring if notify is set to bell") : null,
+            missing.includes("SubagentStart") ? "a reviewer gets no gotcha card" : null,
+          ]
+            .filter(Boolean)
+            .join("; ") +
+          "; run `orc update`",
+        { fixable: true, fix: "orc update", fix_command: "orc update" }
+      );
+    else ok(`session hook wired (Stop + SessionStart compact + SubagentStart) · notify ${bell ? "bell" : "off"}`);
+  } catch (_) {}
+
   // 5a-ter) the code graph (v1.8.0). ONE finding, and only while `code_graph` is
   // on — the read-gate rule. DRIFTED is the only state worth a line: NONE is
   // built by the next code lane's preflight, and a doctor that warns about a
@@ -40852,6 +41759,8 @@ Usage:
                                           [--check]  fail when the export is stale (exit 1)
     orc export import                     read an existing AGENTS.md/.cursorrules as EVIDENCE and
                                           propose ORC config + pact seeds (never applies anything)
+  orc review policy [--json]              does CLAUDE.md / AGENTS.md name the project's own review?
+                                          read-only; it only adds an option to "which review"
   orc pattern [--dir <path>]              cached code-patterns (project-scoped; no --global)
     orc pattern status [<lang>]           whether a cached pattern exists — the deterministic
                                           existence probe every knowledge-gated lane runs first
@@ -40906,8 +41815,31 @@ Usage:
       --reason "<why>"                    moves RESUME.md aside (never deletes it) and records why,
                                           so it stops counting as waiting  [--json]
     orc run reopen <slug|n>               put it back — it is waiting again  [--json]
+    orc run snapshot --run <slug>         at run start: what the tree looked like BEFORE the run
+                                          (a git ref + the untracked files), so undo can tell your
+                                          edits from the run's own  [--json]
+  orc undo --run <slug> [--files a,b]     PRINTS the commands that revert ONLY the files this run
+      [--apply]                           changed, back to the snapshot; --apply runs them. Never
+                                          touches a file outside the run, keeps a run file you
+                                          edited later (exit 4)  [--json]
   orc stats [--since YYYY-MM-DD] [--json] how much you actually use each lane and agent, counted
                                           from the trace filenames — no model, instant, free
+  orc clear logs [--older-than 30|60|90|120|240|360] [--apply] [--include-default-dir]
+                                          PRINTS the finished traces and run folders (with their
+                                          git ref) older than \`log_retention_days\`; --apply
+                                          deletes them. Never user data, a waiting run or the
+                                          active trace. \`orc stats\` keeps their counts  [--json]
+  orc habit show|log|points|why|accept|decline|forget|reset|doctor|export|purge   your usual answers,
+                                          learned from the ASK lines in your traces (config key
+                                          \`habits\`, off by default). Never applied without your yes  [--json]
+  orc habit repo [accept|decline|forget <id>]   soft preferences read from git history (commit,
+                                          branch, test-file naming). An accepted one rides in
+                                          \`orc rules slice\` as the LEARNED tier  [--json]
+  orc trace write --packet -|<file>       write ONE phase packet into the run's trace pair (.txt +
+                                          .jsonl). Exit 2 = a bad packet, nothing written  [--json]
+  orc fix classify|record|list            the deterministic half of /orc-fix — classify a fix from
+                                          evidence, record it (computes the review miss), list them.
+                                          Writes ONE FIX line into the host run's trace  [--json]
   orc wait                                the deterministic half of /orc-wait — a wait costs zero
                                           tokens, because a detached command does it, not a model
     orc wait lanes [--json]               which lanes support a wait, what each one checkpoints,
@@ -41003,6 +41935,7 @@ const WAIT_LANE_SHAPES = [
   { lane: "/orc-pattern", checkpoint: "none", safe_point: "single dispatch" },
   { lane: "/orc-claude", checkpoint: "none", safe_point: "single dispatch" },
   { lane: "/orc-explain", checkpoint: "none", safe_point: "read-only, seconds long" },
+  { lane: "/orc-fix", checkpoint: "none", safe_point: "after the record is written" },
   { lane: "/orc-route", checkpoint: "none", safe_point: "read-only, seconds long" },
   { lane: "/orc-boundary", checkpoint: "none", safe_point: "read-only, seconds long" },
   { lane: "/orc-budget", checkpoint: "none", safe_point: "read-only, seconds long" },
@@ -41991,6 +42924,10 @@ const STATUSLINE_RENDERERS = {
   // motion
   motif: { kind: "motif", needs: "motif" },
   pulse: { kind: "motif", sub: "pulse", needs: "motif" },
+  // v2.0.4 — the animated sprites (pets). `width` is the TRACK in cells.
+  run: { kind: "sprite", sub: "run", width: [6, 40], dflt_w: 16, needs: "sprite" },
+  bounce: { kind: "sprite", sub: "bounce", width: [6, 40], dflt_w: 16, needs: "sprite" },
+  idle: { kind: "sprite", sub: "idle", width: [6, 40], dflt_w: 16, needs: "sprite" },
 };
 
 // WHICH RENDERERS DRAW A LABEL. Seven of thirty-five, and the other
@@ -42027,7 +42964,18 @@ function slRendererUses(name) {
     out.push("ramp");
     if (!out.includes("width")) out.push("width");
   }
-  return out;
+  // v2.0.4 — the decorations every shape can now carry, and the per-kind ones.
+  // `case` styles the authored name, so every shape uses it.
+  out.push("label", "label_pos", "caption", "caption_pos", "caption_align", "caption_color", "caption_case", "case", "brackets", "padding", "prefix", "suffix");
+  if (rend.kind === "text" || rend.kind === "link") out.push("align", "sign", "max_len");
+  // A bar or a series can draw the item's own value beside it (`value_pos`),
+  // through the item's format with prefix/suffix removed, so it uses the number fields.
+  if (rend.kind === "bar" || rend.kind === "series") out.push("format", "compact", "precision", "min_width", "sign", "align", "max_len");
+  if (rend.kind === "bar") out.push("value_pos", "fill_color", "empty_color", "fill_char", "empty_char", "ramp_colors", "ramp_stops");
+  if (name === "split" || name === "marker") out.push("threshold");
+  if (rend.kind === "series") out.push("value_pos", "fill_color");
+  if (["dot", "shape", "icon", "traffic"].includes(name)) out.push("glyph_by_state");
+  return [...new Set(out)];
 }
 
 // ── The glyph sets (design-language.md §2) ──────────────────────────────────
@@ -42192,7 +43140,41 @@ const SL_THEME_ABOUT = {
 
 const SL_FORMATS = ["percent", "ratio", "fraction", "decimal", "plain"];
 const SL_COMPACT = ["off", "si", "bytes"];
-const SL_CASES = ["none", "upper", "lower", "title"];
+const SL_CASES = ["none", "upper", "lower", "title", "small", "super", "sub"];
+// v2.0.4 — the closed sets of the design fields. The panel reads each one from
+// `components --json` and names none of them itself.
+const SL_LABEL_POS = ["before", "after", "above", "below"];
+const SL_VALUE_POS = ["none", "before", "after"];
+const SL_CAPTION_POS = ["above", "below"];
+const SL_CAPTION_ALIGN = ["left", "center", "right"];
+const SL_ALIGNS = ["left", "right"];
+const SL_SIGNS = ["auto", "always", "never"];
+const SL_UNKNOWNS = ["dash", "hide"];
+const SL_LINE_ALIGNS = ["left", "center", "right"];
+const SL_LIMITS = { caption: 40, max_len: 60, padding: 8, ramp_colors: [2, 8], brackets: 3, param_text: 60 };
+
+// The engine owns cell width and the styled alphabets; the CLI borrows them so
+// the validator and the renderer can never disagree. The fallbacks only serve
+// an engine that predates v2.0.4.
+function slCellWidth(s) {
+  const e = slEngine();
+  if (typeof e.cellWidth === "function") return e.cellWidth(String(s));
+  let w = 0;
+  for (const ch of String(s)) w += /[ᄀ-ᅟ⺀-꓏가-힣豈-﫿︰-﹏＀-｠￠-￦]|[\u{1F000}-\u{1FAFF}]/u.test(ch) ? 2 : 1;
+  return w;
+}
+function slCaseText(s, c) {
+  if (c === "upper") return s.toUpperCase();
+  if (c === "lower") return s.toLowerCase();
+  if (c === "title") return s.replace(/\b\w/g, (m) => m.toUpperCase());
+  if (c === "small" || c === "super" || c === "sub") return (slEngine().styleText || ((x) => x))(s, c);
+  return s;
+}
+// A C0 or C1 control character in authored text is a terminal-escape
+// injection: the hook prints the layout to a terminal.
+function slHasControl(s) {
+  return /[\u0000-\u001f\u007f-\u009f]/.test(String(s));
+}
 const SL_TRUNCATE = ["end", "middle", "none"];
 
 // ── The component registry ─────────────────────────────────────────────────
@@ -42247,6 +43229,26 @@ function slRow(o) {
   );
 }
 
+// v2.0.4 — THE SPRITES. Every glyph is exactly 1 cell and every frame of one
+// sprite has the same width; test/statusline-pets.test.js proves it. `a` is the
+// ASCII twin of each frame. `ahead` / `behind` fill the track in front of and
+// behind the sprite ("" = a space).
+const SL_SPRITES = {
+  "pet-cat": { summary: "A pixel cat that runs along the line.", f: ["⠑⡤⡤⠤⡷⡃", "⠑⢤⢤⠤⣷⠃"], a: ["=^.^=", "=^o^="], ms: 1000, ahead: "", behind: "" },
+  "pet-mouse": { summary: "A pixel mouse that runs along the line.", f: ["⢲⠾⡇", "⠲⣾⠇"], a: ["<:3", "<:3"], ms: 700, ahead: "", behind: "" },
+  "pet-chase": { summary: "A pixel cat that chases a mouse along the line.", f: ["⠑⡤⡤⠤⡷⡃  ⢲⠾⡇", "⠑⢤⢤⠤⣷⠃  ⠲⣾⠇"], a: ["=^.^=  <:3", "=^o^=  <:3"], ms: 1000, ahead: "", behind: "" },
+  "pet-cat-text": { summary: "A cat made of letters.", f: ["ᓚᘏᗢ", "ᓚᘏᗢ"], a: ["=^.^=", "=^.^="], ms: 1000, ahead: "", behind: "" },
+  "pet-pacman": { summary: "Pac-Man eats the dots in front of him.", f: ["ᗧ", "●"], a: ["C", "O"], ms: 800, ahead: "·", behind: " ", ahead_a: "." },
+  "pet-fish": { summary: "A fish that swims along the line.", f: [" ><>", "°><>"], a: [" ><>", "o><>"], ms: 1200, ahead: "", behind: "" },
+  "pet-bird": { summary: "A bird that flies along the line.", f: ["\\v/", "-v-"], a: ["\\v/", "-v-"], ms: 600, ahead: "", behind: "" },
+  "pet-dog": { summary: "A dog that runs along the line.", f: ["V•ᴥ•V", "V•ᴥ•V"], a: ["V.w.V", "V.w.V"], ms: 900, ahead: "", behind: "" },
+};
+const SL_SPRITE_SPEED = { slow: 2, normal: 1, fast: 0.5 };
+
+// The weather parts share their parameters. "" = the provider finds the place
+// from your IP address.
+const SL_WEATHER_PARAMS = { location: { free: true, dflt: "", max: 40 }, units: { options: ["metric", "us"], dflt: "metric" } };
+
 const STATUSLINE_COMPONENTS = [
   // ── Group A — Session and tier. Straight from the payload. Free. ─────────
   slRow({ id: "verdict", group: "A", summary: "The ORC-ready verdict icon.", renderers: ["icon", "shape", "dot", "word", "badge", "pill"], defaults: { render: "icon" }, states: ["ready", "boosted", "degrade"], shapes: { ready: "✅", boosted: "🚀", degrade: "⛔" }, binding: "verdict.state", state_binding: "verdict.state" }),
@@ -42278,9 +43280,9 @@ const STATUSLINE_COMPONENTS = [
   slRow({ id: "quota-spend-reset", group: "B", label: "reset", summary: "Minutes until the spend limit resets.", renderers: ["bare", "plain", "paren"], defaults: { render: "paren", suffix: "m" }, unknown: "hide", binding: "quota.spend.reset", time_based: true }),
   slRow({ id: "cost-usd", group: "B", summary: "Session cost in dollars, straight from the payload. No price table, no join.", renderers: ["bare", "plain", "label-value", "spark"], defaults: { render: "bare", prefix: "$", precision: 2 }, series: "cost", binding: "cost.usd" }),
   slRow({ id: "cost-rate", group: "B", label: "/h", summary: "Dollars per hour of session.", renderers: ["bare", "plain", "label-value"], defaults: { render: "plain", prefix: "$", precision: 2 }, binding: "cost.rate_usd_h" }),
-  slRow({ id: "api-time", group: "B", label: "api", summary: "Time spent waiting on the API.", renderers: ["bare", "plain", "label-value"], defaults: { render: "plain", suffix: "m" }, binding: "cost.api_ms" }),
+  slRow({ id: "api-time", group: "B", label: "api", summary: "Time spent waiting on the API.", renderers: ["bare", "plain", "label-value"], defaults: { render: "plain", suffix: "m" }, binding: "cost.api_min" }),
   slRow({ id: "api-ratio", group: "B", label: "api", summary: "How much of this session was waiting rather than thinking.", renderers: ["bar", "blocks", "gauge", "ring", "plain", "fine", "dots"], defaults: { render: "gauge" }, bounded: true, binding: "cost.api_ratio" }),
-  slRow({ id: "wall-time", group: "B", label: "wall", summary: "Total session wall time.", renderers: ["bare", "plain", "label-value"], defaults: { render: "plain", suffix: "m" }, binding: "cost.wall_ms", time_based: true }),
+  slRow({ id: "wall-time", group: "B", label: "wall", summary: "Total session wall time.", renderers: ["bare", "plain", "label-value"], defaults: { render: "plain", suffix: "m" }, binding: "cost.wall_min", time_based: true }),
   slRow({ id: "tok-speed", group: "B", label: "tok/s", summary: "Main tokens per second of session.", renderers: ["bare", "plain", "label-value", "spark"], defaults: { render: "plain" }, series: "speed", cost: "scan", binding: "mtok.speed" }),
 
   // ── Group C — Run state. From the ONE throttled scan. ────────────────────
@@ -42331,7 +43333,7 @@ const STATUSLINE_COMPONENTS = [
   slRow({ id: "worktree", group: "H", summary: "Whether this is a worktree, and which kind.", renderers: ["bare", "shape", "badge", "word"], defaults: { render: "shape" }, states: ["main", "worktree", "detached"], shapes: { main: "·", worktree: "⑂", detached: "!" }, unknown: "hide", binding: "worktree.state", state_binding: "worktree.state" }),
   slRow({ id: "worktree-branch", group: "H", summary: "The worktree's branch.", renderers: ["bare", "plain", "paren"], defaults: { render: "bare" }, unknown: "hide", binding: "worktree.branch" }),
   slRow({ id: "worktree-origin", group: "H", label: "from", summary: "The branch the worktree came from.", renderers: ["bare", "plain", "paren"], defaults: { render: "paren" }, unknown: "hide", binding: "worktree.origin" }),
-  slRow({ id: "lines-added", group: "H", label: "+", summary: "Lines added this session — a diff size with no subprocess.", renderers: ["bare", "plain", "label-value"], defaults: { render: "plain", sign: "always" }, binding: "cost.lines_added" }),
+  slRow({ id: "lines-added", group: "H", label: "+", summary: "Lines added this session — a diff size with no subprocess.", renderers: ["bare", "plain", "label-value"], defaults: { render: "plain", sign: "auto" }, binding: "cost.lines_added" }),
   slRow({ id: "lines-removed", group: "H", label: "−", summary: "Lines removed this session.", renderers: ["bare", "plain", "label-value"], defaults: { render: "plain" }, binding: "cost.lines_removed" }),
   slRow({ id: "lines-net", group: "H", label: "Δ", summary: "Net lines this session.", renderers: ["bare", "plain", "trend", "spark", "label-value"], defaults: { render: "plain", sign: "always" }, states: ["growing", "shrinking", "flat"], shapes: { growing: "▲", shrinking: "▼", flat: "▶" }, series: "lines", binding: "cost.lines_net", state_binding: "cost.lines_state" }),
   slRow({ id: "pr-number", group: "H", label: "PR", summary: "The pull request for this branch. The link is ALWAYS a decoration on text that reads fine without it — Terminal.app does not support OSC 8.", renderers: ["bare", "plain", "label-value", "badge", "link"], defaults: { render: "link", prefix: "#" }, unknown: "hide", binding: "pr.number" }),
@@ -42344,9 +43346,9 @@ const STATUSLINE_COMPONENTS = [
   slRow({ id: "text", group: "I", summary: "Any text you type. Also where a Nerd Font glyph goes, if you have one — ORC ships none, because it cannot detect the font.", renderers: ["bare", "badge", "pill", "bracket", "angle"], defaults: { render: "bare" }, unknown: "hide", params: { text: { free: true, dflt: "" } }, binding: "static.text" }),
   slRow({ id: "clock", group: "I", summary: "The wall clock. Needs `refreshInterval` to tick.", renderers: ["bare", "plain", "label-value"], defaults: { render: "bare" }, params: { format: { options: ["HH:mm", "HH:mm:ss", "h:mm a"], dflt: "HH:mm" } }, binding: "clock.now", time_based: true }),
   slRow({ id: "elapsed", group: "I", summary: "Minutes since this session opened.", renderers: ["bare", "plain", "label-value"], defaults: { render: "plain", suffix: "m" }, binding: "session.elapsed_min", time_based: true }),
-  slRow({ id: "spacer", group: "I", summary: "Literal spaces. Does not count against the 5-per-line limit.", renderers: ["bare"], defaults: { render: "bare" }, unknown: "hide", params: { width: { options: [1, 2, 3, 4, 6, 8], dflt: 1 } }, binding: "static.text" }),
-  slRow({ id: "divider", group: "I", summary: "A styled break between GROUPS of components — the second separator kind. Does not count against the 5-per-line limit.", renderers: ["bare"], defaults: { render: "bare" }, unknown: "hide", params: { text: { free: true, dflt: " │ " } }, binding: "static.text" }),
-  slRow({ id: "fill", group: "I", summary: "Pushes everything after it to the right edge. Exact, because Claude Code sets COLUMNS before the script runs. Does not count against the 5-per-line limit.", renderers: ["bare"], defaults: { render: "bare" }, unknown: "hide", params: { weight: { options: [1, 2, 3], dflt: 1 } }, binding: "static.text" }),
+  slRow({ id: "spacer", group: "I", summary: "Literal spaces. Does not count against the per-line limit.", renderers: ["bare"], defaults: { render: "bare" }, unknown: "hide", params: { width: { options: [1, 2, 3, 4, 6, 8], dflt: 1 } }, binding: "static.text" }),
+  slRow({ id: "divider", group: "I", summary: "A styled break between GROUPS of components — the second separator kind. Does not count against the per-line limit.", renderers: ["bare"], defaults: { render: "bare" }, unknown: "hide", params: { text: { free: true, dflt: " │ " } }, binding: "static.text" }),
+  slRow({ id: "fill", group: "I", summary: "Pushes everything after it to the right edge. Exact, because Claude Code sets COLUMNS before the script runs. Does not count against the per-line limit.", renderers: ["bare"], defaults: { render: "bare" }, unknown: "hide", params: { weight: { options: [1, 2, 3], dflt: 1 } }, binding: "static.text" }),
 
 
   // ── Group D — Knowledge. Every row here comes out of wiki-meta.json, the
@@ -42404,7 +43406,7 @@ const STATUSLINE_COMPONENTS = [
 
   // ── Group I remainder ───────────────────────────────────────────────────
   slRow({ id: "config", group: "I", summary: "Any ORC config key, as a component. It shows what is IN THE FILE — a hook has no lane, so it cannot resolve a key the way a lane would.", renderers: ["plain", "label-value", "bare", "badge"], defaults: { render: "label-value" }, cost: "new-read", params: { key: { free: true, dflt: "extra_enabled" } }, binding: "config.value" }),
-  slRow({ id: "group", group: "I", summary: "Two to four parts drawn as ONE object — shared brackets, one background, one emphasis. It counts as ONE slot against the five, because the limit is about how much a line SAYS and a group says one thing.", renderers: ["bracket", "badge", "pill", "angle"], defaults: { render: "pill" }, unknown: "hide", children: [2, 4], binding: "static.text" }),
+  slRow({ id: "group", group: "I", summary: "Two to four parts drawn as ONE object — shared brackets, one background, one emphasis. It counts as ONE slot against the per-line limit, because the limit is about how much a line SAYS and a group says one thing.", renderers: ["bracket", "badge", "pill", "angle"], defaults: { render: "pill" }, unknown: "hide", children: [2, 4], binding: "static.text" }),
   slRow({ id: "icon-static", group: "I", summary: "One glyph you choose, from the shipped sets. Not an icon font — ORC ships none, because it cannot detect one.", renderers: ["bare"], defaults: { render: "bare" }, unknown: "hide", params: { glyph: { free: true, dflt: "●" } }, binding: "static.text" }),
 
   // ── REFUSED, with the measurement recorded ──────────────────────────────
@@ -42426,6 +43428,14 @@ const STATUSLINE_COMPONENTS = [
   slRow({ id: "task-elapsed", group: "T", board: "subagent", label: "for", summary: "How long this agent has been running.", renderers: ["plain", "label-value", "bare"], defaults: { render: "plain", min_width: 3, align: "right", suffix: "m" }, binding: "task.elapsed_min", time_based: true }),
   slRow({ id: "task-what", group: "T", board: "subagent", summary: "What this agent was asked to do.", renderers: ["bare", "plain"], defaults: { render: "bare", truncate: "end", max_len: 40 }, unknown: "hide", binding: "task.description" }),
 
+  // ── Group M — Pets and motion (v2.0.4). A pet is a SPRITE: the frames are
+  //    data in SL_SPRITES, and the engine only moves them along a track. A
+  //    pet counts against the per-line limit — it is a thing the line shows.
+  ...Object.entries(SL_SPRITES).map(([id, sp]) => slRow({ id, group: "M", summary: sp.summary, renderers: ["run", "bounce", "idle"], defaults: { render: "run", width: 16 }, unknown: "hide", params: { speed: { options: ["slow", "normal", "fast"], dflt: "normal" } }, binding: "clock.now", time_based: true, sprite: id })),
+  slRow({ id: "weather", group: "M", label: "", summary: "The temperature where you are. It is read from wttr.in in the background, at most every 30 minutes.", renderers: ["plain", "bare", "label-value"], defaults: { render: "plain" }, cost: "new-read", params: SL_WEATHER_PARAMS, binding: "weather.temp" }),
+  slRow({ id: "weather-icon", group: "M", summary: "The sky where you are, as one shape.", renderers: ["shape", "icon", "word"], defaults: { render: "shape" }, states: ["sun", "partly", "cloud", "rain", "snow", "storm", "fog"], shapes: { sun: "☼", partly: "◐", cloud: "☁", rain: "☂", snow: "❄", storm: "ϟ", fog: "≋" }, ascii_shapes: { sun: "*", partly: "o", cloud: "c", rain: "r", snow: "s", storm: "!", fog: "=" }, cost: "new-read", params: SL_WEATHER_PARAMS, binding: "weather.state", state_binding: "weather.state" }),
+  slRow({ id: "weather-desc", group: "M", summary: "The short weather text from the provider (24 cells or less).", renderers: ["bare", "plain"], defaults: { render: "bare", truncate: "end", max_len: 24 }, cost: "new-read", params: SL_WEATHER_PARAMS, binding: "weather.desc" }),
+
   // ── Group J — Composite shortcuts. One slot, several facts. ─────────────
   slRow({ id: "tier-block", group: "J", summary: "Verdict + version + model/effort as one object.", renderers: ["plain", "badge", "pill"], defaults: { render: "pill" }, states: ["ready", "boosted", "degrade"], binding: "tier.text", state_binding: "verdict.state", composite: ["verdict", "orc-version", "tier"] }),
   slRow({ id: "quota-block", group: "J", label: "quota", summary: "Both windows as one object.", renderers: ["plain", "badge", "pill"], defaults: { render: "plain" }, states: ["ok", "warn", "critical"], binding: "quota.worst.pct", state_binding: "quota.worst.state", composite: ["quota-5h", "quota-week"] }),
@@ -42604,6 +43614,7 @@ function slResolveItem(item, layout, line) {
 
   out.id = item.id;
   out.type = item.type;
+  out._theme = themeName;
   out._comp = comp;
   out._from = from;
   return out;
@@ -42706,6 +43717,8 @@ function slValidate(layout) {
           E(`"${r}" on "${comp.id}" — ${comp.id} has no states, so there is nothing for a shape to say.`);
         if (rend.needs === "series" && !comp.series)
           E(`"${r}" on "${comp.id}" — no history is kept for ${comp.id}. Series are kept for: ${slSeriesComponents().join(", ")}.`);
+        if (rend.needs === "sprite" && !comp.sprite)
+          E(`"${r}" on "${comp.id}" — only a pet moves along the line.`);
         if (rend.needs === "motif" && !comp.state_binding)
           E(`"${r}" on "${comp.id}" — motion is only for a component with a phase kind.`);
         if (rend.width && item.width != null) {
@@ -42745,8 +43758,17 @@ function slValidate(layout) {
         const given = item.params || {};
         for (const k of Object.keys(given)) {
           if (!comp.params[k]) E(`"${comp.id}" takes no parameter "${k}" — it takes: ${Object.keys(comp.params).join(", ")}`);
+          else if (comp.params[k].options && !comp.params[k].options.map(String).includes(String(given[k])))
+            E(`parameter "${k}" on ${where} takes one of: ${comp.params[k].options.join(", ")}`);
+          else if (comp.params[k].max && String(given[k]).length > comp.params[k].max)
+            E(`parameter "${k}" on ${where} is longer than ${comp.params[k].max} characters`);
+          else if (comp.params[k].free && slCellWidth(given[k]) > SL_LIMITS.param_text)
+            E(`parameter "${k}" on ${where} is longer than ${SL_LIMITS.param_text} cells`);
         }
+      } else if (item.params && Object.keys(item.params).length) {
+        E(`"${comp.id}" takes no parameters (${where})`);
       }
+      slValidateDesign(item, comp, where, board, E);
 
       // ── Tier 3 — design. The rules a human gets wrong and a machine can
       //    check. WARNINGS NEVER BLOCK: an error is a refusal, a warning is a
@@ -42765,12 +43787,21 @@ function slValidate(layout) {
     });
   });
 
+  layout.lines.forEach((line, li) => {
+    const where = `line ${li + 1}`;
+    for (const k of ["separator", "prefix"])
+      if (line[k] != null && slHasControl(line[k])) E(`the ${k} on ${where} holds a control character — a layout is printed to a terminal, so it may not carry one`);
+    if (line.align != null && !SL_LINE_ALIGNS.includes(line.align)) E(`unknown line align "${line.align}" on ${where} — use: ${SL_LINE_ALIGNS.join(", ")}`);
+    if (line.align != null && line.align !== "left" && board.id === "subagent") E(`line align on ${where} — the subagent row is one terminal row and cannot be aligned`);
+    if (line.sep_color != null && !slParseColor(line.sep_color)) E(`"${line.sep_color}" is not a colour (separator colour on ${where})`);
+  });
+
   // Cross-item design warnings.
   layout.lines.forEach((line, li) => {
     const bindings = new Map();
     for (const it of line.items || []) {
       const c = SL_BY_ID.get(it.type);
-      if (!c || !c.binding) continue;
+      if (!c || !c.binding || c.binding === "static.text") continue;
       bindings.set(c.binding, (bindings.get(c.binding) || 0) + 1);
     }
     for (const [b, n] of bindings) {
@@ -42787,6 +43818,81 @@ function slValidate(layout) {
   return { ok: errors.length === 0, errors, warnings };
 }
 
+// v2.0.4 — the design fields of ONE item. Every problem is collected, and each
+// sentence names the position.
+function slValidateDesign(item, comp, where, board, E) {
+  const oneOf = (k, set) => {
+    if (item[k] != null && !set.includes(item[k])) E(`unknown ${k} "${item[k]}" on ${where} — use: ${set.join(", ")}`);
+  };
+  oneOf("label_pos", SL_LABEL_POS);
+  oneOf("value_pos", SL_VALUE_POS);
+  oneOf("caption_pos", SL_CAPTION_POS);
+  oneOf("caption_align", SL_CAPTION_ALIGN);
+  oneOf("caption_case", SL_CASES);
+  oneOf("align", SL_ALIGNS);
+  oneOf("sign", SL_SIGNS);
+  oneOf("unknown", SL_UNKNOWNS);
+  // SECURITY: no control character in any free text.
+  const texts = [["label", item.label], ["prefix", item.prefix], ["suffix", item.suffix], ["caption", item.caption], ["fill_char", item.fill_char], ["empty_char", item.empty_char]];
+  for (const b of Array.isArray(item.brackets) ? item.brackets : []) texts.push(["brackets", b]);
+  for (const g of Object.values(item.glyph_by_state || {})) texts.push(["glyph_by_state", g]);
+  for (const [k, v] of Object.entries(item.params || {})) texts.push(["parameter " + k, v]);
+  for (const [k, v] of texts)
+    if (v != null && slHasControl(v)) E(`the ${k} on ${where} holds a control character — a layout is printed to a terminal, so it may not carry one`);
+  if (item.caption != null && slCellWidth(item.caption) > SL_LIMITS.caption) E(`the caption on ${where} is wider than ${SL_LIMITS.caption} cells`);
+  const oneCell = (k, v) => {
+    if (v == null) return;
+    if ([...String(v)].length !== 1 || slCellWidth(v) !== 1) E(`${k} "${v}" on ${where} must be one character of exactly 1 cell`);
+  };
+  oneCell("fill_char", item.fill_char);
+  oneCell("empty_char", item.empty_char);
+  for (const [st, g] of Object.entries(item.glyph_by_state || {})) {
+    if (!comp.states || !comp.states.includes(st)) E(`glyph_by_state key "${st}" — "${comp.id}" has states: ${(comp.states || []).join(", ") || "none"}`);
+    oneCell(`glyph_by_state ${st}`, g);
+  }
+  for (const [st, c] of Object.entries(item.color_by_state || {}))
+    if (c != null && !slParseColor(c)) E(`"${c}" is not a colour (color_by_state ${st} on ${where})`);
+  for (const k of ["caption_color", "fill_color", "empty_color"]) {
+    const v = item[k];
+    if (v == null || v === "none") continue;
+    if (!slParseColor(v)) E(`"${v}" is not a colour (${k} on ${where})`);
+  }
+  if (item.ramp_colors != null) {
+    const rc = item.ramp_colors;
+    const [lo, hi] = SL_LIMITS.ramp_colors;
+    if (!Array.isArray(rc) || rc.length < lo || rc.length > hi) E(`ramp_colors on ${where} takes ${lo} to ${hi} colours`);
+    else for (const c of rc) if (!slParseColor(c) || /^ramp:/.test(c)) E(`"${c}" is not a colour (ramp_colors on ${where})`);
+  }
+  if (item.ramp_stops != null) {
+    const st = item.ramp_stops;
+    const ok = Array.isArray(st) && st.every((n, i) => typeof n === "number" && isFinite(n) && n >= 0 && n <= 100 && (i === 0 || n > st[i - 1]));
+    if (!ok) E(`ramp_stops on ${where} must be ascending numbers from 0 to 100`);
+    else if (Array.isArray(item.ramp_colors) && st.length !== item.ramp_colors.length) E(`ramp_stops on ${where} has ${st.length} stops for ${item.ramp_colors.length} colours — give one stop per colour`);
+  }
+  if (item.brackets != null) {
+    const b = item.brackets;
+    if (!Array.isArray(b) || b.length !== 2 || b.some((x) => typeof x !== "string" || slCellWidth(x) > SL_LIMITS.brackets))
+      E(`brackets on ${where} take "L,R", each 0 to ${SL_LIMITS.brackets} cells`);
+  }
+  const num = (k, lo, hi) => {
+    const v = item[k];
+    if (v == null) return;
+    if (typeof v !== "number" || !Number.isInteger(v) || v < lo || v > hi) E(`${k} on ${where} takes a whole number from ${lo} to ${hi}`);
+  };
+  num("threshold", 0, 100);
+  num("max_len", 0, SL_LIMITS.max_len);
+  if (item.padding != null) {
+    const p = item.padding;
+    if (!Array.isArray(p) || p.length !== 2 || p.some((n) => !Number.isInteger(n) || n < 0 || n > SL_LIMITS.padding))
+      E(`padding on ${where} takes two whole numbers from 0 to ${SL_LIMITS.padding}`);
+  }
+  // The subagent row is ONE terminal row by construction: no caption rows.
+  if (board.id === "subagent") {
+    if (item.caption != null) E(`a caption on ${where} — the subagent row is one terminal row, so it has no caption row`);
+    if (item.label_pos === "above" || item.label_pos === "below") E(`label_pos ${item.label_pos} on ${where} — the subagent row is one terminal row`);
+  }
+}
+
 // spacer / divider / fill do not count against the 5-per-line limit: the limit
 // is about how much a line SAYS, and none of the three says anything.
 function slIsStructural(type) {
@@ -42885,7 +43991,8 @@ function slCompile(layout) {
       : b.startsWith("wiki.") ? "scan.wiki"
         : b.startsWith("diy.") ? "scan.diy"
           : b.startsWith("update.") ? "scan.update"
-            : "scan.trace";
+            : b.startsWith("weather.") ? "scan.weather"
+              : "scan.trace";
   // W3's groups all read files the shipped status line never opens, so they
   // share one gate — the extended scan — and each sub-read inside it carries
   // its own TTL. One gate, many clocks.
@@ -42933,10 +44040,21 @@ function slCompile(layout) {
       // takes its separator with it. This is Starship's conditional group, and
       // it is what stops a dangling ` ·  · `. No user ever configures it.
       const children = [];
-      if (visible > 0 && !slIsStructural(item.type)) children.push(slLit(sep));
+      const lowered = slLowerItem(r, comp, { formats, glyphsets, statemaps, ramps, idxOf, layout });
+      // An empty `text` part lowers to nothing, and takes no separator with it.
+      if (!lowered.length && comp.id === "text") return;
+      const sepd = visible > 0 && !slIsStructural(item.type);
+      if (sepd) {
+        // The separator colour wraps the lit ONLY when the line sets one, so
+        // an unchanged line compiles to unchanged bytes.
+        const sc = line.sep_color ? slSgr(line.sep_color, null, null) : null;
+        if (sc) children.push({ op: "sgr", s: sc });
+        children.push(slLit(sep));
+        if (sc) children.push({ op: "reset" });
+      }
       visible++;
 
-      for (const op of slLowerItem(r, comp, { formats, glyphsets, statemaps, ramps, idxOf, layout })) children.push(op);
+      for (const op of lowered) children.push(op);
 
       const hide = (r.hide_when || []).filter((h) => h !== "never");
       const itemOp = {
@@ -42959,6 +44077,11 @@ function slCompile(layout) {
       if (slIsStructural(item.type)) itemOp.s = 1;
       if (r.min_cols) itemOp.min_cols = r.min_cols;
       if (r.max_cols) itemOp.max_cols = r.max_cols;
+      if (lowered.cap) {
+        itemOp.cap = lowered.cap;
+        if (sepd) itemOp.sw = slCellWidth(sep);
+      }
+      if (lowered.p) itemOp.p = lowered.p;
       ops.push(itemOp);
 
       // The responsive drop order: priority first (1 = keep longest), then
@@ -42966,23 +44089,27 @@ function slCompile(layout) {
       dropCandidates.push({ id: item.id, line: li, pos: pi, priority: r.priority || 3, min_cols: r.min_cols || 0 });
     });
 
-    lines.push({ prefix: line.prefix || "", separator: sep, ops, static_width: slMeasure(ops, { formats, glyphsets, statemaps }) });
+    const out = { prefix: line.prefix || "", separator: sep, ops, static_width: slMeasure(ops, { formats, glyphsets, statemaps }) };
+    if (line.align === "center" || line.align === "right") out.align = line.align;
+    lines.push(out);
   });
 
   // S5 — the responsive plans. Derived from each item's min_cols and priority;
   // the hook does ONE lookup and no measuring at render time.
   dropCandidates.sort((a, b) => b.priority - a.priority || b.pos - a.pos);
   const widths = [160, 120, 100, 80, 72];
-  const totalStatic = lines.reduce((m, l) => Math.max(m, l.static_width), 0);
+  // PER LINE: only a line wider than w loses parts, and only its own parts.
   for (const w of widths) {
-    if (totalStatic <= w) continue;
     const drop = [];
-    let est = totalStatic;
-    for (const c of dropCandidates) {
-      if (est <= w) break;
-      drop.push(c.id);
-      est -= 8; // a conservative per-item estimate; the exact width is measured
-    }
+    lines.forEach((l, li) => {
+      let est = l.static_width;
+      for (const c of dropCandidates) {
+        if (est <= w) break;
+        if (c.line !== li) continue;
+        drop.push(c.id);
+        est -= 8; // a conservative per-item estimate; the exact width is measured
+      }
+    });
     if (drop.length) plans.push({ cols: w, drop });
   }
   plans.sort((a, b) => a.cols - b.cols);
@@ -43019,7 +44146,8 @@ function slCompile(layout) {
     bindings: [...bindings].sort(),
     providers: [...providers].sort(),
     series: [...seriesWanted].sort(),
-    needs_refresh_interval: timeBased ? 5 : null,
+    // Motion (a sprite, a motif, a pulse) needs the timer at its fastest.
+    needs_refresh_interval: slHasMotion(compiled) ? 1 : timeBased ? 5 : null,
     // THE CAP TRAVELS WITH THE PROGRAM (v1.4.2). A hook cannot call this CLI —
     // a status line re-renders on every keystroke — so before this it simply
     // held its own `5`, and raising the cap here left every legal six-part line
@@ -43032,12 +44160,33 @@ function slCompile(layout) {
   return { compiled, lock };
 }
 
+// Whether a compiled program MOVES: a sprite, a motif or a pulse op anywhere.
+function slHasMotion(compiled) {
+  const walk = (list) => (list || []).some((o) => o && (o.op === "sprite" || o.op === "motif" || walk(o.children) || (o.cap && walk(o.cap.ops))));
+  return ((compiled && compiled.lines) || []).some((l) => walk(l.ops));
+}
+
 function slLowerItem(r, comp, T) {
   const ops = [];
   const rend = STATUSLINE_RENDERERS[r.render] || STATUSLINE_RENDERERS.bare;
-  const label = r.label == null ? null : String(r.label);
+  const rawLabel = r.label == null ? null : String(r.label);
+  const from = r._from || {};
+  // v2.0.4 — a label the ITEM moved. Only an authored position moves it, so
+  // an existing layout compiles to the same bytes.
+  // A non-text shape with an item-authored name and no authored position
+  // draws the name before the shape — the Name box must not be a no-op.
+  const shapeKind = rend.kind === "bar" || rend.kind === "series" || rend.kind === "state" || rend.kind === "motif" || rend.kind === "sprite";
+  const lpos = from.label_pos === "item" ? r.label_pos : shapeKind && from.label === "item" && rawLabel ? "before" : null;
+  const label = lpos && lpos !== "before" ? null : rawLabel;
   const caseOf = r.case || "none";
-  const applyCase = (s) => (caseOf === "upper" ? s.toUpperCase() : caseOf === "lower" ? s.toLowerCase() : caseOf === "title" ? s.replace(/\b\w/g, (m) => m.toUpperCase()) : s);
+  const applyCase = (s) => slCaseText(s, caseOf);
+  // A styled lit keeps its PLAIN text as the ASCII twin: `ᴄᴛx` falls back to
+  // `ctx`, never to `???`.
+  const styledLit = (plain, c) => {
+    const t = slCaseText(plain, c);
+    const a = slAsciiOf(slCaseText(plain, ["small", "super", "sub"].includes(c) ? "none" : c));
+    return a === t ? { op: "lit", t } : { op: "lit", t, a };
+  };
 
   const fmt = {
     kind: r.format || "plain",
@@ -43054,19 +44203,43 @@ function slLowerItem(r, comp, T) {
     prefix: r.prefix ? String(r.prefix) : "",
     suffix: r.suffix ? String(r.suffix) : "",
   };
+  // v2.0.4 — a weather part carries WHAT to fetch; the temperature takes its
+  // unit suffix from `units` unless the item set its own suffix.
+  const isWeather = /^weather\./.test(comp.binding || "");
+  const wp = isWeather ? { location: String(((r.params || {}).location != null ? r.params.location : comp.params.location.dflt)), units: String((r.params || {}).units || comp.params.units.dflt) } : null;
+  if (comp.id === "weather" && from.suffix !== "item") fmt.suffix = wp.units === "us" ? "°F" : "°C";
   const fi = T.idxOf(T.formats, fmt);
-  const gs = STATUSLINE_GLYPHSETS[r.glyphs] || STATUSLINE_GLYPHSETS.blocks;
+  let gs = STATUSLINE_GLYPHSETS[r.glyphs] || STATUSLINE_GLYPHSETS.blocks;
+  // v2.0.4 — the user's own fill and empty cells, on a CLONE. The ASCII twins
+  // keep their ASCII form.
+  if (r.fill_char != null || r.empty_char != null) {
+    gs = Object.assign({}, gs);
+    if (r.fill_char != null) for (const k of ["fill", "meter_on", "on", "braille_fill"]) gs[k] = String(r.fill_char);
+    if (r.empty_char != null) for (const k of ["empty", "meter_off", "off", "braille_empty", "track"]) gs[k] = String(r.empty_char);
+  }
   const gi = T.idxOf(T.glyphsets, gs);
 
   const labelSgr = slSgr(r.label_color, r.emphasis, r.bg);
   const valueSgr = r.value_color && String(r.value_color).startsWith("ramp:") ? null : slSgr(r.value_color, r.emphasis, r.bg);
+  // Emphasis alone, for a value op that carries its own colour.
+  const emphSgr = slSgr(null, r.emphasis, r.bg);
   let ri = null;
-  const rampName = r.ramp || (String(r.value_color || "").startsWith("ramp:") ? String(r.value_color).slice(5) : null);
+  const vFrom = (r._from || {}).value_color || "";
+  const itemColor = (vFrom === "item" || vFrom === "item:color") && r.value_color && !String(r.value_color).startsWith("ramp:");
+  const rampFromItem = (r._from || {}).ramp === "item";
+  // A colour the user set beats a ramp the user did not set. Mono means no
+  // colour, so a default ramp does not apply there either.
+  let rampName = r.ramp && (rampFromItem || (!itemColor && r._theme !== "mono")) ? r.ramp : null;
+  if (!rampName && String(r.value_color || "").startsWith("ramp:")) rampName = String(r.value_color).slice(5);
   if (rampName && STATUSLINE_RAMPS[rampName] && rampName !== "state") {
     const rp = STATUSLINE_RAMPS[rampName];
     const stops = r.ramp_stops || rp.stops;
     ri = T.idxOf(T.ramps, { stops, sgr: rp.colors.map((c, i) => slSgr(c, rp.emphasis ? [rp.emphasis[i]] : null, null) || "") });
   }
+  // v2.0.4 — the item's own ramp. It is used wherever a ramp would be.
+  const rampColors = Array.isArray(r.ramp_colors) && r.ramp_colors.length >= 2 ? r.ramp_colors.map(String) : null;
+  const rampStops = rampColors ? (Array.isArray(r.ramp_stops) && r.ramp_stops.length === rampColors.length ? r.ramp_stops : rampColors.map((_, i) => Math.round((i * 100) / rampColors.length))) : null;
+  if (rampColors) ri = T.idxOf(T.ramps, { stops: rampStops, sgr: rampColors.map((c) => slSgr(c, null, null) || "") });
 
   // The state map: glyph, ASCII twin and colour per state. Built ONCE here so
   // the `state` renderer and the `word` renderer can never disagree about what
@@ -43074,8 +44247,8 @@ function slLowerItem(r, comp, T) {
   const stateMap = () => {
     const map = { glyphs: {}, sgr: {}, ascii: {} };
     for (const st of comp.states || []) {
-      map.glyphs[st] = (comp.shapes && comp.shapes[st]) || st.slice(0, 1);
-      map.ascii[st] = slAsciiOf(map.glyphs[st]);
+      map.glyphs[st] = (r.glyph_by_state && r.glyph_by_state[st]) || (comp.shapes && comp.shapes[st]) || st.slice(0, 1);
+      map.ascii[st] = !(r.glyph_by_state && r.glyph_by_state[st]) && comp.ascii_shapes && comp.ascii_shapes[st] ? comp.ascii_shapes[st] : slAsciiOf(map.glyphs[st]);
       const c = (r.color_by_state && r.color_by_state[st]) || slStateColor(st, r, T.layout);
       const sg = slSgr(c, r.emphasis, r.bg);
       if (sg) map.sgr[st] = sg;
@@ -43094,10 +44267,65 @@ function slLowerItem(r, comp, T) {
   const pushLabel = (text, sep) => {
     if (!text) return;
     if (labelSgr) ops.push({ op: "sgr", s: labelSgr });
-    ops.push(slLit(applyCase(text) + sep));
+    ops.push(styledLit(text + sep, caseOf));
+    if (labelSgr) ops.push({ op: "reset" });
+  };
+  // The same label, drawn beside a non-text shape or after a text value. A
+  // separate name from `pushLabel`, which mirrors SL_LABEL_RENDERERS.
+  const sideLabel = (text, before, after) => {
+    if (labelSgr) ops.push({ op: "sgr", s: labelSgr });
+    ops.push(styledLit(before + text + after, caseOf));
     if (labelSgr) ops.push({ op: "reset" });
   };
 
+  // v2.0.4 — THE CAPTION: ordinary ops in their own row, above or below.
+  const capOps = [];
+  const capLabel = lpos === "above" || lpos === "below";
+  if (capLabel && rawLabel) {
+    if (labelSgr) capOps.push({ op: "sgr", s: labelSgr });
+    capOps.push(styledLit(rawLabel, caseOf));
+    if (labelSgr) capOps.push({ op: "reset" });
+  }
+  if (r.caption != null && String(r.caption) !== "") {
+    const cc = r.caption_case || "none";
+    const csg = slSgr(r.caption_color, null, null);
+    if (capOps.length) capOps.push(slLit(" "));
+    if (csg) capOps.push({ op: "sgr", s: csg });
+    for (const part of String(r.caption).split(/(\{value\}|\{label\})/)) {
+      if (!part) continue;
+      if (part === "{value}") capOps.push(Object.assign({ op: "val", b: comp.binding, f: cc === "none" ? fi : T.idxOf(T.formats, Object.assign({}, fmt, { case: cc })) }, wp ? { p: wp } : {}));
+      else capOps.push(styledLit(part === "{label}" ? rawLabel || "" : part, cc));
+    }
+    if (csg) capOps.push({ op: "reset" });
+  }
+  if (capOps.length) ops.cap = { pos: capLabel ? lpos : r.caption_pos || "below", align: r.caption_align || "left", ops: capOps };
+
+  // v2.0.4 — the static parts draw their own text. They bound `static.text`,
+  // which is null, so before this they drew nothing at all.
+  if (comp.binding === "static.text" && !comp.children) {
+    const prm = r.params || {};
+    const dflt = (k) => (comp.params && comp.params[k] ? comp.params[k].dflt : undefined);
+    if (comp.id === "fill") {
+      ops.push({ op: "flex", w: Number(prm.weight != null ? prm.weight : dflt("weight")) || 1, min: 1 });
+      return ops;
+    }
+    let t = "";
+    if (comp.id === "text") t = String(prm.text != null ? prm.text : dflt("text") || "");
+    else if (comp.id === "divider") t = String(prm.text != null ? prm.text : dflt("text"));
+    else if (comp.id === "spacer") t = " ".repeat(Number(prm.width != null ? prm.width : dflt("width")) || 1);
+    else if (comp.id === "icon-static") t = String(prm.glyph != null ? prm.glyph : dflt("glyph"));
+    if (!t) return ops;
+    const sb = r.brackets || rend.brackets || null;
+    if (sb && sb[0]) ops.push(slLit(sb[0]));
+    if (valueSgr) ops.push({ op: "sgr", s: valueSgr });
+    ops.push(styledLit(t, caseOf));
+    if (valueSgr) ops.push({ op: "reset" });
+    if (sb && sb[1]) ops.push(slLit(sb[1]));
+    return ops;
+  }
+  if (comp.id === "config") ops.p = { key: String((r.params && r.params.key) || comp.params.key.dflt) };
+  if (wp) ops.p = wp;
+
   // A GROUP: its children are lowered inside its brackets and share its
   // background, so a run of chips reads as one object. It is the one place an
   // item op has an item op inside it, and the nesting stops there.
@@ -43117,11 +44345,39 @@ function slLowerItem(r, comp, T) {
     return ops;
   }
 
-  if (open) ops.push(slLit(open));
+  const isPill = r.render === "pill" && !!label;
+  if (open && !isPill) ops.push(slLit(open));
+
+  // v2.0.4 — a bar's own cell colours. `gc` (gradient, all-hex ramp) beats
+  // `fs`/`es`, which beat the ramp; the engine applies that order.
+  const barExtras = (bop) => {
+    const fs = r.fill_color ? slSgr(r.fill_color, null, null) : null;
+    const es = r.empty_color ? slSgr(r.empty_color, null, null) : null;
+    if (fs) bop.fs = fs;
+    if (es) bop.es = es;
+    if (bop.k === "gradient" && rampColors && rampColors.every((c) => /^#[0-9a-fA-F]{6}$/.test(c))) {
+      const rgb = rampColors.map((c) => [1, 3, 5].map((i) => parseInt(c.slice(i, i + 2), 16)));
+      const hex = (n) => Math.round(n).toString(16).padStart(2, "0");
+      bop.gc = [];
+      for (let i = 0; i < bop.w; i++) {
+        const pos = ((i + 1) / bop.w) * 100;
+        let k = 0;
+        while (k < rampStops.length - 2 && pos > rampStops[k + 1]) k++;
+        const span = rampStops[k + 1] - rampStops[k];
+        const t = Math.max(0, Math.min(1, span > 0 ? (pos - rampStops[k]) / span : 1));
+        const c = rgb[k].map((v, j) => v + (rgb[k + 1][j] - v) * t);
+        bop.gc.push(slSgr("#" + c.map(hex).join(""), null, null));
+      }
+    }
+    return bop;
+  };
 
   const valueOp = () => {
     if (rend.kind === "bar") {
-      return { op: "bar", b: comp.binding, k: rend.sub, g: gi, w: r.width || rend.dflt_w || 10, r: ri, thr: r.threshold == null ? null : r.threshold };
+      const bop = { op: "bar", b: comp.binding, k: rend.sub, g: gi, w: r.width || rend.dflt_w || 10, r: ri, thr: r.threshold == null ? null : r.threshold };
+      // A state component on a bar: the engine maps the state to a percent.
+      if (comp.states && !comp.bounded) bop.o = comp.states.filter((s) => s !== "unknown");
+      return barExtras(bop);
     }
     if (rend.kind === "series") {
       return { op: "series", b: comp.binding, s: comp.series, k: rend.sub, g: gi, w: r.width || rend.dflt_w || 8 };
@@ -43132,11 +44388,20 @@ function slLowerItem(r, comp, T) {
     }
     if (rend.kind === "state") {
       const map = stateMap();
-      return { op: "state", b: comp.state_binding || comp.binding, m: T.idxOf(T.statemaps, map) };
+      const st = { op: "state", b: comp.state_binding || comp.binding, m: T.idxOf(T.statemaps, map) };
+      if (wp) st.p = wp;
+      return st;
+    }
+    if (rend.kind === "sprite") {
+      const sp = SL_SPRITES[comp.sprite];
+      const k = SL_SPRITE_SPEED[(r.params || {}).speed] || 1;
+      return { op: "sprite", w: r.width || rend.dflt_w, mode: rend.sub, ms: Math.round(sp.ms * k), f: sp.f.slice(), a: sp.a.slice(), ahead: sp.ahead, behind: sp.behind, ...(/[^ -~]/.test(sp.ahead || "") && sp.ahead_a != null ? { ahead_a: sp.ahead_a } : {}), ...(/[^ -~]/.test(sp.behind || "") && sp.behind_a != null ? { behind_a: sp.behind_a } : {}) };
     }
     // text
     const op = { op: "val", b: comp.binding, f: fi };
     if (r.render === "word" && comp.state_binding) op.b = comp.state_binding;
+    if (comp.id === "clock") op.tf = (r.params && r.params.format) || comp.params.format.dflt;
+    if (ops.p) op.p = ops.p;
     // A ramp derives the colour FROM THE VALUE, so it applies to a number just
     // as much as to a bar — `context 38%` green and `context 94%` red is the
     // whole point of one.
@@ -43152,13 +44417,52 @@ function slLowerItem(r, comp, T) {
     // A state, a motif, a ramped bar and a ramped/state-coloured number all
     // carry their OWN colour. Wrapping them in the theme's value colour as well
     // emits two sequences for one glyph, and the outer one is the wrong answer.
+    const own = inner.op === "state" || inner.op === "motif" || (inner.op === "bar" && inner.r != null) ||
+      (inner.op === "val" && (inner.r != null || inner.m != null)) || (inner.op === "bar" && (inner.fs || inner.es || inner.gc));
+    if (own) return emphSgr ? [{ op: "sgr", s: emphSgr }, inner, { op: "reset" }] : [inner];
+    // v2.0.4 — a fill colour paints the whole spark.
+    if (inner.op === "series" && r.fill_color) {
+      const ss = slSgr(r.fill_color, r.emphasis, r.bg);
+      if (ss) return [{ op: "sgr", s: ss }, inner, { op: "reset" }];
+    }
     if (!valueSgr) return [inner];
-    if (inner.op === "state" || inner.op === "motif") return [inner];
-    if (inner.op === "bar" && inner.r != null) return [inner];
-    if (inner.op === "val" && (inner.r != null || inner.m != null)) return [inner];
     return [{ op: "sgr", s: valueSgr }, inner, { op: "reset" }];
   };
 
+  // v2.0.4 §7 — a NON-TEXT shape with decorations the ITEM authored:
+  //   [label before] [prefix] [value before] SHAPE [value after] [suffix] [label after]
+  // Nothing here runs for a field the item did not set, so an existing layout
+  // compiles to the same bytes.
+  const vpos = from.value_pos === "item" ? r.value_pos : null;
+  const dPre = from.prefix === "item" && r.prefix ? String(r.prefix) : "";
+  const dSuf = from.suffix === "item" && r.suffix ? String(r.suffix) : "";
+  const nonText = rend.kind === "bar" || rend.kind === "series" || rend.kind === "state" || rend.kind === "motif" || rend.kind === "sprite";
+  if (nonText && ((lpos && rawLabel && !capLabel) || dPre || dSuf || vpos === "before" || vpos === "after")) {
+    // The value beside a shape carries neither prefix nor suffix: they are
+    // drawn once, around the whole part.
+    const bareF = T.idxOf(T.formats, Object.assign({}, fmt, { prefix: "", suffix: "" }));
+    const val = () => wrapValue({ op: "val", b: comp.binding, f: bareF });
+    if (lpos === "before" && rawLabel) sideLabel(rawLabel, "", " ");
+    if (dPre) ops.push(slLit(dPre));
+    if (vpos === "before") {
+      for (const o of val()) ops.push(o);
+      ops.push(slLit(" "));
+    }
+    if (r.render === "bar") {
+      for (const o of wrapValue({ op: "val", b: comp.binding, f: bareF })) ops.push(o);
+      ops.push(slLit(" "));
+      ops.push(barExtras({ op: "bar", b: comp.binding, k: "blocks", g: gi, w: r.width || 10, r: ri, thr: null }));
+    } else for (const o of wrapValue(valueOp())) ops.push(o);
+    if (vpos === "after") {
+      ops.push(slLit(" "));
+      for (const o of val()) ops.push(o);
+    }
+    if (dSuf) ops.push(slLit(dSuf));
+    if (lpos === "after" && rawLabel) sideLabel(rawLabel, " ", "");
+    if (close && !isPill) ops.push(slLit(close));
+    return ops;
+  }
+
   switch (r.render) {
     case "bare":
     case "word":
@@ -43207,9 +44511,11 @@ function slLowerItem(r, comp, T) {
       // The two-tone chip: the label in reverse video, the value outside it.
       if (label) {
         const chip = slSgr(r.label_color, (r.emphasis || []).concat(["reverse"]), r.bg);
+        if (open) ops.push(slLit(open));
         if (chip) ops.push({ op: "sgr", s: chip });
         ops.push(slLit(applyCase(label)));
         if (chip) ops.push({ op: "reset" });
+        if (close) { ops.push(slLit(close)); }
       }
       for (const o of wrapValue(valueOp())) ops.push(o);
       break;
@@ -43224,7 +44530,7 @@ function slLowerItem(r, comp, T) {
       // The user's own worked example: number THEN bar.
       for (const o of wrapValue({ op: "val", b: comp.binding, f: fi })) ops.push(o);
       ops.push(slLit(" "));
-      ops.push({ op: "bar", b: comp.binding, k: "blocks", g: gi, w: r.width || 10, r: ri, thr: null });
+      ops.push(barExtras({ op: "bar", b: comp.binding, k: "blocks", g: gi, w: r.width || 10, r: ri, thr: null }));
       break;
     }
     case "link": {
@@ -43237,7 +44543,9 @@ function slLowerItem(r, comp, T) {
       for (const o of wrapValue(valueOp())) ops.push(o);
   }
 
-  if (close) ops.push(slLit(close));
+  // v2.0.4 — label_pos after on a text shape: the value, then the label.
+  if (lpos === "after" && rawLabel) sideLabel(rawLabel, " ", "");
+  if (close && !isPill) ops.push(slLit(close));
   return ops;
 }
 
@@ -43355,6 +44663,12 @@ function slMeasure(ops, T) {
         case "motif":
           w += 1;
           break;
+        case "sprite":
+          w += op.w || 16;
+          break;
+        case "flex":
+          w += op.min || 1;
+          break;
         case "item":
           w += (op.pad_l || 0) + (op.pad_r || 0);
           walk(op.children || []);
@@ -43424,6 +44738,25 @@ const STATUSLINE_PRESETS = {
       [],
     ],
   },
+  // v2.0.4 — the design powers, all on one board.
+  designer: {
+    summary: "Shows what a part can draw: labels beside a bar, a caption under it, a colour gradient, your own bar cells, and a clock at the right edge.",
+    build: () => [
+      [
+        slItem("text", { params: { text: "ORC" }, emphasis: ["bold"] }),
+        slItem("quota-5h", { render: "bar-only", width: 8, label: "5h", label_pos: "before", value_pos: "after" }),
+        slItem("context", { render: "gradient", width: 10, ramp_colors: ["#3fb950", "#d29922", "#f85149"], caption: "context", caption_case: "small" }),
+        slItem("fill"),
+        slItem("clock"),
+      ],
+      [
+        slItem("quota-week", { render: "meter", width: 8, fill_char: "▰", empty_char: "▱", label: "wk", label_pos: "before" }),
+        slItem("tier"),
+        slItem("branch"),
+      ],
+      [],
+    ],
+  },
   // ── the second board (v1.4.0) ──────────────────────────────────────────
   "agent-default": {
     board: "subagent",
@@ -43623,13 +44956,13 @@ const SL_FIXTURES = {
       prompt_cache: { warm: true, ttl: "5m", hit_ratio: 0.91, requests: 214, misses: 19, cache_write_tokens: 48000, recache_tokens_if_cold: 45000 },
       workspace: { project_dir: "/repo", repo: { host: "github.com", owner: "azure-id", name: "orc" } },
     },
-    ledger: { five_hour: { baseline: 55, last: 61, accumulated: 0, resets: 0 }, tok: { input: 12000, cache_write: 40000, cache_read: 350000, output: 10000 }, series: { quota5h: [55, 56, 58, 59, 60, 61], ucs: [0, 1, 2, 4, 5, 6], mtok: [10, 40, 120, 260, 380, 412] } },
-    scan: { spawns: 7, running: 2, lanes: ["quick"], phase: { lane: "quick", label: "Q3 DO", kind: "do" }, branch: "main", inflight: "clear", wiki: { tier: "fresh", distance: 3 }, extra_enabled: true, trace_age_min: 0, trace_state: "live" },
+    ledger: { five_hour: { baseline: 55, last: 61, accumulated: 0, resets: 0 }, tok: { input: 12000, cache_write: 40000, cache_read: 350000, output: 10000 }, series: { quota5h: [55, 56, 58, 59, 60, 61], ucs: [0, 1, 2, 4, 5, 6], mtok: [10, 40, 120, 260, 380, 412], agents: [0, 1, 3, 2, 2, 2], burn: [0.8, 1.1, 1.4, 1.2, 1.3, 1.5], cost: [0.05, 0.12, 0.2, 0.28, 0.35, 0.42], cachehit: [62, 74, 81, 86, 89, 91], cachewrite: [12000, 20000, 28000, 36000, 42000, 48000], lines: [40, 120, 180, 240, 290, 324], extraspend: [0, 0.02, 0.04, 0.07, 0.09, 0.11], speed: [38, 52, 47, 61, 55, 58], mtokkind: [8, 30, 90, 200, 300, 340], quotawk: [15, 15, 16, 17, 17, 18] } },
+    scan: { spawns: 7, running: 2, lanes: ["quick"], phase: { lane: "quick", label: "Q3 DO", kind: "do" }, branch: "main", inflight: "clear", wiki: { tier: "fresh", distance: 3 }, extra_enabled: true, trace_age_min: 0, trace_state: "live", weather: { temp_c: 18, temp_f: 64, state: "partly", desc: "Partly cloudy" } },
   },
   degraded: {
     label: "the wrong tier, a full window, and nothing running",
     payload: {
-      model: { id: "claude-sonnet-5", display_name: "Sonnet 5" },
+      model: { id: "claude-sonnet-5-5", display_name: "Sonnet 5" },
       effort: { level: "low" },
       context_window: { used_percentage: 94, remaining_percentage: 6 },
       rate_limits: { five_hour: { used_percentage: 93, resets_at: null }, seven_day: { used_percentage: 88, resets_at: null } },
@@ -43682,7 +45015,7 @@ function slDerived(payload) {
   return { verdict, reasons, version: currentVersion() };
 }
 
-function slPreview(compiled, fixtureName, cols, overrides) {
+function slPreview(compiled, fixtureName, cols, overrides, at) {
   const fx = SL_FIXTURES[fixtureName] || SL_FIXTURES.healthy;
   const payload = JSON.parse(JSON.stringify(fx.payload));
   for (const [k, v] of Object.entries(overrides || {})) slDeepSet(payload, k, v);
@@ -43693,7 +45026,8 @@ function slPreview(compiled, fixtureName, cols, overrides) {
     scan: fx.scan || {},
     derived: slDerived(payload),
     task: SL_TASK_FIXTURES[fixtureName] || SL_TASK_FIXTURES.healthy,
-    now,
+    // `at` moves ONLY the clock, so an animated preview draws the same session.
+    now: at || now,
     cols: cols || 0,
     env: Object.assign({}, process.env, { COLUMNS: String(cols || 120) }),
   };
@@ -43755,6 +45089,8 @@ function statusline() {
       return slCloneCmd(claudeDir, p);
     case "compile":
       return slCompileCmd(claudeDir, true);
+    case "refresh":
+      return slRefreshCmd(claudeDir, p);
     default:
       console.error(`usage: orc statusline components|show|explain|validate|preview [--json]
        orc statusline set <line> <pos> <type> [--render R] [--label L] [--color C] [--width N] …
@@ -43766,6 +45102,8 @@ function statusline() {
        orc statusline expand <line>:<pos>                     a composite, or a group, back into its parts
        orc statusline clone <line>:<pos>
        orc statusline presets [--json] | apply <name> | reset | compile
+       orc statusline refresh <off|1|2|3|5|10|N>               the refresh timer in settings.json (1 s floor)
+       orc statusline preview --frames N [--frame-ms M]       an animated preview
 
 COMPOSE THIS IN \`orc ui\` ▸ CLI Hook Interface. These flags exist so the panel
 has something to shell — typing a three-line layout is worse than the board.`);
@@ -43822,7 +45160,9 @@ function slComponentsCmd() {
     renderers: Object.fromEntries(Object.entries(STATUSLINE_RENDERERS).map(([k, v]) => [k, { kind: v.kind, form: v.form || null, needs: v.needs, width: v.width || null, decoration: !!v.decoration, uses: slRendererUses(k) }])),
     // Which shapes DO draw a label, so a refusal can name them instead of
     // saying "not here".
-    label_renderers: [...SL_LABEL_RENDERERS],
+      label_renderers: [...SL_LABEL_RENDERERS],
+      // The value that clears a colour back to the shared one.
+      inherit_token: "inherit",
       glyph_sets: Object.keys(STATUSLINE_GLYPHSETS),
       ramps: Object.fromEntries(Object.entries(STATUSLINE_RAMPS).map(([k, v]) => [k, { stops: v.stops, colors: v.colors, why: v.why }])),
       themes: STATUSLINE_THEMES,
@@ -43830,6 +45170,18 @@ function slComponentsCmd() {
       formats: SL_FORMATS,
       compact: SL_COMPACT,
       cases: SL_CASES,
+      // v2.0.4 — what each case looks like, and the other closed sets.
+      case_samples: Object.fromEntries(SL_CASES.map((c) => [c, slCaseText("Weekly 61", c)])),
+      label_positions: SL_LABEL_POS,
+      value_positions: SL_VALUE_POS,
+      caption_positions: SL_CAPTION_POS,
+      caption_aligns: SL_CAPTION_ALIGN,
+      aligns: SL_ALIGNS,
+      signs: SL_SIGNS,
+      unknowns: SL_UNKNOWNS,
+      line_aligns: SL_LINE_ALIGNS,
+      caption_tokens: ["{value}", "{label}"],
+      limits: SL_LIMITS,
       truncate: SL_TRUNCATE,
       emphasis: Object.keys(SL_EMPHASIS),
       refused_emphasis: SL_REFUSED_EMPHASIS,
@@ -43877,6 +45229,7 @@ const SL_GROUP_NAMES = {
   H: "Project and VCS",
   I: "Static and structural",
   J: "Composite shortcuts",
+  M: "Pets and motion",
 };
 
 // A dropdown of the word `braille-bar` tells nobody anything, so every renderer
@@ -43911,11 +45264,17 @@ const SL_ITEM_FIELDS = [
   "glyphs", "format", "case", "truncate", "compact", "prefix", "suffix",
   "emphasis", "hide_when", "width", "precision", "min_width", "min_cols",
   "max_cols", "priority", "max_len", "align", "draw_empty", "unknown",
+  // v2.0.4 — the design fields.
+  "label_pos", "value_pos", "caption", "caption_pos", "caption_align",
+  "caption_color", "caption_case", "fill_color", "empty_color", "ramp_colors",
+  "ramp_stops", "fill_char", "empty_char", "brackets", "threshold", "padding",
+  "sign", "color_by_state", "glyph_by_state", "params",
 ];
 // The ones whose absence is an empty LIST rather than a null — a control that
 // iterates a null throws, and a null here would read as "unknown" when it means
 // "nothing selected".
-const SL_ITEM_LIST_FIELDS = new Set(["emphasis", "hide_when"]);
+const SL_ITEM_LIST_FIELDS = new Set(["emphasis", "hide_when", "ramp_colors", "ramp_stops", "brackets", "padding"]);
+const SL_ITEM_MAP_FIELDS = new Set(["color_by_state", "glyph_by_state", "params"]);
 
 function slAuthoredFields(it) {
   const out = {};
@@ -43937,11 +45296,31 @@ function slShowCmd(claudeDir) {
   try {
     preview = slPreview(slCompile(eff).compiled, "healthy", 120, {}).text;
   } catch (_) {}
+  const hook = slHookInfo(claudeDir, slBoard());
+  const lockNow = slReadJson(slPaths(claudeDir).lock);
+  let animated = false;
+  try {
+    animated = slHasMotion(slCompile(eff).compiled);
+  } catch (_) {}
+  // ONE item alone, in its own saved design: what the chip looks like.
+  const sampleOf = (it, l) => {
+    try {
+      const copy = JSON.parse(JSON.stringify(eff));
+      copy.lines.forEach((x, i) => (x.items = []));
+      copy.lines[0] = Object.assign({}, l, { items: [JSON.parse(JSON.stringify(it))], prefix: "" });
+      return slPreview(slCompile(copy).compiled, "healthy", 120, {}).text;
+    } catch (_) {
+      return null;
+    }
+  };
   const lines = eff.lines.map((l, i) => ({
     line: i + 1,
     separator: l.separator,
     theme: l.theme,
     max_width: l.max_width || 0,
+    align: l.align || "left",
+    sep_color: l.sep_color || null,
+    prefix: l.prefix || "",
     count: (l.items || []).length,
     counted: (l.items || []).filter((it) => !slIsStructural(it.type)).length,
     full: (l.items || []).filter((it) => !slIsStructural(it.type)).length >= SL_MAX_PER_LINE,
@@ -43963,8 +45342,9 @@ function slShowCmd(claudeDir) {
         // cannot tell "you chose the theme's colour" from "you chose nothing"
         // cannot offer to clear it.
         authored: slAuthoredFields(it),
+        sample: sampleOf(it, l),
       };
-      for (const k of SL_ITEM_FIELDS) row[k] = r && r[k] !== undefined && r[k] !== null ? r[k] : SL_ITEM_LIST_FIELDS.has(k) ? [] : null;
+      for (const k of SL_ITEM_FIELDS) row[k] = r && r[k] !== undefined && r[k] !== null ? r[k] : SL_ITEM_LIST_FIELDS.has(k) ? [] : SL_ITEM_MAP_FIELDS.has(k) ? {} : null;
       if (it.children) row.children = it.children.map((k) => ({ id: k.id, type: k.type, authored: slAuthoredFields(k) }));
       return row;
     }),
@@ -43983,11 +45363,16 @@ function slShowCmd(claudeDir) {
       errors: v.errors,
       warnings: v.warnings,
       preview,
+      hook,
+      refresh_interval: slRefreshInterval(hook, slBoard()),
+      needs_refresh: (lockNow && lockNow.needs_refresh_interval) || null,
+      animated,
       dense_prefix: "A line may hold a component only if every line above it holds at least one.",
     }, v.ok ? 0 : 1);
   console.log("");
   console.log(ui.header("Status line") + "  " + (on ? ui.mark.ok("custom layout ON") : ui.color.gray("custom layout off — the shipped two lines are rendering")));
   if (!layout) console.log(ui.color.gray("  nothing saved yet — this is the shipped default"));
+  if (!hook.match && hook.fix) console.log("  " + ui.mark.warn(slHookSentence(hook)));
   console.log("");
   for (const l of lines) {
     const cells = l.items.map((i) => ui.color.cyan(i.type) + ui.color.gray("/" + i.render)).join(ui.color.gray("  ·  "));
@@ -44073,8 +45458,18 @@ function slPreviewCmd(claudeDir) {
       if (k) overrides[k] = val;
     }
   }
+  // v2.0.4 — an animated preview: the same program at successive instants.
+  const nFrames = flag("--frames") === undefined ? 1 : Number(flag("--frames"));
+  const frameMs = flag("--frame-ms") === undefined ? 1000 : Number(flag("--frame-ms"));
+  if (!Number.isInteger(nFrames) || nFrames < 1 || nFrames > 24 || !Number.isInteger(frameMs) || frameMs < 1) {
+    if (wantsJson()) return emitJson({ ok: false, reason: "bad-frames", hint: "--frames takes 1 to 24, --frame-ms a whole number of milliseconds" }, 2);
+    console.error("--frames takes 1 to 24, and --frame-ms takes a whole number of milliseconds");
+    process.exit(2);
+  }
   const { compiled } = slCompile(layout);
   const base = slPreview(compiled, state, cols, overrides);
+  const frames = [base.text];
+  for (let i = 1; i < nFrames; i++) frames.push(slPreview(compiled, state, cols, overrides, 1767225600000 + i * frameMs).text);
   // R4: every design must survive three strippings, and the panel shows all
   // three as small rows under the main preview — not as an afterthought tab.
   const strip = (env) => {
@@ -44105,6 +45500,8 @@ function slPreviewCmd(claudeDir) {
     fixture: (SL_FIXTURES[state] || SL_FIXTURES.healthy).label,
     fixtures: Object.fromEntries(Object.entries(SL_FIXTURES).map(([k, f]) => [k, f.label])),
     text: base.text,
+    frames,
+    frame_ms: frameMs,
     strippings: {
       no_color: strip({ NO_COLOR: "1" }),
       ascii: strip({ ORC_STATUSLINE_ASCII: "1" }),
@@ -44153,20 +45550,95 @@ function slSetCmd(claudeDir, p) {
     process.exit(2);
   }
   const item = existing || { id: slNewId(layout), type };
+  // A SWAP drops what the new component cannot carry, so the swap never fails
+  // on the old shape.
+  if (type && existing && existing.type !== type) {
+    const nc = SL_BY_ID.get(type);
+    if (nc) {
+      if (item.render && !nc.renderers.includes(item.render)) delete item.render;
+      delete item.label;
+      delete item.params;
+      if (!nc.bounded) delete item.ramp;
+      const rn = item.render || (nc.defaults && nc.defaults.render) || nc.renderers[0];
+      if (!(STATUSLINE_RENDERERS[rn] && STATUSLINE_RENDERERS[rn].width)) delete item.width;
+    }
+  }
   if (type) item.type = type;
+  const COLOR_KEYS = new Set(["color", "label_color", "value_color", "bg"]);
   for (const [k, f] of [["render", "--render"], ["label", "--label"], ["color", "--color"], ["label_color", "--label-color"], ["value_color", "--value-color"], ["bg", "--bg"], ["ramp", "--ramp"], ["glyphs", "--glyphs"], ["format", "--format"], ["case", "--case"], ["truncate", "--truncate"], ["compact", "--compact"], ["prefix", "--prefix"], ["suffix", "--suffix"]]) {
-    const v = flag(f);
-    if (typeof v === "string") item[k] = v;
+    const v = slFlag(f);
+    if (typeof v !== "string") continue;
+    // "" clears the key (null = inherit); `inherit` clears a colour too.
+    if (v === "" || (COLOR_KEYS.has(k) && v === "inherit")) delete item[k];
+    else item[k] = v;
   }
   for (const [k, f] of [["width", "--width"], ["precision", "--precision"], ["min_width", "--min-width"], ["min_cols", "--min-cols"], ["max_cols", "--max-cols"], ["priority", "--priority"]]) {
-    const v = flag(f);
-    if (typeof v === "string" && v !== "") item[k] = Number(v);
-  }
-  const emph = flag("--emphasis");
-  if (typeof emph === "string") item.emphasis = emph.split(",").map((s) => s.trim()).filter(Boolean);
-  const hide = flag("--hide-when");
-  if (typeof hide === "string") item.hide_when = hide === "never" ? [] : hide.split(",").map((s) => s.trim()).filter(Boolean);
+    const v = slFlag(f);
+    if (v === "") delete item[k];
+    else if (typeof v === "string") item[k] = Number(v);
+  }
+  const emph = slFlag("--emphasis");
+  if (emph === "") delete item.emphasis;
+  else if (typeof emph === "string") item.emphasis = emph.split(",").map((s) => s.trim()).filter(Boolean);
+  const hide = slFlag("--hide-when");
+  if (hide === "") delete item.hide_when;
+  else if (typeof hide === "string") item.hide_when = hide === "never" ? [] : hide.split(",").map((s) => s.trim()).filter(Boolean);
   if (flag("--draw-empty") === true) item.draw_empty = true;
+  // v2.0.4 — the design fields. Same rules: "" clears, `inherit` clears a
+  // colour, and the validator judges every value.
+  const DESIGN_COLORS = new Set(["caption_color", "fill_color", "empty_color"]);
+  for (const [k, f] of [["label_pos", "--label-pos"], ["value_pos", "--value-pos"], ["caption", "--caption"], ["caption_pos", "--caption-pos"], ["caption_align", "--caption-align"], ["caption_color", "--caption-color"], ["caption_case", "--caption-case"], ["fill_color", "--fill-color"], ["empty_color", "--empty-color"], ["fill_char", "--fill-char"], ["empty_char", "--empty-char"], ["align", "--align"], ["sign", "--sign"], ["unknown", "--unknown"]]) {
+    const v = slFlag(f);
+    if (typeof v !== "string") continue;
+    if (v === "" || (DESIGN_COLORS.has(k) && v === "inherit")) delete item[k];
+    else item[k] = v;
+  }
+  for (const [k, f] of [["threshold", "--threshold"], ["max_len", "--max-len"]]) {
+    const v = slFlag(f);
+    if (v === "") delete item[k];
+    else if (typeof v === "string") item[k] = Number(v);
+  }
+  for (const [i, f] of [[0, "--pad-left"], [1, "--pad-right"]]) {
+    const v = slFlag(f);
+    if (typeof v !== "string") continue;
+    const pad = Array.isArray(item.padding) ? item.padding.slice(0, 2) : [0, 0];
+    pad[i] = v === "" ? 0 : Number(v);
+    if (!pad[0] && !pad[1]) delete item.padding;
+    else item.padding = [pad[0] || 0, pad[1] || 0];
+  }
+  const csv = (v) => v.split(",").map((s) => s.trim()).filter(Boolean);
+  for (const [k, f, conv] of [["ramp_colors", "--ramp-colors", csv], ["ramp_stops", "--ramp-stops", (v) => csv(v).map(Number)], ["brackets", "--brackets", (v) => v.split(",")]]) {
+    const v = slFlag(f);
+    if (v === "") delete item[k];
+    else if (typeof v === "string") item[k] = conv(v);
+  }
+  for (const [k, f] of [["color_by_state", "--state-color"], ["glyph_by_state", "--state-glyph"]]) {
+    const v = slFlag(f);
+    if (v === "") delete item[k];
+    else if (typeof v === "string") {
+      const map = {};
+      for (const pair of csv(v)) {
+        const eq = pair.indexOf("=");
+        if (eq > 0) map[pair.slice(0, eq)] = pair.slice(eq + 1);
+        else map[pair] = "";
+      }
+      item[k] = map;
+    }
+  }
+  // `--param k=v` is REPEATABLE; `--param k=` deletes that one key.
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] !== "--param" || typeof args[i + 1] !== "string") continue;
+    const pv = args[i + 1];
+    const eq = pv.indexOf("=");
+    const key = eq === -1 ? pv : pv.slice(0, eq);
+    if (!key) continue;
+    const val = eq === -1 ? "" : pv.slice(eq + 1);
+    const prm = Object.assign({}, item.params || {});
+    if (val === "") delete prm[key];
+    else prm[key] = val;
+    if (Object.keys(prm).length) item.params = prm;
+    else delete item.params;
+  }
   if (!existing) {
     line.items = line.items || [];
     line.items.splice(Math.min(pi - 1, line.items.length), 0, item);
@@ -44225,13 +45697,20 @@ function slLineCmd(claudeDir, p) {
     process.exit(2);
   }
   const line = layout.lines[n - 1];
-  const sep = flag("--separator");
+  const sep = slFlag("--separator");
   if (typeof sep === "string") line.separator = sep;
-  const pre = flag("--prefix");
+  const pre = slFlag("--prefix");
   if (typeof pre === "string") line.prefix = pre;
-  const mw = flag("--max-width");
+  const mw = slFlag("--max-width");
   if (typeof mw === "string") line.max_width = Number(mw) || 0;
-  const th = flag("--theme");
+  // v2.0.4 — the line's alignment and its separator colour. "" clears.
+  const al = slFlag("--align");
+  if (al === "") delete line.align;
+  else if (typeof al === "string") line.align = al;
+  const sc = slFlag("--sep-color");
+  if (sc === "" || sc === "inherit") delete line.sep_color;
+  else if (typeof sc === "string") line.sep_color = sc;
+  const th = slFlag("--theme");
   if (typeof th === "string") {
     if (!STATUSLINE_THEMES[th]) {
       if (wantsJson()) return emitJson({ ok: false, reason: "unknown-theme", theme: th, known: Object.keys(STATUSLINE_THEMES) }, 2);
@@ -44251,7 +45730,7 @@ function slLineCmd(claudeDir, p) {
 // per scope, and the panel calls the one that matches the control.
 function slDocCmd(claudeDir, p) {
   const layout = slLoadOrDefault(claudeDir);
-  const th = flag("--theme");
+  const th = slFlag("--theme");
   if (typeof th === "string") {
     if (!STATUSLINE_THEMES[th]) {
       if (wantsJson()) return emitJson({ ok: false, reason: "unknown-theme", theme: th, known: Object.keys(STATUSLINE_THEMES) }, 2);
@@ -44265,7 +45744,7 @@ function slDocCmd(claudeDir, p) {
     // shadowed is the one failure this whole command exists to fix.
     for (const l of layout.lines) l.theme = null;
   }
-  const gl = flag("--glyphs");
+  const gl = slFlag("--glyphs");
   if (typeof gl === "string") {
     if (!STATUSLINE_GLYPHSETS[gl]) {
       if (wantsJson()) return emitJson({ ok: false, reason: "unknown-glyphs", glyphs: gl, known: Object.keys(STATUSLINE_GLYPHSETS) }, 2);
@@ -44274,7 +45753,7 @@ function slDocCmd(claudeDir, p) {
     }
     layout.glyphs = gl;
   }
-  const an = flag("--ansi");
+  const an = slFlag("--ansi");
   if (typeof an === "string") {
     if (!["auto", "off"].includes(an)) {
       if (wantsJson()) return emitJson({ ok: false, reason: "unknown-ansi", ansi: an, known: ["auto", "off"] }, 2);
@@ -44283,7 +45762,7 @@ function slDocCmd(claudeDir, p) {
     }
     layout.ansi = an;
   }
-  const align = flag("--align-columns");
+  const align = slFlag("--align-columns");
   if (typeof align === "string") layout.align_columns = align === "on";
   return slSaveAndCompile(claudeDir, layout, { action: "doc", theme: layout.theme, glyphs: layout.glyphs, ansi: layout.ansi, align_columns: !!layout.align_columns });
 }
@@ -44366,14 +45845,18 @@ function slSaveAndCompile(claudeDir, layout, info, skipWrite) {
   if (!skipWrite) slWriteLayout(claudeDir, layout);
   fs.writeFileSync(paths.compiled, JSON.stringify(compiled, null, 2) + "\n");
   fs.writeFileSync(paths.lock, JSON.stringify(lock, null, 2) + "\n");
+  // A fresh compile supersedes the hook's last recorded fallback.
+  if (paths.board.id === "status") slClearFallback(claudeDir);
+  const hook = slHookInfo(claudeDir, paths.board);
   let preview = null;
   try {
     preview = slPreview(compiled, "healthy", 120, {}).text;
   } catch (_) {}
-  const out = Object.assign({ ok: true, wrote: true, warnings: v.warnings, needs_refresh_interval: lock.needs_refresh_interval, static_width: compiled.lines.map((l) => l.static_width), preview }, info);
+  const out = Object.assign({ ok: true, wrote: true, warnings: v.warnings, needs_refresh_interval: lock.needs_refresh_interval, static_width: compiled.lines.map((l) => l.static_width), preview, hook }, info);
   if (wantsJson()) return emitJson(out, 0);
   console.log("");
   console.log("  " + ui.mark.ok(`${info.action} — compiled`));
+  if (!hook.match && hook.fix) console.log("  " + ui.mark.warn(slHookSentence(hook)));
   if (preview) for (const row of preview.split("\n")) console.log("    " + row);
   for (const w of v.warnings) console.log("  " + ui.mark.warn(w));
   if (lock.needs_refresh_interval)
@@ -44389,6 +45872,141 @@ function slSaveAndCompile(claudeDir, layout, info, skipWrite) {
   console.log("");
 }
 
+function slClearFallback(claudeDir) {
+  try {
+    fs.unlinkSync(path.join(claudeDir, "orc", "statusline-state.json"));
+  } catch (_) {}
+}
+
+function slReadJson(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8").replace(/^\uFEFF/, ""));
+  } catch (_) {
+    return null;
+  }
+}
+
+// WHICH HOOK WILL DRAW THIS LAYOUT, and does it speak this CLI's catalogue?
+// The panel said "your lines are showing" while the hook refused the lock.
+function slHookInfo(claudeDir, board) {
+  const b = board || SL_BOARDS.status;
+  const needle = b.id === "subagent" ? "orc-subagent-line" : "orc-statusline";
+  let hookPath = null;
+  let settings = null;
+  for (const sp of [path.join(claudeDir, "settings.json"), path.join(os.homedir(), ".claude", "settings.json")]) {
+    const st = slReadJson(sp);
+    const cmd = st && st[b.setting] && typeof st[b.setting].command === "string" ? st[b.setting].command : null;
+    if (!cmd || !cmd.includes(needle)) continue;
+    const quoted = cmd.match(/"([^"]+)"/g);
+    const q = quoted && quoted.map((x) => x.slice(1, -1)).find((x) => x.includes(needle));
+    hookPath = path.resolve(q || cmd.trim().split(/\s+/).pop());
+    settings = sp;
+    break;
+  }
+  const inst = hookPath ? slReadJson(path.join(path.dirname(hookPath), "orc-version.json")) : null;
+  const hash = slCatalogHash();
+  const cli = currentVersion();
+  const version = (inst && inst.version) || null;
+  const catalog_hash = (inst && inst.catalog_hash) || null;
+  const hookOk = !!hookPath && (catalog_hash ? catalog_hash === hash : version === cli);
+  const lock = slReadJson(slPaths(claudeDir, b).lock);
+  const lockOk = !lock || lock.catalog_hash === hash;
+  const fallback = b.id === "status" ? slReadJson(path.join(claudeDir, "orc", "statusline-state.json")) : null;
+  const match = hookOk && lockOk;
+  let fix = null;
+  if (hookPath && !hookOk) {
+    const home = path.join(os.homedir(), ".claude").toLowerCase() + path.sep;
+    fix = hookPath.toLowerCase().startsWith(home) ? "orc update --global" : "orc update";
+  } else if (!hookPath) fix = null;
+  else if (!lockOk || fallback) fix = "orc statusline compile";
+  return { path: hookPath, version, catalog_hash, cli_version: cli, match, fallback, fix, settings };
+}
+
+// The `refreshInterval` in force for this board, or null.
+function slRefreshInterval(hook, board) {
+  const st = hook && hook.settings ? slReadJson(hook.settings) : null;
+  const v = st && st[board.setting] ? st[board.setting].refreshInterval : null;
+  return typeof v === "number" ? v : null;
+}
+
+// v2.0.4 — `orc statusline refresh <seconds|off>`: set or remove the timer in
+// the settings file that holds ORC's hook. The rest of the file is kept.
+// v2.1.0 — ONE core (`slRefreshApply`) for the command, `orc config set
+// statusline_refresh` and the panel; a sub-second value is refused BY NAME
+// (measured: 0.25 s never starts Claude Code's timer).
+const SL_REFRESH_FLOOR_S = 1;
+function slRefreshFloorText(arg) {
+  return `✗ refresh ${arg} s is below the Claude Code floor.\n  Claude Code runs the status line at most once a second (refreshInterval minimum: 1).\n  A lower value does not start the timer. Nearest allowed value: 1.`;
+}
+function slRefreshApply(claudeDir, board, secs) {
+  const hook = slHookInfo(claudeDir, board);
+  if (!hook.settings) return { ok: false, reason: "not-wired", settings: null, hint: `ORC's ${board.setting} hook is not in a settings.json. Run: orc update` };
+  let st;
+  try {
+    st = JSON.parse(fs.readFileSync(hook.settings, "utf8").replace(/^\uFEFF/, ""));
+  } catch (_) {
+    return { ok: false, reason: "settings-unparsed", settings: hook.settings, hint: `${hook.settings} is not valid JSON. Correct the file, then try again.` };
+  }
+  if (!st || typeof st[board.setting] !== "object" || st[board.setting] === null)
+    return { ok: false, reason: "not-wired", settings: hook.settings, hint: `ORC's ${board.setting} hook is not in ${hook.settings}. Run: orc update` };
+  if (secs == null) delete st[board.setting].refreshInterval;
+  else st[board.setting].refreshInterval = secs;
+  fs.writeFileSync(hook.settings, JSON.stringify(st, null, 2) + "\n");
+  return { ok: true, refresh_interval: secs, settings: hook.settings };
+}
+function slRefreshCmd(claudeDir, p) {
+  const board = slBoard();
+  const arg = String(p[2] == null ? "" : p[2]);
+  const secs = arg === "off" ? null : Number(arg);
+  if (arg !== "off" && Number.isFinite(secs) && secs > 0 && secs < SL_REFRESH_FLOOR_S) {
+    if (wantsJson()) return emitJson({ ok: false, reason: "below-floor", floor_s: SL_REFRESH_FLOOR_S, nearest: 1, hint: slRefreshFloorText(arg) }, 2);
+    console.error(slRefreshFloorText(arg));
+    process.exit(2);
+  }
+  if (arg !== "off" && (!Number.isInteger(secs) || secs < 1 || secs > 60)) {
+    if (wantsJson()) return emitJson({ ok: false, reason: "bad-arg", hint: "use a whole number of seconds from 1 to 60, or off" }, 2);
+    console.error("usage: orc statusline refresh <off|1|2|3|5|10|N 1-60> [--board status|subagent]");
+    process.exit(2);
+  }
+  const r = slRefreshApply(claudeDir, board, secs);
+  if (!r.ok) {
+    if (wantsJson()) return emitJson(r, 1);
+    console.error(r.hint);
+    process.exit(1);
+  }
+  if (wantsJson()) return emitJson(r, 0);
+  console.log("  " + ui.mark.ok(secs == null ? `the refresh timer is off (${r.settings})` : `the status line refreshes every ${secs} s (${r.settings})`));
+}
+
+function slHookSentence(h) {
+  if (h.fix === "orc statusline compile")
+    return `Your terminal does not show this layout yet. The compiled layout is old. Run: ${h.fix}`;
+  return `Your terminal does not show this layout yet. The status line hook is ORC ${h.version || "unknown"} and this CLI is ORC ${h.cli_version}. Run: ${h.fix}`;
+}
+
+// After `orc init|update`: recompile each EXISTING layout, so the lock matches
+// the hooks that were just installed. Never creates a layout.
+function slRecompileInstalled(claudeDir) {
+  for (const b of [SL_BOARDS.status, SL_BOARDS.subagent]) {
+    try {
+      const paths = slPaths(claudeDir, b);
+      if (!fs.existsSync(paths.layout)) continue;
+      const layout = slReadLayout(claudeDir, b);
+      const v = layout ? slValidate(layout) : { ok: false };
+      if (!v.ok) {
+        console.log(`  skip  orc/${b.files[0]} — the layout does not validate; run \`orc statusline validate\``);
+        continue;
+      }
+      const { compiled, lock } = slCompile(layout);
+      lock.warnings = v.warnings;
+      fs.writeFileSync(paths.compiled, JSON.stringify(compiled, null, 2) + "\n");
+      fs.writeFileSync(paths.lock, JSON.stringify(lock, null, 2) + "\n");
+      console.log(`  upd   orc/${b.files[1]} (recompiled for v${currentVersion()})`);
+      if (b.id === "status") slClearFallback(claudeDir);
+    } catch (_) {}
+  }
+}
+
 
 // ── orc rules (v1.7.0) — the anti-slop rule surface ─────────────────────────
 //
@@ -44454,6 +46072,22 @@ const RULES_PRECEDENCE = [
   { rank: 3, layer: "ORC rules", scope: "everything", where: "<claude>/skills/_shared/rules/", beats: "nothing — it is the floor, and yours replaces it" },
 ];
 
+// v2.0.0 DE-8 — the LEARNED tier sits between your rules and the ORC rules.
+// It is named ONLY while `habits` is on: off = the ladder of the release before.
+function rulesPrecedence(claudeDir) {
+  let on = false;
+  try {
+    on = require("./habit.js").habitsMode(readOverride(claudeDir).map) !== "off";
+  } catch (_) {}
+  if (!on) return RULES_PRECEDENCE;
+  return [
+    RULES_PRECEDENCE[0],
+    RULES_PRECEDENCE[1],
+    { rank: 3, layer: "learned", scope: "commit, branch and test-file naming", where: "<claude>/orc/habits-state.json (`orc habit repo`)", beats: "the ORC rules — and your rules beat it" },
+    Object.assign({}, RULES_PRECEDENCE[2], { rank: 4 }),
+  ];
+}
+
 // Which packs ride in which lane. `ui` is absent from every row ON PURPOSE: it
 // is added PER TASK by the orchestrator when a task's declared files are
 // front-end. A UI rule in a backend slice is tokens paid on every spawn for a
@@ -44488,6 +46122,8 @@ const RULE_LANE_PACKS = {
   "orc-test": ["writing", "delivery"],
   "orc-route": ["writing", "delivery"],
   "orc-explain": ["writing", "delivery"],
+  // v2.1.0 W6 — with no run open, /orc-fix may write code (DE-12 c).
+  "orc-fix": ["writing", "code", "delivery"],
   "context-combiner": ["writing", "delivery"],
 };
 
@@ -44722,6 +46358,10 @@ function rulesLine(packs, blocks, overrides) {
 // which are what a rule's body is mostly made of. Nothing is hidden: the pack
 // file is named beside the rules, exactly as the light tiers already are.
 const RULES_COMPACT_LANES = new Set(["orc-quick"]);
+// v2.0.0 DE-17 — the SAME compact card for orc-mini / orc-fast, behind
+// `rules_card_compact` (default off). It flips only when eval E4 passes
+// (eval/results/2.0.0/E4.md). Off = the full card, byte for byte.
+const RULES_COMPACT_OPT_IN = new Set(["orc-mini", "orc-fast"]);
 
 // One line out of a rule body: the first paragraph, whitespace collapsed, cut
 // at a word boundary. A rule whose instruction does not survive that is a rule
@@ -44742,7 +46382,16 @@ function rulesSlice(claudeDir, lane, extraPacks) {
   const overridden = new Set(overrides.filter((o) => o.known).map((o) => o.id));
   const want = new Set([...(RULE_LANE_PACKS[lane] || []), ...(extraPacks || [])]);
   const chosen = packs.packs.filter((p) => want.has(p.id));
-  const compact = RULES_COMPACT_LANES.has(lane);
+  let cfgMap = {};
+  try {
+    cfgMap = readOverride(claudeDir).map || {};
+  } catch (_) {}
+  const compact =
+    RULES_COMPACT_LANES.has(lane) || (RULES_COMPACT_OPT_IN.has(lane) && /^(on|true)$/.test(String(cfgMap.rules_card_compact === undefined || cfgMap.rules_card_compact === null ? "on" : cfgMap.rules_card_compact)));
+  // DE-8 — the LEARNED tier. `null` under `habits: off`: then the slice is
+  // byte-identical to the release before, and the field is not even present.
+  const learned = require("./habit.js").learnedRules(claudeDir, repoRootOf(claudeDir), cfgMap);
+  const inForce = learned ? learned.filter((r) => r.state === "applied") : [];
 
   const L = [];
   if (!led.empty) {
@@ -44752,6 +46401,13 @@ function rulesSlice(claudeDir, lane, extraPacks) {
       if (body) L.push(pr, body, "");
     }
   }
+  if (inForce.length) {
+    L.push(
+      "LEARNED PREFERENCES — computed from this repo's own history, and accepted by you. Your rules above win over these. These win over the ORC rules below.",
+      ...inForce.map((r) => `${r.id} · ${r.rule}`),
+      ""
+    );
+  }
   if (chosen.length) {
     L.push(
       `ORC RULES — the anti-slop baseline. Shipped with ORC, read-only. ${packs.count} rules, ${plural(chosen.length, "pack")} in this slice.`,
@@ -44795,6 +46451,9 @@ function rulesSlice(claudeDir, lane, extraPacks) {
     // `compact` is REPORTED, never asked for. A reader that cannot tell a short
     // card from a stripped one cannot trust either.
     compact,
+    // Present ONLY when habits is on (DE-16: off = zero bytes). Stale rows are
+    // listed with their reason and are NOT in `text`.
+    ...(learned ? { learned } : {}),
     text: L.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\s+$/, ""),
     overrides,
     line: rulesLine(packs, led.blocks, overrides),
@@ -45071,7 +46730,7 @@ function rulesCmd() {
         },
         priorities: RULE_PRIORITIES,
         tiers: RULE_TIERS,
-        precedence: RULES_PRECEDENCE,
+        precedence: rulesPrecedence(claudeDir),
         overrides,
         overrides_note:
           "counted from ORC rule ids you NAMED in your own rules. A conflict you did not name is found by the agent at dispatch and returned as rules_conflicts[] — the CLI cannot parse intent, so it does not pretend to.",
@@ -45084,7 +46743,7 @@ function rulesCmd() {
 
   console.log(`\norc rules — ${line}\n`);
   console.log(ui.color.bold("  Precedence") + ui.color.gray("   the order never changes"));
-  for (const r of RULES_PRECEDENCE)
+  for (const r of rulesPrecedence(claudeDir))
     console.log(
       `   ${r.rank}. ${ui.color.cyan(r.layer.padEnd(12))} ${ui.color.gray(r.scope)}\n` +
         `      ${ui.color.gray(r.where)}\n` +
@@ -45247,7 +46906,7 @@ function lintScanFile(abs, rel, opts) {
   } catch (_) {
     return out;
   }
-  if (text.includes("")) return out; // binary
+  if (text.includes("\u0000")) return out; // binary
   const lines = text.replace(/\r\n/g, "\n").split("\n");
 
   // THE CARVE-OUT, and it is not a convenience. A rule that bans a word has to
@@ -45587,9 +47246,31 @@ function jsonCrash(err) {
     case "gotcha":
       gotcha();
       break;
+    // 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 }));
+      break;
     case "graph":
       graphCmd();
       break;
+    // v2.0.0 W2 — the habit engine. Every subcommand is a READ except accept,
+    // decline, forget, reset and purge, which are habits-state.json's only writers.
+    case "habit":
+      require("./habit.js").habitCmd(habitDeps());
+      break;
+    // v2.0.0 T21 — the CLI holds the trace pen: one packet → the .txt + .jsonl
+    // 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,
+        logSweep: (claudeDir) => require("./clear-logs.js").sweep(claudeDir, clearLogsDeps()),
+      });
+      break;
+    // v2.1.0 W7 — print by default; only --apply deletes (DE-16, DE-17).
+    case "clear":
+      require("./clear-logs.js").clearCmd(clearLogsDeps());
+      break;
     case "mock":
       mock();
       break;
@@ -45620,6 +47301,10 @@ function jsonCrash(err) {
     case "export":
       exportCmd();
       break;
+    // v2.1.0 — does the project ask for its own review? Read-only probe.
+    case "review":
+      reviewCmd();
+      break;
     // v0.47.0 — the lane that refuses to produce. Every subcommand is a READ
     // with an exit-code contract except `init`, `record`, `accept`, `rebut`,
     // `template`, `goals` and `report`, which are the ledger's only writers.
@@ -45679,12 +47364,20 @@ function jsonCrash(err) {
     case "pr-stack-status":
       pr(cmd);
       break;
+    // v2.0.0 W6a (Q3) — the failing CI steps, read-only, flaky re-attempts named.
+    case "ci":
+      require("./gotcha-import.js").ciFailedCmd(gotchaDeps());
+      break;
     case "resume":
       resume();
       break;
     case "run":
       runCmd();
       break;
+    // v2.0.0 W6b (Q2)  revert ONLY what a run changed, back to its snapshot.
+    case "undo":
+      require("./run-undo.js").undoCmd(runUndoDeps());
+      break;
     case "stats":
       stats();
       break;