@mmerterden/multi-agent-pipeline 20.24.0 → 20.25.1

package/pipeline/scripts/_transcript-hosts.mjs

@@ -0,0 +1,406 @@
+/**
+ * @file _transcript-hosts.mjs  -  Copilot CLI and Codex session logs, read as
+ * the Claude Code records transcript-index.mjs already understands.
+ *
+ * Each host writes a different JSONL:
+ *
+ *   claude   ~/.claude/projects/<cwd slug>/<session>.jsonl: `type` user /
+ *            assistant / system, the message under `message`
+ *   copilot  ~/.copilot/session-state/<session>/events.jsonl: dotted event
+ *            types (`session.start`, `assistant.message`,
+ *            `tool.execution_complete`, ...), the body under `data`
+ *   codex    ~/.codex/sessions/YYYY/MM/DD/rollout-<time>-<session>.jsonl:
+ *            `type` session_meta / response_item / event_msg / compacted /
+ *            turn_context, the body under `payload`
+ *
+ * detectFormat() names the format from one record. createAdapter() returns a
+ * function that turns each record of a file into zero or more records in the
+ * Claude Code shape, so the indexer has one reading loop and every finding
+ * still cites the line of the file it came from. Two record kinds exist only
+ * here and are handled by the indexer directly:
+ *
+ *   x-usage   token use the host reports outside a message (Codex
+ *             token_count, Copilot CLI's shutdown totals)
+ *   a user record with `subagentStats`, carrying a background subagent's
+ *             tokens and duration with its completion notice
+ *
+ * A tool result may carry `denied: true` when the host marks a refusal with a
+ * code rather than a message.
+ *
+ * @module pipeline/scripts/_transcript-hosts
+ */
+
+const CODEX_TYPES = new Set([
+  "session_meta",
+  "response_item",
+  "event_msg",
+  "compacted",
+  "turn_context",
+]);
+
+/** "claude", "copilot" or "codex" for one parsed record. */
+export function detectFormat(rec) {
+  if (!rec || typeof rec !== "object") return "claude";
+  if (
+    typeof rec.type === "string" &&
+    rec.type.includes(".") &&
+    rec.data &&
+    typeof rec.data === "object"
+  )
+    return "copilot";
+  if (CODEX_TYPES.has(rec.type) && rec.payload && typeof rec.payload === "object") return "codex";
+  return "claude";
+}
+
+const asObject = (raw) => {
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) return raw;
+  if (typeof raw !== "string") return {};
+  try {
+    const v = JSON.parse(raw);
+    return v && typeof v === "object" && !Array.isArray(v) ? v : { arguments: raw };
+  } catch {
+    return { arguments: raw };
+  }
+};
+
+const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+
+/** A prompt as the indexer reads it: a leading slash command becomes a command record. */
+function promptRecord(timestamp, text) {
+  const t = String(text ?? "");
+  const slash = t.trim().match(/^(\/[^\s<]+)/);
+  const content = slash ? `<command-name>${slash[1]}</command-name>` : t;
+  return { type: "user", timestamp, message: { role: "user", content } };
+}
+
+const interrupt = (timestamp, reason) => ({
+  type: "user",
+  timestamp,
+  message: {
+    role: "user",
+    content: `[Request interrupted by user]${reason ? ` (${reason})` : ""}`,
+  },
+});
+
+const toolResult = (timestamp, id, body, isError, extra = {}) => ({
+  type: "user",
+  timestamp,
+  message: {
+    role: "user",
+    content: [
+      {
+        type: "tool_result",
+        tool_use_id: id,
+        content: body,
+        is_error: isError,
+        ...(extra.denied ? { denied: true } : {}),
+      },
+    ],
+  },
+  ...(extra.toolUseResult !== undefined ? { toolUseResult: extra.toolUseResult } : {}),
+});
+
+const notice = (timestamp, id, status, stats) => ({
+  type: "user",
+  timestamp,
+  message: {
+    role: "user",
+    content: `<task-notification><task-id>${id}</task-id><status>${status}</status></task-notification>`,
+  },
+  subagentStats: stats,
+});
+
+// --- Copilot CLI -----------------------------------------------------------------
+
+const COPILOT_SUBAGENT_TOOL = "task";
+const COPILOT_DENIAL_CODES = new Set(["denied", "rejected"]);
+
+function copilotAdapter() {
+  const toolNames = new Map();
+  const finished = new Map();
+  const counted = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  let shutdown = false;
+
+  const adapt = (rec) => {
+    const d = rec.data || {};
+    const ts = rec.timestamp;
+    switch (rec.type) {
+      case "user.message":
+        return [promptRecord(ts, d.content)];
+      case "assistant.message": {
+        const content = [];
+        if (typeof d.content === "string" && d.content.trim())
+          content.push({ type: "text", text: d.content });
+        for (const r of Array.isArray(d.toolRequests) ? d.toolRequests : []) {
+          if (!r || typeof r.name !== "string") continue;
+          if (r.toolCallId) toolNames.set(r.toolCallId, r.name);
+          content.push({
+            type: "tool_use",
+            id: r.toolCallId,
+            name: r.name,
+            input: asObject(r.arguments),
+          });
+        }
+        const out = num(d.outputTokens);
+        counted.output += out;
+        return [
+          {
+            type: "assistant",
+            timestamp: ts,
+            isSidechain: Boolean(d.parentToolCallId),
+            message: {
+              id: d.messageId,
+              role: "assistant",
+              content,
+              ...(d.outputTokens !== undefined ? { usage: { output_tokens: out } } : {}),
+            },
+          },
+        ];
+      }
+      case "tool.execution_complete": {
+        const ok = d.success !== false;
+        const body = ok
+          ? String(d.result?.content ?? "")
+          : String(d.error?.message ?? d.result?.content ?? "failed");
+        const denied = !ok && COPILOT_DENIAL_CODES.has(d.error?.code);
+        let toolUseResult;
+        if (toolNames.get(d.toolCallId) === COPILOT_SUBAGENT_TOOL) {
+          const stats = finished.get(d.toolCallId);
+          toolUseResult = stats
+            ? {
+                status: stats.status,
+                agentId: d.toolCallId,
+                totalTokens: stats.tokens,
+                totalDurationMs: stats.durationMs,
+                totalToolUseCount: stats.toolUses,
+              }
+            : { status: ok ? "async_launched" : "error", agentId: d.toolCallId };
+        }
+        return [toolResult(ts, d.toolCallId, body, !ok, { denied, toolUseResult })];
+      }
+      case "subagent.completed":
+      case "subagent.failed": {
+        const stats = {
+          status: rec.type === "subagent.failed" ? "failed" : "completed",
+          tokens: Number.isFinite(d.totalTokens) ? d.totalTokens : undefined,
+          durationMs: Number.isFinite(d.durationMs) ? d.durationMs : undefined,
+          toolUses: Number.isFinite(d.totalToolCalls) ? d.totalToolCalls : undefined,
+        };
+        finished.set(d.toolCallId, stats);
+        return [notice(ts, d.toolCallId, stats.status, stats)];
+      }
+      case "session.compaction_complete":
+        if (d.success === false)
+          return [{ type: "system", timestamp: ts, level: "error", content: "compaction failed" }];
+        return [
+          {
+            type: "system",
+            subtype: "compact_boundary",
+            timestamp: ts,
+            compactMetadata: { preTokens: d.preCompactionTokens },
+          },
+        ];
+      case "hook.end":
+        if (d.success !== false) return [];
+        return [
+          {
+            type: "system",
+            timestamp: ts,
+            hookErrors: [`${d.hookType || "hook"}: ${d.error?.message || "failed"}`],
+          },
+        ];
+      case "session.error":
+        return [
+          {
+            type: "system",
+            timestamp: ts,
+            level: "error",
+            content: `${d.errorType ? `${d.errorType}: ` : ""}${d.message || ""}`,
+          },
+        ];
+      case "abort":
+        return [interrupt(ts, d.reason)];
+      case "session.shutdown": {
+        shutdown = true;
+        const total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+        for (const m of Object.values(d.modelMetrics || {})) {
+          const u = m?.usage || {};
+          total.input += num(u.inputTokens);
+          total.output += num(u.outputTokens);
+          total.cacheRead += num(u.cacheReadTokens);
+          total.cacheWrite += num(u.cacheWriteTokens);
+        }
+        const add = {};
+        for (const k of Object.keys(total)) {
+          add[k] = Math.max(0, total[k] - counted[k]);
+          counted[k] += add[k];
+        }
+        return [
+          { type: "x-usage", timestamp: ts, usage: add, countsMessage: false, inTurn: false },
+        ];
+      }
+      default:
+        return [];
+    }
+  };
+  // Input and cache tokens arrive only in session.shutdown; without it the
+  // session's usage is its output tokens alone.
+  adapt.usagePartial = () => !shutdown;
+  return adapt;
+}
+
+// --- Codex -------------------------------------------------------------------------
+
+const EXIT_CODE = /(?:^|\n)(?:Process exited with code|Exit code:?)\s*(-?\d+)/;
+const WALL_TIME = /(?:^|\n)Wall time:\s*([\d.]+)\s*seconds?/;
+
+function codexOutput(raw) {
+  if (typeof raw === "string") {
+    try {
+      const v = JSON.parse(raw);
+      if (v && typeof v === "object" && !Array.isArray(v) && ("output" in v || "metadata" in v)) {
+        const meta = v.metadata || {};
+        return {
+          text: String(v.output ?? ""),
+          exitCode: Number.isFinite(meta.exit_code) ? meta.exit_code : null,
+          durationMs: Number.isFinite(meta.duration_seconds)
+            ? Math.round(meta.duration_seconds * 1000)
+            : null,
+        };
+      }
+    } catch {
+      // Plain text output.
+    }
+    const code = raw.match(EXIT_CODE);
+    const wall = raw.match(WALL_TIME);
+    return {
+      text: raw,
+      exitCode: code ? Number(code[1]) : null,
+      durationMs: wall ? Math.round(Number(wall[1]) * 1000) : null,
+    };
+  }
+  if (Array.isArray(raw)) {
+    const text = raw
+      .map((b) => (typeof b === "string" ? b : typeof b?.text === "string" ? b.text : ""))
+      .filter(Boolean)
+      .join("\n");
+    return codexOutput(text);
+  }
+  if (raw && typeof raw === "object") return codexOutput(raw.content ?? JSON.stringify(raw));
+  return { text: "", exitCode: null, durationMs: null };
+}
+
+function codexInput(name, raw) {
+  const input = asObject(raw);
+  for (const k of ["command", "cmd"]) {
+    if (Array.isArray(input[k])) return { ...input, [k]: input[k].join(" ") };
+  }
+  return input;
+}
+
+function codexAdapter() {
+  let lastTotal = null;
+
+  const toolUse = (ts, id, name, input) => ({
+    type: "assistant",
+    timestamp: ts,
+    message: { role: "assistant", content: [{ type: "tool_use", id, name, input }] },
+  });
+
+  return (rec) => {
+    const p = rec.payload || {};
+    const ts = rec.timestamp;
+    if (rec.type === "compacted")
+      return [{ type: "system", subtype: "compact_boundary", timestamp: ts, compactMetadata: {} }];
+    if (rec.type === "event_msg") {
+      switch (p.type) {
+        case "user_message":
+          return [promptRecord(ts, p.message)];
+        case "token_count": {
+          const info = p.info;
+          const total = info?.total_token_usage?.total_tokens;
+          if (!info || total === lastTotal) return [];
+          lastTotal = total;
+          const u = info.last_token_usage || {};
+          const cached = num(u.cached_input_tokens);
+          return [
+            {
+              type: "x-usage",
+              timestamp: ts,
+              usage: {
+                input: Math.max(0, num(u.input_tokens) - cached),
+                output: num(u.output_tokens),
+                cacheRead: cached,
+                cacheWrite: num(u.cache_write_input_tokens),
+              },
+              countsMessage: true,
+              inTurn: true,
+            },
+          ];
+        }
+        case "error":
+          return [{ type: "system", timestamp: ts, level: "error", content: p.message || "" }];
+        case "turn_aborted":
+          return [interrupt(ts, p.reason)];
+        default:
+          return [];
+      }
+    }
+    if (rec.type !== "response_item") return [];
+    switch (p.type) {
+      case "message":
+        if (p.role !== "assistant") return [];
+        return [
+          {
+            type: "assistant",
+            timestamp: ts,
+            message: {
+              role: "assistant",
+              content: (Array.isArray(p.content) ? p.content : [])
+                .filter((b) => typeof b?.text === "string")
+                .map((b) => ({ type: "text", text: b.text })),
+            },
+          },
+        ];
+      case "function_call":
+        return [toolUse(ts, p.call_id, p.name, codexInput(p.name, p.arguments))];
+      case "custom_tool_call":
+        return [toolUse(ts, p.call_id, p.name, { input: String(p.input ?? "") })];
+      case "local_shell_call":
+        return [toolUse(ts, p.call_id, "local_shell", codexInput("local_shell", p.action || {}))];
+      case "web_search_call":
+        return [toolUse(ts, undefined, "web_search", { query: p.action?.query ?? "" })];
+      case "function_call_output":
+      case "custom_tool_call_output": {
+        const out = codexOutput(p.output);
+        const failed = (out.exitCode !== null && out.exitCode !== 0) || p.output?.success === false;
+        return [
+          toolResult(ts, p.call_id, out.text, failed, {
+            toolUseResult: out.durationMs !== null ? { durationMs: out.durationMs } : undefined,
+          }),
+        ];
+      }
+      default:
+        return [];
+    }
+  };
+}
+
+/**
+ * The record converter for `format`: a function from one parsed record to the
+ * Claude Code records it stands for (often none). A Copilot CLI converter also
+ * has `usagePartial()`, true while the session has written no shutdown record.
+ */
+export function createAdapter(format) {
+  if (format === "copilot") return copilotAdapter();
+  if (format === "codex") return codexAdapter();
+  return (rec) => [rec];
+}
+
+/** The working directory a Copilot CLI or Codex session started in, from its opening record. */
+export function sessionCwd(rec) {
+  const format = detectFormat(rec);
+  if (format === "copilot" && rec.type === "session.start") return rec.data?.context?.cwd ?? null;
+  if (format === "codex" && rec.type === "session_meta") return rec.payload?.cwd ?? null;
+  return null;
+}

