@azure-id/orc 2.0.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) {
@@ -1548,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 {
@@ -1556,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/extra-dispatch.md

@@ -131,9 +131,9 @@ tasks and then pins one executor over them, so both edges of that agent's band i
 a question about numbers the run actually produced. `/orc-fast` produces none.
 Mini is the LAST caller of the both-edges rule, and that rule keeps its reason.
 **Resolve BOTH EDGES of the pinned agent's band and require them to agree** —
-`[55,65)` is `orc extra resolve 55` and `orc extra resolve 64`, same profile and
+`[31,41)` is `orc extra resolve 31` and `orc extra resolve 40`, same profile and
 model on both or the lane stays on Claude. The alternative was a midpoint, and a
-row covering `[55,58)` would then capture an entire mini run on the strength of
+row covering `[31,34)` would then capture an entire mini run on the strength of
 three scores out of ten. **A number ORC invented to satisfy an
 interface is not a routing decision the user made.**
 
@@ -153,7 +153,7 @@ too.
 | `doc-writer` | `/orc-doc` | `orc-doc-writer-opus-5-med` | announced, before the wave, naming the sections | a writer owns ONE part file and invents no fact; its output is read by a checker and by you before it ships |
 | `doc-checker` | `/orc-doc` | `orc-doc-checker-opus-5-low` | announced, before the wave | the checker reads one bounded part and reports; it rewrites nothing |
 | `test-designer` | `/orc-test` | `orc-test-designer-opus-5-high` | announced, the T1 `extra:` line, before any case runs | the designer writes a FILE the CLI reads back through a validating command, and a row that fails validation is refused BY NAME — so its output is checked before anything is sent |
-| `wiki-scanner-deep` | `/orc-wiki` | `orc-wiki-scanner-opus-4-8-high` | announced, per scan-batch, beside the resolved tier | a scanner returns an evidence-anchored doc body; every claim in it is anchored to a file you can open |
+| `wiki-scanner-deep` | `/orc-wiki` | `orc-wiki-scanner-opus-5-low` | announced, per scan-batch, beside the resolved tier | a scanner returns an evidence-anchored doc body; every claim in it is anchored to a file you can open |
 | `wiki-scanner-light` | `/orc-wiki` | `orc-wiki-scanner-sonnet-5-high` | announced, per scan-batch, beside the resolved tier | the LIGHT tier is already a small no-new-surface delta on an existing doc |
 
 **`/orc-test`'s INTERPRETER deliberately has NO SLOT, and that refusal is the
@@ -163,7 +163,7 @@ fence fences FILES, not a request body. There is no version of that route this
 repo could describe honestly, so there is none. It is the `/orc-challenge never`
 shape, for a stronger reason than cost.
 
-Both wiki slots collapse onto `orc-wiki-scanner-opus-5-med` while `opus5_only` is
+Both wiki slots collapse onto `orc-wiki-scanner-opus-5-low` while `opus5_only` is
 on, which is why this release **adds no agent and no pair**. Two slots and one
 Opus 5.5 agent is not a contradiction: **a slot names the POSITION, not the model.**
 
@@ -235,7 +235,7 @@ One sentence, and it is the same sentence for both shapes:
 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
 ```
 
 **A slot**, highest wins:

package/templates/skills/_shared/gotchas.md

@@ -185,7 +185,19 @@ cited one), then ONE trace line:
 `FINDING-OUTCOME addressed=<n> disputed=<n> wontfix=<n> open=<n> pre=<n> suppressed=<n> :: <cat>:<addressed>/<total>,…`.
 Where: `/orc` and `/orc-ultra` at Phase 7 (`phases/summary.md`), `/orc-mini`
 after the risk option's review, `/orc-quick` after the review offer. A review
-with zero findings records nothing and is a HEALTHY answer.
+with zero findings records no observation and is a HEALTHY answer: its
+`FINDING-OUTCOME` line (or the hook `RETURN orc-reviewer-*` line) already counts
+it as a review in `orc gotcha quality` (v2.1.0). An `author: orc` observation
+without `run` is refused (exit 2) — a `ref` that starts with the run id fills it.
+
+**The reviewed ranges (v2.1.0, DE-13).** In the same step, store what the review
+READ: `orc gotcha observe -` with
+`{"kind": "review-scope", "run": "<trace name>", "commit": "<HEAD>", "files": {"<path>": [[start, end], …]}}`
+— the slice's `diff_ranges`, a clean review too. The CLI keeps the last 500
+reviews in `.claude/orc/review-scope.jsonl` (user data, never pruned by age) and
+counts what it drops. A later `orc fix record` on lines inside a stored range
+of an EARLIER run is a computed `miss`: the fix is promoted at 1 case and goes
+first in the next card.
 
 ### Per-lane mechanics (the spines keep the trigger; this is the detail)
 
@@ -205,16 +217,24 @@ file is never a reason to fall back, and gotchas here are purely additive: probe
 inject the scope-matching entries into the F2 slice, and stop there. It never
 writes one, because one executor plus one repair round is too little signal to
 attribute a cause — and a lane with no analyst writing repair memory is how that
-memory fills with guesses.
+memory fills with guesses. **A review is different (v2.1.0):** when `/orc-fast` runs
+a review (the F4 offer, or the user asks for one), it records that review's outcomes
+as "Review close" says — an observation is REVIEW LEARNING, not a repair-memory
+entry, and every lane that ran a review records it.
 
 **`/orc-quick` — reads and records, since 2.0.0 (a deliberate reversal).**
-Record at step 3.3, after entry N is appended, and only for a request with
-programmatic proof: a defect entry with `REPRO red` then `REPRO green`
+Record after the step 3.5 offers (v2.1.0 — it was 3.3, before the review offer
+existed to record), and only for a request with programmatic proof: a defect entry with `REPRO red` then `REPRO green`
 (`source: defect`, `reproduced: true`) · a PR thread the request took and fixed
 (`source: pr`) · a Sonar or SARIF item fixed (`source: sonar` / `sarif`) · a CI
-failure fixed (`source: ci`) · a review-offer P0/P1 fixed (`source: review`,
-`addressed`) · a review finding the user called "not a problem here"
-(`source: review`, `disputed`). A plain fix with none of these records nothing.
+failure fixed (`source: ci`) · every finding of a review offer, ONE observation per finding
+with its outcome, as "Review close" says (`source: review`; "not a problem here"
+= `disputed`). A plain fix with none of these records nothing.
+A FIX of a named finding (a Sonar issue, a failed check, a defect ORC or an AI
+tool caused) goes through `orc fix record -` (`via: "orc-quick"`, v2.1.0): the
+author is the finder, never `orc`; a Sonar issue key gives the importer's own id,
+so a later gotcha sync completes the same row; and the CLI computes `miss`
+from `review-scope.jsonl`.
 Why the reversal: quick is where most of the fixes happen, so a memory that
 skips it never learns; a PR thread is a human's judgement and a red → green
 repro is proof, so the v1 "too little signal" objection does not apply; and the

package/templates/skills/_shared/habits.md

@@ -74,14 +74,14 @@ compiled flow's last phase. `/orc-wait` makes no proposal.
   question; its `announce[]` line names the habit and its undo. A habit
   toward `no` is a pre-mark only, never applied. A learned
   `review_before_push: on` → the end-of-run batch ALWAYS carries option *a*
-  (dispatch `orc-reviewer-opus-5-med` on the diff), marked `→ usual`, even with
+  (dispatch `orc-reviewer-opus-5-low` on the diff), marked `→ usual`, even with
   no `risk: high` row. Record `any.ship.review-before-push` whenever option *a*
   is offered: `chose=review` when the user takes it, else `push`.
 - **`/orc-fast`.** `fast.f0.stale-wiki`: a habit NEVER suggests `continue`
   (a stale wiki is a risk the user takes each time). The CLI never proposes
   it (`never_option`); a suggestion row that names it anyway is ignored. Show
   a `refresh` or `mini` suggestion only, and never apply one. A learned `review_before_push: on` → F4
-  offers a dispatch of `orc-reviewer-opus-5-med` on the diff FIRST (P0/P1 block
+  offers a dispatch of `orc-reviewer-opus-5-low` on the diff FIRST (P0/P1 block
   the commit), marked `→ usual`; the reviewer is not in the fast pipeline, so
   it runs only on that yes. Record `any.ship.review-before-push` whenever it is
   offered.