@azure-id/orc 1.9.0 → 1.9.2

package/templates/hooks/orc-effort-guard.js

@@ -1,178 +1,178 @@
-#!/usr/bin/env node
-"use strict";
-
-/**
- * ORC effort guard — a Claude Code PreToolUse hook.
- *
- * Blocks invocation of the full `orc` orchestrator skill unless the MAIN
- * session is running at HIGH reasoning effort (Opus 5 / Fable 5 clear at
- * medium+ — see the session-model bridge below). This is the one half of the
- * "run ORC on Opus 4.8 high or better" rule hooks can enforce deterministically:
- * Claude Code exposes `effort.level` (and $CLAUDE_EFFORT) to PreToolUse, but
- * NOT the model id (only SessionStart may see the model, and cannot block).
- * The model tier is surfaced separately by the statusline warning + the
- * self-check inside skills/orc/SKILL.md.
- *
- * Wiring (installed by `orc init` into .claude/settings.json):
- *   hooks.PreToolUse[] { matcher: "Skill", hooks:[{ type:"command",
- *     command: 'node "<.claude>/hooks/orc-effort-guard.js"' }] }
- *
- * Contract: read PreToolUse JSON from stdin. Exit 0 = allow. Exit 2 = block
- * the tool call and show stderr to Claude, which relays it to the user.
- *
- * Also surfaces a "newer orc version available" nudge here — this hook fires
- * exactly when /orc is invoked, so it's the natural place to tell the user
- * without them running `orc version`. On allow it emits a `systemMessage`
- * (shown to the user, NOT added to model context → zero tokens); on block it
- * appends the nudge to the block reason. Version check is cached 24h and
- * fail-silent. (systemMessage handling may vary by Claude Code version — verify
- * with /doctor if you don't see it; the statusline shows it regardless.)
- */
-
-// Shared update-check helper (sibling file). Degrade gracefully if absent.
-let updater = null;
-try {
-  updater = require("./orc-update-lib.js");
-} catch (_) {
-  updater = null;
-}
-
-// Effort ladder: low < medium < high < xhigh < max. A tier that meets the bar
-// meets it at that rung OR anything stronger — so "requires high" allows xhigh
-// and max too (the bug this fixes: an xhigh/max session was hard-blocked).
-const EFFORT_LADDER = ["low", "medium", "high", "xhigh", "max"];
-const effortsAtOrAbove = (e) => {
-  const i = EFFORT_LADDER.indexOf(String(e).toLowerCase());
-  return i === -1 ? ["high", "xhigh", "max"] : EFFORT_LADDER.slice(i);
-};
-
-// Session-model bridge (written by orc-statusline.js). The guard can't see the
-// model id itself, so it reads it here to grant the medium-effort allowance of
-// the models that are strictly stronger than the Opus 4.8 baseline (Opus 5 and
-// Fable 5). Fail-OPEN: missing / unreadable / stale → null, and the guard
-// behaves exactly as it would without a bridge (never blocks on our own error).
-// Stale = older than this window; a live session re-renders the statusline far
-// more often, so a fresh file always exists during active use.
-const BRIDGE_MAX_AGE_MS = 30 * 60 * 1000;
-function readSessionModel(projectDir) {
-  try {
-    const fs = require("fs");
-    const path = require("path");
-    const p = path.join(projectDir, ".claude", "orc", "session-model.json");
-    const j = JSON.parse(fs.readFileSync(p, "utf8").replace(/^/, ""));
-    if (!j || typeof j.written_at !== "number") return null;
-    if (Date.now() - j.written_at > BRIDGE_MAX_AGE_MS) return null;
-    return String(j.model_id || "");
-  } catch (_) {
-    return null;
-  }
-}
-// Models that clear /orc at medium effort — strictly stronger than the Opus 4.8
-// baseline, so medium on them beats high on it. Opus 5 (v0.34.0) joins Fable 5.
-// The `\b` after the 5 keeps 4.8 / 4.7 / 5-something-else correctly gated.
-const isMediumOkModel = (id) =>
-  /(opus|fable)[\s._-]?5\b/.test(String(id || "").toLowerCase());
-
-let raw = "";
-process.stdin.on("data", (c) => (raw += c));
-process.stdin.on("end", () => {
-  let data = {};
-  try {
-    data = JSON.parse(raw || "{}");
-  } catch (_) {
-    // Unparseable payload — never block on our own error.
-    process.exit(0);
-  }
-
-  const tool = data.tool_name || "";
-  const input = data.tool_input || {};
-  const skill = String(input.skill || input.name || "");
-
-  // Only gate the full orchestrator and the compiled DIY lane. orc-mini /
-  // orc-fast / orc-analyze / subskills pass — orc-fast is DESIGNED to run at
-  // Sonnet medium; never widen this match to include it.
-  const isOrc = tool === "Skill" && /^orc$/i.test(skill);
-  const isDiy = tool === "Skill" && /^orc-diy$/i.test(skill);
-  if (!isOrc && !isDiy) process.exit(0);
-
-  const effort = String(
-    (data.effort && data.effort.level) || process.env.CLAUDE_EFFORT || ""
-  ).toLowerCase();
-  const installed = updater ? updater.installedVersion(__dirname) : null;
-  const projectDir = data.cwd || process.cwd();
-
-  // Baseline /orc: the session must be at high effort OR stronger (xhigh/max).
-  // Opus 5 and Fable 5 additionally clear at medium — strictly-capable models —
-  // detected through the session-model bridge (the guard can't see the model id
-  // itself; fail-open when the bridge is missing/stale, i.e. medium stays blocked).
-  let requiredEfforts = effortsAtOrAbove("high");
-  let requiredLabel =
-    "Opus 4.8 at high effort (Opus 5 / Fable 5 also clear at medium+)";
-  if (!isDiy && isMediumOkModel(readSessionModel(projectDir))) {
-    requiredEfforts = ["medium", ...requiredEfforts];
-  }
-
-  // /orc-diy: the required tier is whatever the flow was COMPILED for — read
-  // it from flow.lock.json (written only by the `orc diy` CLI). Fail closed:
-  // no lock = no compiled flow = deterministic onboarding block. `compile` /
-  // `status` invocations pass at any effort (they just shell out to the CLI).
-  if (isDiy) {
-    if (/^\s*(compile|status)\b/i.test(String(input.args || ""))) process.exit(0);
-    const fs = require("fs");
-    const path = require("path");
-    let lock = null;
-    try {
-      lock = JSON.parse(
-        fs
-          .readFileSync(
-            path.join(projectDir, ".claude", "orc", "diy", "flow.lock.json"),
-            "utf8"
-          )
-          .replace(/^\uFEFF/, "")
-      );
-    } catch (_) {}
-    if (!lock || !lock.session_tier) {
-      process.stderr.write(
-        "\n⛔ /orc-diy blocked — no compiled flow in this project (fail-closed gate)." +
-          "\n   Compose and build your flow in the terminal first:" +
-          "\n     orc diy init        (then shape it: orc diy set <key> <value>)" +
-          "\n     orc diy compile" +
-          "\n   Guide: .claude/skills/orc-diy/README.md — or use plain /orc for this request.\n"
-      );
-      process.exit(2);
-    }
-    // Effort half is DETERMINISTIC from the compiled slug's suffix (allow that
-    // effort or anything stronger); the model half is warn-only on the
-    // statusline (hooks can't block on model). Covers the full tier grid —
-    // sonnet-4-6 / opus-4-7 / opus-4-8 / fable-5 at med|high|xhigh|max.
-    const m = String(lock.session_tier).match(/-(med|high|xhigh|max)$/);
-    const slugEffort = m ? (m[1] === "med" ? "medium" : m[1]) : "high";
-    requiredEfforts = effortsAtOrAbove(slugEffort);
-    requiredLabel = `${lock.session_tier} (compiled session_tier — needs effort ${slugEffort}+)`;
-  }
-
-  const decide = (nudge) => {
-    if (requiredEfforts.includes(effort)) {
-      // Requirement met — allow. Surface a version nudge if one exists.
-      if (nudge) {
-        try {
-          process.stdout.write(JSON.stringify({ systemMessage: nudge }));
-        } catch (_) {}
-      }
-      process.exit(0);
-    }
-
-    process.stderr.write(
-      `\n⛔ ${isDiy ? "/orc-diy" : "ORC"} blocked — required effort not met` +
-        (effort ? ` (current effort: ${effort}).` : " (effort not detected).") +
-        `\n   Switch this session to ${requiredLabel}, then re-run.` +
-        "\n   Run the MAIN session at (or above) the required tier — subagents cannot" +
-        "\n   exceed the main tier, so pinned agents silently downgrade below it.\n" +
-        (nudge ? "\n" + nudge + "\n" : "")
-    );
-    process.exit(2);
-  };
-
-  if (updater) updater.refreshAndNudge(installed, decide);
-  else decide(null);
-});
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * ORC effort guard — a Claude Code PreToolUse hook.
+ *
+ * Blocks invocation of the full `orc` orchestrator skill unless the MAIN
+ * session is running at HIGH reasoning effort (Opus 5.5 / Fable 5 clear at
+ * medium+ — see the session-model bridge below). This is the one half of the
+ * "run ORC on Opus 4.8 high or better" rule hooks can enforce deterministically:
+ * Claude Code exposes `effort.level` (and $CLAUDE_EFFORT) to PreToolUse, but
+ * NOT the model id (only SessionStart may see the model, and cannot block).
+ * The model tier is surfaced separately by the statusline warning + the
+ * self-check inside skills/orc/SKILL.md.
+ *
+ * Wiring (installed by `orc init` into .claude/settings.json):
+ *   hooks.PreToolUse[] { matcher: "Skill", hooks:[{ type:"command",
+ *     command: 'node "<.claude>/hooks/orc-effort-guard.js"' }] }
+ *
+ * Contract: read PreToolUse JSON from stdin. Exit 0 = allow. Exit 2 = block
+ * the tool call and show stderr to Claude, which relays it to the user.
+ *
+ * Also surfaces a "newer orc version available" nudge here — this hook fires
+ * exactly when /orc is invoked, so it's the natural place to tell the user
+ * without them running `orc version`. On allow it emits a `systemMessage`
+ * (shown to the user, NOT added to model context → zero tokens); on block it
+ * appends the nudge to the block reason. Version check is cached 24h and
+ * fail-silent. (systemMessage handling may vary by Claude Code version — verify
+ * with /doctor if you don't see it; the statusline shows it regardless.)
+ */
+
+// Shared update-check helper (sibling file). Degrade gracefully if absent.
+let updater = null;
+try {
+  updater = require("./orc-update-lib.js");
+} catch (_) {
+  updater = null;
+}
+
+// Effort ladder: low < medium < high < xhigh < max. A tier that meets the bar
+// meets it at that rung OR anything stronger — so "requires high" allows xhigh
+// and max too (the bug this fixes: an xhigh/max session was hard-blocked).
+const EFFORT_LADDER = ["low", "medium", "high", "xhigh", "max"];
+const effortsAtOrAbove = (e) => {
+  const i = EFFORT_LADDER.indexOf(String(e).toLowerCase());
+  return i === -1 ? ["high", "xhigh", "max"] : EFFORT_LADDER.slice(i);
+};
+
+// Session-model bridge (written by orc-statusline.js). The guard can't see the
+// model id itself, so it reads it here to grant the medium-effort allowance of
+// the models that are strictly stronger than the Opus 4.8 baseline (Opus 5.5 and
+// Fable 5). Fail-OPEN: missing / unreadable / stale → null, and the guard
+// behaves exactly as it would without a bridge (never blocks on our own error).
+// Stale = older than this window; a live session re-renders the statusline far
+// more often, so a fresh file always exists during active use.
+const BRIDGE_MAX_AGE_MS = 30 * 60 * 1000;
+function readSessionModel(projectDir) {
+  try {
+    const fs = require("fs");
+    const path = require("path");
+    const p = path.join(projectDir, ".claude", "orc", "session-model.json");
+    const j = JSON.parse(fs.readFileSync(p, "utf8").replace(/^/, ""));
+    if (!j || typeof j.written_at !== "number") return null;
+    if (Date.now() - j.written_at > BRIDGE_MAX_AGE_MS) return null;
+    return String(j.model_id || "");
+  } catch (_) {
+    return null;
+  }
+}
+// Models that clear /orc at medium effort — strictly stronger than the Opus 4.8
+// baseline, so medium on them beats high on it. Opus 5.5 (v0.34.0) joins Fable 5.
+// The `\b` after the 5 keeps 4.8 / 4.7 / 5-something-else correctly gated.
+const isMediumOkModel = (id) =>
+  /(opus|fable)[\s._-]?5\b/.test(String(id || "").toLowerCase());
+
+let raw = "";
+process.stdin.on("data", (c) => (raw += c));
+process.stdin.on("end", () => {
+  let data = {};
+  try {
+    data = JSON.parse(raw || "{}");
+  } catch (_) {
+    // Unparseable payload — never block on our own error.
+    process.exit(0);
+  }
+
+  const tool = data.tool_name || "";
+  const input = data.tool_input || {};
+  const skill = String(input.skill || input.name || "");
+
+  // Only gate the full orchestrator and the compiled DIY lane. orc-mini /
+  // orc-fast / orc-analyze / subskills pass — orc-fast is DESIGNED to run at
+  // Sonnet medium; never widen this match to include it.
+  const isOrc = tool === "Skill" && /^orc$/i.test(skill);
+  const isDiy = tool === "Skill" && /^orc-diy$/i.test(skill);
+  if (!isOrc && !isDiy) process.exit(0);
+
+  const effort = String(
+    (data.effort && data.effort.level) || process.env.CLAUDE_EFFORT || ""
+  ).toLowerCase();
+  const installed = updater ? updater.installedVersion(__dirname) : null;
+  const projectDir = data.cwd || process.cwd();
+
+  // Baseline /orc: the session must be at high effort OR stronger (xhigh/max).
+  // Opus 5.5 and Fable 5 additionally clear at medium — strictly-capable models —
+  // detected through the session-model bridge (the guard can't see the model id
+  // itself; fail-open when the bridge is missing/stale, i.e. medium stays blocked).
+  let requiredEfforts = effortsAtOrAbove("high");
+  let requiredLabel =
+    "Opus 4.8 at high effort (Opus 5.5 / Fable 5 also clear at medium+)";
+  if (!isDiy && isMediumOkModel(readSessionModel(projectDir))) {
+    requiredEfforts = ["medium", ...requiredEfforts];
+  }
+
+  // /orc-diy: the required tier is whatever the flow was COMPILED for — read
+  // it from flow.lock.json (written only by the `orc diy` CLI). Fail closed:
+  // no lock = no compiled flow = deterministic onboarding block. `compile` /
+  // `status` invocations pass at any effort (they just shell out to the CLI).
+  if (isDiy) {
+    if (/^\s*(compile|status)\b/i.test(String(input.args || ""))) process.exit(0);
+    const fs = require("fs");
+    const path = require("path");
+    let lock = null;
+    try {
+      lock = JSON.parse(
+        fs
+          .readFileSync(
+            path.join(projectDir, ".claude", "orc", "diy", "flow.lock.json"),
+            "utf8"
+          )
+          .replace(/^\uFEFF/, "")
+      );
+    } catch (_) {}
+    if (!lock || !lock.session_tier) {
+      process.stderr.write(
+        "\n⛔ /orc-diy blocked — no compiled flow in this project (fail-closed gate)." +
+          "\n   Compose and build your flow in the terminal first:" +
+          "\n     orc diy init        (then shape it: orc diy set <key> <value>)" +
+          "\n     orc diy compile" +
+          "\n   Guide: .claude/skills/orc-diy/README.md — or use plain /orc for this request.\n"
+      );
+      process.exit(2);
+    }
+    // Effort half is DETERMINISTIC from the compiled slug's suffix (allow that
+    // effort or anything stronger); the model half is warn-only on the
+    // statusline (hooks can't block on model). Covers the full tier grid —
+    // sonnet-4-6 / opus-4-7 / opus-4-8 / fable-5 at med|high|xhigh|max.
+    const m = String(lock.session_tier).match(/-(med|high|xhigh|max)$/);
+    const slugEffort = m ? (m[1] === "med" ? "medium" : m[1]) : "high";
+    requiredEfforts = effortsAtOrAbove(slugEffort);
+    requiredLabel = `${lock.session_tier} (compiled session_tier — needs effort ${slugEffort}+)`;
+  }
+
+  const decide = (nudge) => {
+    if (requiredEfforts.includes(effort)) {
+      // Requirement met — allow. Surface a version nudge if one exists.
+      if (nudge) {
+        try {
+          process.stdout.write(JSON.stringify({ systemMessage: nudge }));
+        } catch (_) {}
+      }
+      process.exit(0);
+    }
+
+    process.stderr.write(
+      `\n⛔ ${isDiy ? "/orc-diy" : "ORC"} blocked — required effort not met` +
+        (effort ? ` (current effort: ${effort}).` : " (effort not detected).") +
+        `\n   Switch this session to ${requiredLabel}, then re-run.` +
+        "\n   Run the MAIN session at (or above) the required tier — subagents cannot" +
+        "\n   exceed the main tier, so pinned agents silently downgrade below it.\n" +
+        (nudge ? "\n" + nudge + "\n" : "")
+    );
+    process.exit(2);
+  };
+
+  if (updater) updater.refreshAndNudge(installed, decide);
+  else decide(null);
+});

package/templates/hooks/orc-graph-hook.js

@@ -24,7 +24,10 @@
  *                 the NEXT read can be a range read. The read still runs. OFF
  *                 by default: it is armed with `code_graph_hooks: on,read`.
  *   PostToolUse   (E4c) a Read of a file the extractor did NOT fully see →
- *                 one line naming the lines it missed.
+ *                 one line naming the lines it missed. (R2, v1.9.1) Under `on`
+ *                 it also COUNTS a whole-file read of a wide file — a ledger
+ *                 row, no context — so the `on,read` default can be decided
+ *                 from data.
  *
  * NO DOUBLE PAYMENT. Every hint dedupes against the run's own counters file,
  * and `orc graph ctx --for-slice` (D2) writes the names it delivered into that
@@ -213,7 +216,8 @@ function emit(event, text) {
 // out, inside the fail-quiet wrapper, so a full disk can slow a Grep and can
 // never block one. A coverage note records PAID ONLY: it adds, it saves
 // nothing (K6).
-function ledger(runName, cmd, body, avoided) {
+function ledger(runName, cmd, body, avoided, row) {
+  const extra = row || {};
   try {
     fs.appendFileSync(
       path.join(GRAPH_DIR, "gain.jsonl"),
@@ -225,7 +229,11 @@ function ledger(runName, cmd, body, avoided) {
         targets: [],
         gen: null,
         ms: 0,
-        paid: { card: 0, source: 0, hints: Math.ceil((PREFIX.length + 1 + String(body || "").length) / 4) },
+        ...extra,
+        // M1 (v1.9.1): a row that put NO tokens into anyone's context needs its
+        // own `paid`. The default counts the hint's own prefix, which is right
+        // for a hint and wrong for a background update that nobody read.
+        paid: extra.paid || { card: 0, source: 0, hints: Math.ceil((PREFIX.length + 1 + String(body || "").length) / 4), envelope: 0 },
         avoided: avoided || { low: 0, high: 0, calls_low: 0, calls_high: 0 },
         basis: { files: [], grep_hits: 0 },
       }) + "\n"
@@ -295,7 +303,7 @@ function run() {
     if (tool === "Read") return readHint ? onWideRead(data, runName, meta) : undefined;
     return onSearch(data, runName, meta);
   }
-  if (event === "PostToolUse") return onRead(data, runName, meta);
+  if (event === "PostToolUse") return onRead(data, runName, meta, readHint);
 }
 
 // ── E5b — an executor finished, so the map is behind ───────────────────────
@@ -326,6 +334,18 @@ function onExecutorStop(data, runName) {
   if (r.error && r.error.code === "ETIMEDOUT") return traceLine(runName, "GRAPH-UPDATE deadline", `agent=${clean(agent, 60)}`);
   if (!out || out.state === "off") return;
   bump(runName, "updates");
+  // M1: the meter showed `0 hook updates` on a project whose hook had run 35 of
+  // them, because the counters file and the ledger are two different files and
+  // only one of them was written. This row is what `orc graph gain` counts. It
+  // is appended in the same fail-quiet path, AFTER the update is done, and it
+  // pays nothing: a background update puts no tokens into any context.
+  ledger(runName, "hook-update", "", { low: 0, high: 0, calls_low: 0, calls_high: 0 }, {
+    agent: clean(agent, 60),
+    targets: [clean(agent, 60)],
+    gen: out.generation || null,
+    ms: Number(out.ms) || 0,
+    paid: { card: 0, source: 0, hints: 0, envelope: 0 },
+  });
   const moved = (out.added || 0) + (out.changed || 0) + (out.deleted || 0);
   traceLine(
     runName,
@@ -430,10 +450,17 @@ function onWideRead(data, runName, meta) {
   const rows = Object.prototype.hasOwnProperty.call(wide.files, rel) ? wide.files[rel] : null;
   if (!Array.isArray(rows) || !rows.length) return;
   if (!bump(runName, "injected", "wide:" + rel)) return;
+  // R3 (v1.9.1): the store ranks by IMPORTANCE, which is the repository's view.
+  // A name this run was already told about — by a search hint or by the slice —
+  // is the TASK's view, so it goes first. A stable sort: every other row keeps
+  // its importance order, and the line text does not change.
+  const told = new Set(((readJson(seenFile(runName)) || {}).tokens || []).filter((t) => typeof t === "string" && t.startsWith("name:")).map((t) => t.slice(5)));
+  const mine = (r) => (told.has(String(r[0])) || told.has(String(r[0]).split(".").pop()) ? 0 : 1);
+  const ordered = told.size ? rows.map((r, i) => ({ r, i })).sort((a, b) => mine(a.r) - mine(b.r) || a.i - b.i).map((x) => x.r) : rows;
   const body = emit(
     "PreToolUse",
     `${clean(rel, 160)} holds many symbols; the most reached are ` +
-      rows.slice(0, WIDE_ROWS).map((r) => `${clean(r[0], 80)} ${Number(r[1]) || 0}-${Number(r[2]) || 0}`).join(" · ") +
+      ordered.slice(0, WIDE_ROWS).map((r) => `${clean(r[0], 80)} ${Number(r[1]) || 0}-${Number(r[2]) || 0}`).join(" · ") +
       `. The read below still runs; a later read of this file can name a range.`
   );
   ledger(runName, "hint", body, { low: 0, high: HINT_RANGE_TOKENS, calls_low: 0, calls_high: 1 });
@@ -442,9 +469,10 @@ function onWideRead(data, runName, meta) {
 // ── E4c — a Read of a file the extractor did not fully see ─────────────────
 // The ONLY case worth a line. A file the graph parsed whole needs no note, and
 // a note on every read would be the noise that gets a hook switched off.
-function onRead(data, runName, meta) {
+function onRead(data, runName, meta, readHint) {
   if (String(data.tool_name || "") !== "Read") return;
-  const abs = String((data.tool_input || {}).file_path || "");
+  const input = data.tool_input || {};
+  const abs = String(input.file_path || "");
   if (!abs) return;
   let rel;
   try {
@@ -454,6 +482,24 @@ function onRead(data, runName, meta) {
   }
   if (!rel || rel.startsWith("..")) return;
 
+  // R2 (v1.9.1) — COUNT, never say. A whole-file read of a wide file under
+  // `on` is a read the `on,read` hint would have named ranges for. The count is
+  // what the decision to arm that hint by default waits for (DE-8); nothing
+  // flips by itself. Under `on,read` the PreToolUse hint already fired, so the
+  // miss is zero and nothing is counted. Once per file per run, no context, no
+  // trace line.
+  if (!readHint && input.offset === undefined && input.limit === undefined) {
+    const wide = readJson(path.join(GRAPH_DIR, "wide.json"));
+    if (wide && wide.files && wide.generation === meta.generation && Object.prototype.hasOwnProperty.call(wide.files, rel)) {
+      if (bump(runName, "wide_unhinted", "wideu:" + rel))
+        ledger(runName, "wide-unhinted", "", { low: 0, high: 0, calls_low: 0, calls_high: 0 }, {
+          targets: [clean(rel, 160)],
+          gen: meta.generation,
+          paid: { card: 0, source: 0, hints: 0, envelope: 0 },
+        });
+    }
+  }
+
   const files = readJson(path.join(GRAPH_DIR, "files.json"));
   if (!files || !Object.prototype.hasOwnProperty.call(files, rel)) return;
   const entry = files[rel];

package/templates/hooks/orc-statusline.js

@@ -24,8 +24,8 @@
  * ICON carries the verdict and the words carry the installed ORC version — but
  * the degrade branch still names every reason, because a warning with no reason
  * is an emoji:
- *   ✅ ORC v1.2.1 - Opus 5/high          Opus 4.8 high (the baseline)
- *   🚀 ORC v1.2.1 - Opus 5/high          Opus 4.8 xhigh/max, or Opus 5 / Fable 5 medium…max
+ *   ✅ ORC v1.2.1 - Opus 5.5/high          Opus 4.8 high (the baseline)
+ *   🚀 ORC v1.2.1 - Opus 5.5/high          Opus 4.8 xhigh/max, or Opus 5.5 / Fable 5 medium…max
  *   ⛔ ORC v1.2.1 - Sonnet 5/high (why)  everything below (wrong model, sub-baseline effort, quota)
  *
  * The two lines, in full (v1.2.1):
@@ -52,7 +52,7 @@
  * This is the ONLY place Claude Code exposes the live model id, so it also
  * writes a fail-silent session-model bridge (.claude/orc/session-model.json)
  * that the PreToolUse effort guard reads — the guard can't see the model id
- * on its own, so the bridge is how the Opus 5 / Fable 5 medium-effort allowance
+ * on its own, so the bridge is how the Opus 5.5 / Fable 5 medium-effort allowance
  * reaches it.
  *
  * Also appends a "newer orc version available" hint from the 24h update cache
@@ -66,7 +66,7 @@
  * over that budget — ORC_STATUSLINE_SCAN_MS — and nothing in ORC ever sets it.
  */
 
-// Opus 4.8 / Opus 5 / Fable 5 are matched by tolerant regexes below (accept
+// Opus 4.8 / Opus 5.5 / Fable 5 are matched by tolerant regexes below (accept
 // dated/suffixed ids and the display name), not strict strings. Effort ranks give
 // the acceptance-matrix tiers (0 = unknown, never treated as a positive downgrade).
 const EFFORT_RANK = { low: 1, medium: 2, high: 3, xhigh: 4, max: 5 };
@@ -526,7 +526,7 @@ process.stdin.on("end", () => {
   // ── Session-model bridge (fail-silent) ─────────────────────────────────────
   // The PreToolUse effort guard cannot see the model id; it can only read
   // effort. Persist {model_id, effort, written_at} here so the guard can grant
-  // the Opus 5 / Fable 5 medium-effort allowance. The statusline re-renders constantly
+  // the Opus 5.5 / Fable 5 medium-effort allowance. The statusline re-renders constantly
   // while a session is active, so written_at stays fresh; the guard treats a
   // stale file (older than its freshness window) as absent and never blocks on
   // it. Any error (no dir, read-only fs) is swallowed — this is a nicety, not a
@@ -674,7 +674,7 @@ process.stdin.on("end", () => {
   const hay = `${model} ${display}`.toLowerCase();
   const isOpus48 = /opus[\s._-]?4[\s._-]?8\b/.test(hay);
   const isFable5 = /fable[\s._-]?5\b/.test(hay);
-  // Opus 5 (v0.34.0) — strictly above the baseline, so it boosts from medium up,
+  // Opus 5.5 (v0.34.0) — strictly above the baseline, so it boosts from medium up,
   // exactly like Fable 5. The `\b` keeps opus 4.8 / 4.7 out of this branch.
   const isOpus5 = /opus[\s._-]?5\b/.test(hay);
   const modelKnown = model !== "" || (display !== "" && display !== "unknown");