package/pipeline/scripts/build-stack-plugins.mjs

@@ -177,9 +177,9 @@ for (const skill of allSkills) {
 // --- 2b. routing audit ---------------------------------------------------
 // The loop above adds a skill to EVERY plugin whose pattern matches, so a bare
 // substring alternative that also reads as a suffix of another stack's skill
-// name ships that skill into two plugins. `architecture` did that to
-// android-architecture and swift-architecture, which is how ai-backend-toolkit
-// came to carry Compose and SwiftUI guidance.
+// name ships that skill into two plugins. A bare `architecture` matches
+// android-architecture and swift-architecture, and would put Compose and
+// SwiftUI guidance into ai-backend-toolkit.
 //
 // --check-routing runs this audit alone. It reads nothing but the authoring
 // source in this repo, so CI can gate it without a checkout of the plugins repo.

package/pipeline/scripts/capture-flush.sh

@@ -5,14 +5,14 @@
 #
 # WHY THIS EXISTS
 #
-# Every persistent write used to live in Phase 5: triage ingest, the learnings
-# ledger distill, the knowledge-base append, the code-graph refresh. And Phase 5
-# is, by the pipeline's own admission in features/code-graph.md, the phase a run
-# is LEAST likely to reach. A run killed in Phase 3, a session that hits its
-# context ceiling, a crash after review - each one threw away everything it had
-# established, and the next run on the same repo rediscovered it from scratch.
+# The persistent writes are triage ingest, the learnings ledger distill, the
+# knowledge-base append and the code-graph refresh. Phase 5 is, per
+# features/code-graph.md, the phase a run is LEAST likely to reach. A run killed
+# in Phase 3, a session that hits its context ceiling, a crash after review -
+# if the writes waited for Phase 5, each would throw away everything it had
+# established, and the next run on the same repo would rediscover it.
 #
-# So the writes move here, and Phase 5 becomes the LAST flush rather than the
+# So the writes happen here, and Phase 5 is the LAST flush rather than the
 # only one. Phase boundaries call this, and so does SessionEnd. Nothing about
 # the trigger depends on a model noticing that a moment qualifies: it hangs on
 # a phase transition and on process exit, both objectively visible without any

package/pipeline/scripts/code-graph-rules/android.json

@@ -110,5 +110,5 @@
     "Unit",
     "Any"
   ],
