@azure-id/orc 1.9.2 → 2.1.0

package/templates/hooks/orc-statusline.js

@@ -401,6 +401,23 @@ const SCAN = {
   trace_age_min: null, trace_state: null, last_agent: null, retries: null,
 };
 
+// v2.1.0 (DE-23) — is a `statusLine.refreshInterval` set? The local file wins
+// over the project file, as in Claude Code. One small read per run, fail-silent.
+function refreshIntervalSet(projectDir) {
+  const fs = require("fs");
+  const path = require("path");
+  for (const f of ["settings.local.json", "settings.json"]) {
+    try {
+      const j = JSON.parse(fs.readFileSync(path.join(projectDir, ".claude", f), "utf8"));
+      if (j && j.statusLine && Object.prototype.hasOwnProperty.call(j.statusLine, "refreshInterval")) {
+        const n = Number(j.statusLine.refreshInterval);
+        return Number.isFinite(n) && n >= 1;
+      }
+    } catch (_) {}
+  }
+  return false;
+}
+
 function ledger(projectDir, sid) {
   if (LED) return LED;
   const fs = require("fs");
@@ -473,7 +490,7 @@ function readPlan(d) {
     const projectDir =
       (d.workspace && d.workspace.project_dir) || d.cwd || process.cwd();
     const raw = fs.readFileSync(path.join(projectDir, ".claude", "orc.config.yaml"), "utf8");
-    if (!/^[ \t]*statusline_custom:[ \t]*["']?on["']?[ \t]*\r?$/m.test(raw)) return null;
+    if (!/^[ \t]*statusline_custom:[ \t]*["']?on["']?[ \t]*(?:#.*)?\r?$/m.test(raw)) return null;
     const lock = JSON.parse(
       fs.readFileSync(path.join(projectDir, ".claude", "orc", "statusline.lock.json"), "utf8")
     );
@@ -572,16 +589,27 @@ process.stdin.on("end", () => {
           ? { used_percentage: o.used_percentage, resets_at: o.resets_at == null ? null : o.resets_at }
           : null;
       fs.mkdirSync(orcDir, { recursive: true });
-      fs.writeFileSync(
-        path.join(orcDir, "usage.json"),
-        JSON.stringify({
-          five_hour: win(rl0 && rl0.five_hour),
-          seven_day: win(rl0 && rl0.seven_day),
-          context_used_percentage:
-            cw0 && typeof cw0.used_percentage === "number" ? cw0.used_percentage : null,
-          written_at: Date.now(),
-        }) + "\n"
-      );
+      // v2.1.0 (DE-24) — rewrite ONLY when the numbers change. With a refresh
+      // timer every tick re-ran this, and a fresh `written_at` on old numbers
+      // made them look new to `orc usage check`. `written_at` is now the time
+      // the reading last MOVED.
+      const usageFile = path.join(orcDir, "usage.json");
+      const reading = {
+        five_hour: win(rl0 && rl0.five_hour),
+        seven_day: win(rl0 && rl0.seven_day),
+        context_used_percentage:
+          cw0 && typeof cw0.used_percentage === "number" ? cw0.used_percentage : null,
+      };
+      let prev = null;
+      try {
+        prev = JSON.parse(fs.readFileSync(usageFile, "utf8"));
+      } catch (_) {}
+      const same =
+        prev &&
+        prev.written_at &&
+        JSON.stringify([prev.five_hour, prev.seven_day, prev.context_used_percentage]) ===
+          JSON.stringify([reading.five_hour, reading.seven_day, reading.context_used_percentage]);
+      if (!same) fs.writeFileSync(usageFile, JSON.stringify(Object.assign(reading, { written_at: Date.now() })) + "\n");
       // -- Session consumption (v1.2.0) -------------------------------------
       // `usage.json` is a SNAPSHOT of the window. It cannot answer "how much
       // has THIS session eaten", which is the question a user actually asks
@@ -1085,6 +1113,18 @@ process.stdin.on("end", () => {
     line2 = "";
   }
 
+  // v2.1.0 (DE-23) — when a refresh timer is set, a motion part advances ONE
+  // step per run (the frame after the last frame shown), not the frame for this
+  // millisecond: at 2-10 s the wall clock skipped most frames. No timer → the
+  // wall-clock rule stays, so `step` is null.
+  let step = null;
+  try {
+    if (LED && refreshIntervalSet((d.workspace && d.workspace.project_dir) || d.cwd || process.cwd())) {
+      LED.frame = (Number(LED.frame) || 0) + 1;
+      step = LED.frame;
+    }
+  } catch (_) {}
+
   // ONE write, after every block that touches the ledger has had its say. It is
   // last on purpose: a render that throws half way through still prints, and a
   // ledger that could not be written never takes the status line down with it.
@@ -1102,6 +1142,7 @@ process.stdin.on("end", () => {
     scan: SCAN,
     derived: { verdict, reasons, version: ver },
     now: Date.now(),
+    step,
   });
   if (composed != null) {
     process.stdout.write(composed);
@@ -1117,7 +1158,8 @@ process.stdin.on("end", () => {
 //   1  statusline_custom is not `on`        the shipped lines. BYTE-IDENTICAL.
 //   2  statusline-compiled.json missing /   default + statusline-layout-unreadable
 //      unparseable / schema mismatch
-//   3  orc_version or catalog_hash moved    default + statusline-layout-stale
+//   3  catalog_hash moved (orc_version when default + statusline-layout-stale
+//      the install has no catalog_hash)
 //   4  an unknown op or an unknown binding  default + statusline-layout-skew
 //   5  the cheap shape guard fails          default + statusline-layout-invalid
 //   6  otherwise                            run the program
@@ -1145,7 +1187,7 @@ function custom(d, ctx) {
       // The trailing \r is tolerated on purpose: a config file written on
       // Windows carries CRLF, and a $-anchored match silently never fires
       // there — which is a feature that is ON in the file and OFF on the bar.
-      on = /^[ \t]*statusline_custom:[ \t]*["']?on["']?[ \t]*\r?$/m.test(raw);
+      on = /^[ \t]*statusline_custom:[ \t]*["']?on["']?[ \t]*(?:#.*)?\r?$/m.test(raw);
     } catch (_) {}
     if (!on) return null;
 
@@ -1164,11 +1206,13 @@ function custom(d, ctx) {
     try {
       lock = JSON.parse(fs.readFileSync(path.join(orcDir, "statusline.lock.json"), "utf8"));
     } catch (_) {}
-    let installed = null;
+    // The catalogue hash decides when the install carries one: a CLI version
+    // bump that changed no component must not drop the user's design.
+    let inst = {};
     try {
-      installed = JSON.parse(fs.readFileSync(path.join(__dirname, "orc-version.json"), "utf8")).version;
+      inst = JSON.parse(fs.readFileSync(path.join(__dirname, "orc-version.json"), "utf8")) || {};
     } catch (_) {}
-    if (!lock || (installed && lock.orc_version !== installed))
+    if (!lock || (inst.catalog_hash ? lock.catalog_hash !== inst.catalog_hash : (inst.version && lock.orc_version !== inst.version)))
       return slFallback(orcDir, "statusline-layout-stale");
 
     const engine = require("./orc-statusline-render.js");
@@ -1178,6 +1222,7 @@ function custom(d, ctx) {
     for (const b of lock.bindings || []) {
       if (!engine.BINDINGS[b]) return slFallback(orcDir, "statusline-layout-skew");
     }
+    if (engine.OPS && !opsKnown(prog.lines, engine.OPS)) return slFallback(orcDir, "statusline-layout-skew");
 
     // Rung 5. The cheap shape guard: at most three lines, at most `max_per_line`
     // components on any of them, and the dense-prefix rule —
@@ -1206,16 +1251,25 @@ function custom(d, ctx) {
     // Rung 6. Run the program. Failure isolation lives inside the engine: one
     // throwing item emits its unknown form and the rest of the line survives.
     SCAN.preset = prog.preset || null;
+    if ((lock.providers || []).indexOf("scan.weather") >= 0) weather(orcDir, prog.lines);
     const out = engine.render(prog, {
       payload: ctx.payload,
       ledger: ctx.ledger,
       scan: ctx.scan,
       derived: ctx.derived,
       now: ctx.now,
-      cols: Number(process.env.COLUMNS) || 0,
+      step: ctx.step,
+      cols: Number(process.env.COLUMNS) || Number(d.columns) || 0,
       env: process.env,
     });
     if (out.errors && out.errors.length) slNote(orcDir, "statusline-item-failed", out.errors[0]);
+    else {
+      // A working bar clears the old fallback, so `orc doctor` stops naming it.
+      try {
+        const st = path.join(orcDir, "statusline-state.json");
+        if (fs.existsSync(st)) fs.unlinkSync(st);
+      } catch (_) {}
+    }
     return out.text;
   } catch (_) {
     // Even the ladder must not throw. A status line that crashes is a status
@@ -1224,6 +1278,67 @@ function custom(d, ctx) {
   }
 }
 
+// Every compiled op must be one the engine walks. A plain stack, no copies.
+function opsKnown(lines, OPS) {
+  const st = [];
+  for (const l of lines || []) st.push(l.ops || []);
+  while (st.length) {
+    const list = st.pop();
+    for (let i = 0; i < list.length; i++) {
+      const o = list[i];
+      if (!o || !OPS[o.op]) return false;
+      if (o.children) st.push(o.children);
+      if (o.cap && o.cap.ops) st.push(o.cap.ops);
+    }
+  }
+  return true;
+}
+
+// ── WEATHER (v2.0.4) ───────────────────────────────────────────────────────
+// ONE small file read. The network belongs to a DETACHED fetcher that this
+// hook starts and never waits for; the bar shows the last cached answer, or an
+// em dash. A lock file keeps a slow network from starting a fetch per render.
+function weather(orcDir, lines) {
+  try {
+    const fs = require("fs");
+    const path = require("path");
+    const now = Date.now();
+    let j = null;
+    try {
+      j = JSON.parse(fs.readFileSync(path.join(orcDir, "weather.json"), "utf8"));
+    } catch (_) {}
+    SCAN.weather = j && typeof j === "object" ? j : undefined;
+    if (j && typeof j.at === "number" && now - j.at < 30 * 60 * 1000) return;
+    if (process.env.ORC_STATUSLINE_NO_NET === "1") return;
+    const lockFile = path.join(orcDir, "weather.lock");
+    try {
+      if (now - fs.statSync(lockFile).mtimeMs < 2 * 60 * 1000) return;
+    } catch (_) {}
+    // Location and units come from the first op that binds `weather.*`.
+    let p = null;
+    const st = (lines || []).map((l) => l.ops || []);
+    while (st.length && !p) {
+      for (const o of st.pop()) {
+        if (!o) continue;
+        if (typeof o.b === "string" && o.b.indexOf("weather.") === 0 && o.p) {
+          p = o.p;
+          break;
+        }
+        if (o.children) st.push(o.children);
+      }
+    }
+    p = p || {};
+    fs.writeFileSync(lockFile, String(now));
+    require("child_process")
+      .spawn(process.execPath, [path.join(__dirname, "orc-weather-fetch.js"), orcDir, String(p.location || ""), p.units === "us" ? "us" : "metric"], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+      })
+      .unref();
+  } catch (_) {}
+}
+
 // A fallback RECORDS ITSELF. `orc doctor` reads this file and names the finding
 // with the exact command that clears it.
 function slFallback(orcDir, finding) {
@@ -1339,8 +1454,10 @@ function extendedScan(d, wants, wantsProvider) {
   }
   if (wants("gotchas.count")) {
     SCAN.gotchas = cached("gotchas", TTL.knowledge, () => {
+      // The ledger is ONE file, `.claude/orc/gotchas.md`; each entry opens with
+      // a `## G-<id>` heading. No file → null, never 0 (no ledger is not "none").
       try {
-        return fs.readdirSync(path.join(orc, "gotchas")).filter((f) => f.endsWith(".md")).length;
+        return (fs.readFileSync(path.join(orc, "gotchas.md"), "utf8").match(/^##[ \t]+G-\d/gm) || []).length;
       } catch (_) {
         return null;
       }
@@ -1546,7 +1663,15 @@ function extendedScan(d, wants, wantsProvider) {
 // planner again. A series nothing binds is not kept, so the ledger does not
 // grow for a user whose layout has no sparkline on it.
 const SERIES_MAX = 16;
-const SERIES_MIN_GAP_MS = 20000;
+const SERIES_MIN_GAP_MS = 10000;
+// Series name → the binding whose number it stores. The stored sample IS the
+// binding's value, so a spark and the number beside it can never disagree.
+const SERIES_BINDING = {
+  agents: "run.agents", burn: "burn.rate", cost: "cost.usd", cachehit: "cache.hit_ratio",
+  cachewrite: "cache.write_tokens", lines: "cost.lines_net", extraspend: "extra.spend",
+  speed: "mtok.speed", mtok: "mtok.total", mtokkind: "mtok.cache_read",
+  quota5h: "quota.5h.pct", quotawk: "quota.week.pct", ucs: "ucs.pct",
+};
 
 function sampleSeries(d, plan) {
   try {
@@ -1554,42 +1679,32 @@ function sampleSeries(d, plan) {
     const led = LED;
     if (!led) return;
     const now = Date.now();
-    // A sample every 20 seconds, not every render. Sixteen samples at the
-    // render rate would be five seconds of history, which is not history — it
-    // is the same number sixteen times.
-    if (led.series_at && now - led.series_at < SERIES_MIN_GAP_MS) return;
-    led.series_at = now;
     led.series = led.series || {};
-    const push = (key, v) => {
-      if (!plan.series.has(key)) return;
-      if (typeof v !== "number" || !Number.isFinite(v)) return;
+    // A sample every 10 seconds, not every render. Sixteen samples at the
+    // render rate would be a few seconds of history, which is not history — it
+    // is the same number sixteen times. While no series has a point yet, it is
+    // sampled at once, so a new spark has a point on its first render.
+    const empty = [...plan.series].every((k) => !(led.series[k] && led.series[k].length));
+    if (!empty && led.series_at && now - led.series_at < SERIES_MIN_GAP_MS) return;
+    led.series_at = now;
+    // The engine is required by custom() on this same render, so this costs no
+    // extra file read.
+    const B = require("./orc-statusline-render.js").BINDINGS;
+    const c = { payload: d, ledger: led, scan: SCAN, now, derived: {}, task: null };
+    for (const key of plan.series) {
+      const b = SERIES_BINDING[key];
+      if (!b || !B[b]) continue;
+      let v = null;
+      try {
+        v = B[b](c);
+      } catch (_) {}
+      if (typeof v !== "number" || !Number.isFinite(v)) continue;
       const arr = led.series[key] || [];
-      arr.push(Math.round(v));
+      // Two decimals: Math.round turned every dollar amount below 1 into 0.
+      arr.push(Number(v.toFixed(2)));
       while (arr.length > SERIES_MAX) arr.shift();
       led.series[key] = arr;
-    };
-    const rl = d.rate_limits || {};
-    const w = led.five_hour;
-    push("quota5h", rl.five_hour && rl.five_hour.used_percentage);
-    push("quotawk", rl.seven_day && rl.seven_day.used_percentage);
-    push("ucs", w && typeof w.last === "number" && typeof w.baseline === "number"
-      ? Math.max(0, (w.accumulated || 0) + Math.max(0, w.last - w.baseline))
-      : null);
-    const tok = led.tok;
-    if (tok) {
-      push("mtok", (tok.input || 0) + (tok.cache_write || 0) + (tok.cache_read || 0) + (tok.output || 0));
-      push("mtokkind", tok.cache_read || 0);
     }
-    push("agents", SCAN.spawns);
-    push("cost", d.cost && d.cost.total_cost_usd != null ? d.cost.total_cost_usd * 100 : null);
-    push("cachehit", d.prompt_cache && d.prompt_cache.hit_ratio != null
-      ? (d.prompt_cache.hit_ratio <= 1 ? d.prompt_cache.hit_ratio * 100 : d.prompt_cache.hit_ratio)
-      : null);
-    push("cachewrite", d.prompt_cache && d.prompt_cache.cache_write_tokens);
-    push("lines", d.cost && d.cost.total_lines_added != null
-      ? (d.cost.total_lines_added || 0) - (d.cost.total_lines_removed || 0)
-      : null);
-    push("extraspend", SCAN.extra_spend && SCAN.extra_spend.usd != null ? SCAN.extra_spend.usd * 100 : null);
   } catch (_) {
     // A series is a nicety. It never takes the status line down with it.
   }

package/templates/hooks/orc-subagent-line.js

@@ -151,7 +151,7 @@ function render(d, tasks) {
     let on = false;
     try {
       const cfg = fs.readFileSync(path.join(projectDir, ".claude", "orc.config.yaml"), "utf8");
-      on = /^[ \t]*subagent_line_custom:[ \t]*["']?on["']?[ \t]*\r?$/m.test(cfg);
+      on = /^[ \t]*subagent_line_custom:[ \t]*["']?on["']?[ \t]*(?:#.*)?\r?$/m.test(cfg);
     } catch (_) {}
     if (!on) return null;
 
@@ -167,11 +167,12 @@ function render(d, tasks) {
     try {
       lock = JSON.parse(fs.readFileSync(path.join(orcDir, "subagent.lock.json"), "utf8"));
     } catch (_) {}
-    let installed = null;
+    // The catalogue hash decides when the install carries one.
+    let inst = {};
     try {
-      installed = JSON.parse(fs.readFileSync(path.join(__dirname, "orc-version.json"), "utf8")).version;
+      inst = JSON.parse(fs.readFileSync(path.join(__dirname, "orc-version.json"), "utf8")) || {};
     } catch (_) {}
-    if (!lock || (installed && lock.orc_version !== installed)) return null;
+    if (!lock || (inst.catalog_hash ? lock.catalog_hash !== inst.catalog_hash : (inst.version && lock.orc_version !== inst.version))) return null;
 
     const engine = require("./orc-statusline-render.js");
 
@@ -179,6 +180,7 @@ function render(d, tasks) {
     for (const b of lock.bindings || []) {
       if (!engine.BINDINGS[b]) return null;
     }
+    if (engine.OPS && !opsKnown(prog.lines, engine.OPS)) return null;
 
     // Rung 5. A subagent row is ONE line by construction — Claude Code renders
     // one row per task — so the board's three-line shape does not apply and the
@@ -202,7 +204,7 @@ function render(d, tasks) {
             payload: d,
             ledger: {},
             scan: {},
-            derived: { verdict: null, reasons: [], version: installed },
+            derived: { verdict: null, reasons: [], version: inst.version || null },
             task,
             now,
             cols: Number(process.env.COLUMNS) || 0,
@@ -220,3 +222,19 @@ function render(d, tasks) {
     return null;
   }
 }
+
+// Every compiled op must be one the engine walks. A plain stack, no copies.
+function opsKnown(lines, OPS) {
+  const st = [];
+  for (const l of lines || []) st.push(l.ops || []);
+  while (st.length) {
+    const list = st.pop();
+    for (let i = 0; i < list.length; i++) {
+      const o = list[i];
+      if (!o || !OPS[o.op]) return false;
+      if (o.children) st.push(o.children);
+      if (o.cap && o.cap.ops) st.push(o.cap.ops);
+    }
+  }
+  return true;
+}

package/templates/hooks/orc-weather-fetch.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * ORC statusline — THE WEATHER FETCHER. (v2.0.4)
+ *
+ * The status-line hook starts this DETACHED and never waits for it:
+ *   node orc-weather-fetch.js <orcDir> <location> <metric|us>
+ * It asks wttr.in once, writes `<orcDir>/weather.json` atomically (a temp file,
+ * then a rename) and deletes `<orcDir>/weather.lock`. Any error deletes the
+ * lock and exits quietly: the old cache stays as it was. It never prints.
+ * Zero dependencies.
+ */
+
+const SUN = [113];
+const PARTLY = [116];
+const CLOUD = [119, 122];
+const FOG = [143, 248, 260];
+const STORM = [200, 386, 389, 392, 395];
+const RAIN = [176, 263, 266, 281, 284, 293, 296, 299, 302, 305, 308, 311, 314, 353, 356, 359];
+const SNOW = [179, 182, 185, 227, 230, 317, 320, 323, 326, 329, 332, 335, 338, 350, 362, 365, 368, 371, 374, 377];
+
+// wttr.in weatherCode → one of the `weather-icon` states. An unknown code is
+// fog when the description names haze/smoke/mist/fog/dust/sand/ash, else cloud.
+function stateOf(code, desc) {
+  const n = Number(code);
+  if (!Number.isFinite(n)) return null;
+  if (SUN.includes(n)) return "sun";
+  if (PARTLY.includes(n)) return "partly";
+  if (CLOUD.includes(n)) return "cloud";
+  if (FOG.includes(n)) return "fog";
+  if (STORM.includes(n)) return "storm";
+  if (SNOW.includes(n)) return "snow";
+  if (RAIN.includes(n)) return "rain";
+  if (/haze|smoke|mist|fog|dust|sand|ash/i.test(String(desc || ""))) return "fog";
+  return "cloud";
+}
+
+// A provider string is printed to a terminal: no control characters (an ESC
+// is a terminal-escape injection), at most 24 characters.
+function clean(s) {
+  if (s == null) return null;
+  const t = [...String(s).replace(/[\u0000-\u001f\u007f-\u009f]/g, "")].slice(0, 24).join("").trim();
+  return t || null;
+}
+
+function numOr(v) {
+  const n = typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v) : NaN;
+  return Number.isFinite(n) ? n : null;
+}
+
+// The pure half: a parsed wttr.in `j1` body → the cache record, or null.
+function record(body, now) {
+  const cur = body && Array.isArray(body["current_condition"]) ? body["current_condition"][0] : null;
+  if (!cur) return null;
+  const desc = Array.isArray(cur.weatherDesc) && cur.weatherDesc[0] ? cur.weatherDesc[0].value : null;
+  return {
+    at: now,
+    temp_c: numOr(cur.temp_C),
+    temp_f: numOr(cur.temp_F),
+    state: stateOf(cur.weatherCode, desc),
+    desc: clean(desc),
+  };
+}
+
+function main(argv) {
+  const fs = require("fs");
+  const path = require("path");
+  const orcDir = argv[0];
+  if (!orcDir) return;
+  const lockFile = path.join(orcDir, "weather.lock");
+  const drop = () => {
+    try {
+      fs.unlinkSync(lockFile);
+    } catch (_) {}
+  };
+  try {
+    const loc = String(argv[1] || "").replace(/[\u0000-\u001f\u007f-\u009f]/g, "").slice(0, 40);
+    const url = "https://wttr.in/" + encodeURIComponent(loc) + "?format=j1";
+    const req = require("https").get(url, { headers: { "User-Agent": "orc-statusline" }, timeout: 6000 }, (res) => {
+      if (res.statusCode !== 200) {
+        res.resume();
+        drop();
+        return;
+      }
+      let raw = "";
+      res.setEncoding("utf8");
+      res.on("data", (c) => {
+        raw += c;
+        if (raw.length > 1e6) req.destroy();
+      });
+      res.on("end", () => {
+        try {
+          const rec = record(JSON.parse(raw), Date.now());
+          if (rec) {
+            const out = path.join(orcDir, "weather.json");
+            const tmp = out + "." + process.pid + ".tmp";
+            fs.writeFileSync(tmp, JSON.stringify(rec) + "\n");
+            fs.renameSync(tmp, out);
+          }
+        } catch (_) {}
+        drop();
+      });
+      res.on("error", drop);
+    });
+    req.on("timeout", () => req.destroy());
+    req.on("error", drop);
+  } catch (_) {
+    drop();
+  }
+}
+
+if (require.main === module) {
+  process.on("uncaughtException", () => {
+    try {
+      require("fs").unlinkSync(require("path").join(process.argv[2] || ".", "weather.lock"));
+    } catch (_) {}
+    process.exit(0);
+  });
+  main(process.argv.slice(2));
+}
+
+module.exports = { stateOf, clean, record };

package/templates/skills/_shared/README.md

@@ -55,6 +55,15 @@ loaded on demand when the step fires.
   their meaning — read a family top-down and stop at the first rank that
   resolves. Also the two contested families, gates vs inertness, the
   `announce[]` boundary, and what a lane does when the CLI cannot answer.
+- `lane-contract.md` — the common text of the six spine blocks (Calls · Config ·
+  Rules · Trace · Phases · Wait), held once. A coding-lane spine keeps a short
+  pointer with its own values and reads this file ONLY when a CLI call exits ≠ 0.
+- `habits.md` — the lane side of habits: the `→ usual` mark, the `ASK` event at
+  each `(H <qid>)` question, and the one run-end proposal. Read ONLY when
+  `orc lane config` answers with a `habits{}` block (never under `habits: off`).
+- `review-slice.md` — the ONE review slice every lane uses: the R1 free check,
+  the fields (`tool_findings[]`, `gotcha_card` …) and the
+  after-filter. Read ONLY when a review dispatch is about to be built.
 
 Human guides live in the skills themselves: `../orc-pr-setup/README.md` (plan the
 layers), `../orc-pr-driver/README.md` (build, submit, merge them), and