-  "note": "Kotlin declaration modifiers are not separate patterns: `data class Foo`, `sealed class Foo` and `annotation class Foo` all still contain `class Foo`, so one pattern covers them. `enum` allows an optional `class` between keyword and name, which is the only shape that differs between Java (`enum Foo`) and Kotlin (`enum class Foo`). `object` matches the named form only - `companion object {` and the anonymous `object : Iface {` carry no name and correctly produce nothing. Imports are fully qualified on the JVM, so the pattern captures the final segment: `import com.example.ui.Button` resolves against the file named Button.kt, which is how the engine links a file-level import edge. A star import (`import com.example.ui.*`) captures nothing, deliberately - it names a package, and pointing every star import at an arbitrary file in that package would invent an edge nobody wrote. Pattern ORDER is load-bearing: `enum class Cabin` matches both the enum pattern and the class pattern, and the first match to register the name decides its kind, so the more specific patterns are listed first. With class first, every Kotlin enum was filed as a class and the report's symbol-kind census was wrong."
+  "note": "Kotlin declaration modifiers are not separate patterns: `data class Foo`, `sealed class Foo` and `annotation class Foo` all still contain `class Foo`, so one pattern covers them. `enum` allows an optional `class` between keyword and name, which is the only shape that differs between Java (`enum Foo`) and Kotlin (`enum class Foo`). `object` matches the named form only - `companion object {` and the anonymous `object : Iface {` carry no name and correctly produce nothing. Imports are fully qualified on the JVM, so the pattern captures the final segment: `import com.example.ui.Button` resolves against the file named Button.kt, which is how the engine links a file-level import edge. A star import (`import com.example.ui.*`) captures nothing, deliberately - it names a package, and pointing every star import at an arbitrary file in that package would invent an edge nobody wrote. Pattern ORDER is load-bearing: `enum class Cabin` matches both the enum pattern and the class pattern, and the first match to register the name decides its kind, so the more specific patterns are listed first. With class first, every Kotlin enum would be filed as a class and the report's symbol-kind census would be wrong."
 }

package/pipeline/scripts/cost-analyze.mjs

@@ -168,30 +168,37 @@ const asNumber = (v, fallback) => {
 const TABLE = JSON.parse(readFileSync(join(HERE, "cost-table.json"), "utf-8"));
 
 /**
- * modelId -> rung. The transcripts carry the wire value ("claude-opus-5"); the
- * price table is keyed by rung. Matching on modelId rather than on the rung
- * name is what keeps a generation move a one-line data edit, which is the
- * contract cost-table.json states for itself.
+ * Wire ID -> rate. Transcripts carry the wire value ("claude-opus-5-5"); the
+ * price table is keyed by rung, so each rung's `modelId` and `copilotModelId`
+ * map to its rate, `legacy` adds previous-generation IDs at their own rates,
+ * and `models` overrides the rung rate for a dispatched ID whose model is not
+ * the rung's (Copilot CLI's older models bill at their own rate). Matching on
+ * the ID rather than the rung name keeps a generation move a data edit, which
+ * is the contract cost-table.json states for itself.
  */
-const RUNG_BY_MODEL_ID = new Map(
-  Object.entries(TABLE.prices || {}).map(([rung, p]) => [p.modelId, rung]),
-);
+const RATE_BY_MODEL_ID = new Map([
+  ...Object.entries(TABLE.legacy || {}),
+  ...Object.values(TABLE.prices || {}).flatMap((p) =>
+    [p.modelId, p.copilotModelId].filter(Boolean).map((id) => [id, p]),
+  ),
+  ...Object.entries(TABLE.models || {}),
+]);
+const IDS_LONGEST_FIRST = [...RATE_BY_MODEL_ID.keys()].sort((a, b) => b.length - a.length);
 
 function rateFor(modelId) {
   if (!modelId) return null;
-  const rung = RUNG_BY_MODEL_ID.get(modelId);
-  if (rung) return TABLE.prices[rung];
-  // A dated snapshot id (an alias plus a release date suffix) prices as its
-  // alias - written as a shape rather than as a literal, because
+  const exact = RATE_BY_MODEL_ID.get(modelId);
+  if (exact) return exact;
+  // A dated snapshot id (a known id, a hyphen, a release date) prices as that
+  // id; the longest known id wins, so a current id is never read as a shorter
+  // legacy one. Written as a shape rather than as a literal, because
   // smoke-model-fallback.sh reads every model id in this tree and requires it
-  // to exist in cost-table.json, and an EXAMPLE id is exactly the kind of thing
-  // that would make that gate wrong about what ships. An
-  // id nobody knows prices as nothing and is COUNTED as unpriced rather than
-  // folded in at zero.
-  for (const [id, rung] of RUNG_BY_MODEL_ID) {
-    if (modelId.startsWith(id)) return TABLE.prices[rung];
-  }
-  return null;
+  // to exist in cost-table.json. An id nobody knows prices as nothing and is
+  // COUNTED as unpriced rather than folded in at zero.
+  const id = IDS_LONGEST_FIRST.find(
+    (known) => modelId.startsWith(`${known}-`) || modelId.startsWith(`${known}[`),
+  );
+  return id ? RATE_BY_MODEL_ID.get(id) : null;
 }
 
 /**

package/pipeline/scripts/cost-table.json

@@ -1,38 +1,54 @@
 {
-  "_readme": "Per-model unit prices in USD per million tokens. Source: Anthropic public pricing (Claude-family rows verified 2026-07-28 against the current model table; the gpt-* rows remain approximate). Update when Anthropic publishes new tiers. Rung names (fable / opus / sonnet / haiku) are the pipeline's stable identifiers and `modelId` is the wire value they currently resolve to - dispatch reads the rung, so a generation move is a `modelId` edit here plus the phase specs, never a rename of the rungs. `provider` says which layer a rung belongs to: an `anthropic` rung is reachable from every call site; `free-chain` (the `free` rung) only from bulk-read and delegate, where the multi-agent-toolkit's verified free-model chain answers and the caller's default takes over when it escalates; any other provider from no call site. model-dispatch.sh enforces this. Unknown models render USD as ' - ' and emit a footnote  -  never block PR-body generation. cacheReadPerMtok is the discounted rate for prompt-cache hits (~10% of inPerMtok); the renderer prices a phase's tokens_cached at this rate when the tracker records it, so resume/cache reuse is visible in the ledger.",
+  "_readme": "Per-model unit prices in USD per million tokens. Source: Anthropic public pricing (Claude-family rows verified 2026-10-14 against the current model table; the gpt-* rows remain approximate). Update when Anthropic publishes new tiers. Rung names (fable / opus / sonnet / haiku) are the pipeline's stable identifiers and `modelId` is the wire value they currently resolve to - dispatch reads the rung, so a generation move is a `modelId` edit here plus the phase specs, never a rename of the rungs. `copilotModelId`, where present, is the name Copilot CLI dispatches for the rung: one of the dotted IDs `copilot help config` lists (Copilot rejects any other as not available), the newest of the rung's family there. A rung without one (fable) is not offered on Copilot CLI, where its personas take the opus rung. smoke-model-fallback.sh checks the IDs against `copilot help config` when the CLI is installed. `provider` says which layer a rung belongs to: an `anthropic` rung is reachable from every call site; `free-chain` (the `free` rung) only from bulk-read and delegate, where the multi-agent-toolkit's verified free-model chain answers and the caller's default takes over when it escalates; any other provider from no call site. model-dispatch.sh enforces this. Unknown models render USD as ' - ' and emit a footnote  -  never block PR-body generation. cacheReadPerMtok is the discounted rate for prompt-cache hits, published per model and well below inPerMtok; the renderer prices a phase's tokens_cached at this rate when the tracker records it, so resume/cache reuse is visible in the ledger.",
   "schemaVersion": "1.1.0",
+  "_legacyReadme": "`legacy` prices previous-generation wire IDs a transcript may still name, keyed by the exact ID (a dated snapshot of one prices as it). Dispatch never reads it; cost-analyze consults it after the current `modelId` values and the `models` map. Official Anthropic prices per million tokens.",
+  "legacy": {
+    "claude-fable-5": { "inPerMtok": 10.0, "outPerMtok": 50.0, "cacheReadPerMtok": 1.0 },
+    "claude-opus-5": { "inPerMtok": 5.0, "outPerMtok": 25.0, "cacheReadPerMtok": 0.5 },
+    "claude-sonnet-5": { "inPerMtok": 2.0, "outPerMtok": 10.0, "cacheReadPerMtok": 0.2 },
+    "claude-haiku-4-5": { "inPerMtok": 1.0, "outPerMtok": 5.0, "cacheReadPerMtok": 0.1 }
+  },
+  "_modelsReadme": "`models` prices wire IDs a rung dispatches whose model is not the rung's `modelId`: Copilot CLI's `copilotModelId` values name an older model than the rung's, billed at that model's own rate. Keyed by the exact ID; cost-analyze consults it before the rung rates, so a Copilot CLI session is priced at its own model. Official Anthropic prices per million tokens, verified 2026-10-14.",
+  "models": {
+    "claude-opus-4.7": { "inPerMtok": 5.0, "outPerMtok": 25.0, "cacheReadPerMtok": 0.5 },
+    "claude-sonnet-4.6": { "inPerMtok": 3.0, "outPerMtok": 15.0, "cacheReadPerMtok": 0.3 },
+    "claude-haiku-4.5": { "inPerMtok": 1.0, "outPerMtok": 5.0, "cacheReadPerMtok": 0.1 }
+  },
   "prices": {
     "fable": {
       "inPerMtok": 10.0,
       "outPerMtok": 50.0,
-      "cacheReadPerMtok": 1.0,
-      "modelId": "claude-fable-5",
+      "cacheReadPerMtok": 0.25,
+      "modelId": "claude-fable-5-1",
       "provider": "anthropic",
-      "note": "Top tier (restored v10.6.0)  -  architects, Reviewer 1, triage. Verified against Anthropic pricing 2026-07-02."
+      "note": "Top tier - architects, Reviewer 1 and triage on Claude Code. Claude Fable 5.1, verified against Anthropic pricing 2026-10-14."
     },
     "opus": {
-      "inPerMtok": 5.0,
-      "outPerMtok": 25.0,
-      "cacheReadPerMtok": 0.5,
-      "modelId": "claude-opus-5",
+      "inPerMtok": 4.0,
+      "outPerMtok": 20.0,
+      "cacheReadPerMtok": 0.2,
+      "modelId": "claude-opus-5-5",
+      "copilotModelId": "claude-opus-4.7",
       "provider": "anthropic",
-      "note": "Second tier - Reviewer 1 and triage on Copilot CLI, and the opus rung of the fable -> opus -> sonnet fallback ladder. Same rate as the Opus 4.8 it replaces, so the ledger needed no reprice on the generation move. Claude Opus 5 draws on a rate-limit pool SEPARATE from the combined Opus 4.x pool - moving traffic here neither frees headroom on the old bucket nor inherits it."
+      "note": "Second tier - Reviewer 2 on Claude Code, Reviewer 1 and triage on Copilot CLI, and the opus rung of the fable -> opus -> sonnet fallback ladder. Claude Opus 5.5, verified against Anthropic pricing 2026-10-14."
     },
     "sonnet": {
-      "inPerMtok": 3.0,
-      "outPerMtok": 15.0,
-      "cacheReadPerMtok": 0.3,
-      "modelId": "claude-sonnet-5",
+      "inPerMtok": 2.0,
+      "outPerMtok": 10.0,
+      "cacheReadPerMtok": 0.1,
+      "modelId": "claude-sonnet-5-5",
+      "copilotModelId": "claude-sonnet-4.6",
       "provider": "anthropic",
-      "note": "Floor tier for Claude-family dispatch - Reviewer 3 on both hosts, and the terminal rung of the fallback ladder. Priced at the standard 3/15 rather than the 2/10 introductory rate that runs through 2026-08-31: over-reporting during the intro window is the safe direction for a cost ledger, and it needs no dated edit when the intro ends."
+      "note": "Floor tier for Claude-family dispatch - Reviewer 3 on both hosts, the dev phase, and the terminal rung of the fallback ladder. Claude Sonnet 5.5, verified against Anthropic pricing 2026-10-14."
     },
     "haiku": {
-      "inPerMtok": 1.0,
-      "outPerMtok": 5.0,
-      "cacheReadPerMtok": 0.1,
-      "modelId": "claude-haiku-4-5",
+      "inPerMtok": 0.5,
+      "outPerMtok": 2.5,
+      "cacheReadPerMtok": 0.05,
+      "modelId": "claude-haiku-5-5",
+      "copilotModelId": "claude-haiku-4.5",
       "provider": "anthropic",
-      "note": "Speed tier - task-clarifier and other latency-sensitive dispatches, plus the terminal rung of the fallback ladder. Named by its alias like every other rung here rather than by a dated snapshot, so the four rungs stay comparable at a glance."
+      "note": "Speed tier - task-clarifier and other latency-sensitive dispatches, plus the terminal rung of the fallback ladder. Claude Haiku 5.5 is priced in two tiers by prompt length (in 0.10, cache-read 0.01, out 0.50 up to 100k input tokens; in 0.50, cache-read 0.05, out 2.50 above); this table holds one rate per rung, so it carries the over-100k tier: over-reporting is the safe direction for a cost ledger. Verified against Anthropic pricing 2026-10-14."
     },
     "gpt-5.4": {
       "inPerMtok": 10.0,