sprag-cli 3.56.0 → 3.57.0

package/src/codex-hooks.js

@@ -11,7 +11,7 @@ import { findProjectRoot } from './harness.js';
 import { runCodexBrief } from './codex-brief.js';
 import { codexDocumentTool, codexDocumentNote, convertCodexDocument } from './codex-doc2md.js';
 import { codexDelegationTool, codexRouteHint } from './codex-delegation.js';
-import { bindCodexSubagent } from './codex-ledger.js';
+import { bindCodexSubagent, closeStaleCodexRoutes, unsettledCodexRoutes } from './codex-ledger.js';
 import { seedOfferBlock } from './seed-rules.js';
 import { readCodexRouteScan, openCodexCandidates, shouldRescanCodex } from './codex-route-scan.js';
 import { userDataDir } from './paths.js';
@@ -120,6 +120,20 @@ function defaultRescan() {
     { detached: true, stdio: 'ignore', windowsHide: true }).unref();
 }
 
+/**
+ * Prices the delegated runs the ledger has not joined yet, in a detached
+ * process. The ledger was refreshed only by the route scan, which the rescan
+ * gate holds back for up to a day, so "Routing saved" showed a delegation that
+ * long after it happened. Claude's side has the same shortcut on its
+ * PostToolUse hook; Codex has no hook for a finished child, so the next prompt
+ * of the parent is the earliest point that knows one was spawned.
+ */
+function defaultLedgerRefresh() {
+  if (process.env.CTS_NO_ROUTE_SCAN === '1') return;
+  spawn(process.execPath, [process.argv[1], 'route-scan', 'savings', '--refresh', '--quiet', '--agent', 'codex'],
+    { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+}
+
 export function lintCodexTool(payload, { scope = 'all' } = {}) {
   if (!payload || typeof payload !== 'object') return null;
   const input = payload.tool_input;
@@ -148,7 +162,7 @@ export function lintCodexTool(payload, { scope = 'all' } = {}) {
   return messages.length ? messages.join('\n\n') : null;
 }
 
-export async function codexHookOutput(event, payload, { cfg = loadConfig() } = {}) {
+export async function codexHookOutput(event, payload, { cfg = loadConfig(), refreshLedger = defaultLedgerRefresh } = {}) {
   if (!payload || typeof payload !== 'object') return null;
   if (event === 'session-start' || event === 'subagent-start') {
     if (event === 'subagent-start' && cfg?.codex?.delegate !== true) return null;
@@ -193,13 +207,20 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig() } = {
   if (event === 'prompt') {
     const parts = [];
     if (cfg?.codex?.delegate === true) {
+      // Before the hint for this prompt is recorded: a hint from an earlier turn
+      // that no child claimed is closed, and children that did run get priced.
+      try { closeStaleCodexRoutes(payload); } catch (e) { debug('codex:close-routes', e); }
+      try { if (unsettledCodexRoutes() > 0) refreshLedger(); } catch (e) { debug('codex:ledger-refresh', e); }
       try {
         parts.push(codexRouteHint(payload, { root: findProjectRoot(payload.cwd || process.cwd(), { agent: 'codex' }),
           minContext: Number.isFinite(cfg?.codex?.delegateMinContext) ? cfg.codex.delegateMinContext : undefined }));
       } catch (e) { debug('codex:route-hint', e); }
     }
     if (cfg?.codex?.brief !== false) {
-      try { parts.push(runCodexBrief({ sessionId: payload.session_id, transcriptPath: payload.transcript_path, cwd: payload.cwd })); }
+      try {
+        parts.push(runCodexBrief({ sessionId: payload.session_id, transcriptPath: payload.transcript_path, cwd: payload.cwd,
+          root: findProjectRoot(payload.cwd || process.cwd(), { agent: 'codex' }) }));
+      }
       catch (e) { debug('codex:brief', e); }
     }
     if (process.env.CTS_NO_DOC2MD !== '1' && cfg?.codex?.doc2md !== false) {

package/src/codex-ledger.js

@@ -87,19 +87,57 @@ export function readCodexBindings({ dir = userDataDir() } = {}) {
   return out;
 }
 
+/** Route ids a later prompt closed before any child claimed them. Kept in the binds file as `{ id, closed: true }` lines. */
+function closedCodexRouteIds({ dir = userDataDir() } = {}) {
+  let text;
+  try { text = readFileSync(bindsFile(dir), 'utf8'); } catch { return new Set(); }
+  const out = new Set();
+  for (const line of text.split('\n')) {
+    try {
+      const b = JSON.parse(line);
+      if (b?.closed === true && /^[0-9a-f]{16}$/.test(b.id)) out.add(b.id);
+    } catch { /* Partial trailing line. */ }
+  }
+  return out;
+}
+
+/**
+ * Close the routes this parent was hinted in an earlier turn and never spawned.
+ *
+ * A hint asks for a spawn in the turn that carries it. Left open, its pending
+ * record kept matching for the whole bind window, so a child the parent spawned
+ * for an unrelated reason twenty minutes later, on the same model, was bound to
+ * it and its cost was booked as a routing saving. A new prompt from the user is
+ * what ends the hinted turn, so that is where the record is closed. Returns how
+ * many were closed; writes nothing when there are none.
+ */
+export function closeStaleCodexRoutes(payload, { dir = userDataDir(), now = Date.now() } = {}) {
+  if (typeof payload?.session_id !== 'string') return 0;
+  const sameTurn = (r) => typeof payload.turn_id === 'string' && r.turnId === payload.turn_id;
+  const open = readCodexDelegations({ dir }).filter((r) =>
+    r.via === 'prompt' && r.parentSessionId === payload.session_id && now - r.at < BIND_TTL_MS && !sameTurn(r));
+  if (!open.length) return 0;
+  const taken = new Set([...readCodexBindings({ dir }).map((b) => b.id), ...closedCodexRouteIds({ dir })]);
+  const stale = open.filter((r) => !taken.has(r.id));
+  for (const r of stale) appendFileSync(bindsFile(dir), JSON.stringify({ id: r.id, closed: true, at: now }) + '\n', { mode: 0o600 });
+  return stale.length;
+}
+
 /**
  * Bind a just-spawned SubagentStart child to the pending route it most likely
  * fulfills: same parent thread, same target model, recent enough, and not
- * already claimed by another child. Returns the bound route id, or null when
- * nothing matches or this child is already bound.
+ * already claimed by another child or closed by a later prompt. When both the
+ * record and the payload name a turn, the turns must agree. Returns the bound
+ * route id, or null when nothing matches or this child is already bound.
  */
 export function bindCodexSubagent(payload, { dir = userDataDir(), now = Date.now() } = {}) {
   if (typeof payload?.agent_id !== 'string' || typeof payload?.session_id !== 'string' || typeof payload?.model !== 'string') return null;
   const binds = readCodexBindings({ dir });
   if (binds.some((b) => b.childSessionId === payload.agent_id)) return null;
-  const boundIds = new Set(binds.map((b) => b.id));
+  const boundIds = new Set([...binds.map((b) => b.id), ...closedCodexRouteIds({ dir })]);
+  const otherTurn = (r) => typeof payload.turn_id === 'string' && typeof r.turnId === 'string' && r.turnId !== payload.turn_id;
   const pending = readCodexDelegations({ dir }).filter((r) =>
-    r.parentSessionId === payload.session_id && r.to === payload.model && now - r.at < BIND_TTL_MS && !boundIds.has(r.id));
+    r.parentSessionId === payload.session_id && r.to === payload.model && now - r.at < BIND_TTL_MS && !boundIds.has(r.id) && !otherTurn(r));
   if (!pending.length) return null;
   // Oldest first: spawns are recorded in order, so the earliest unbound record belongs to the earliest child.
   const chosen = pending.reduce((a, b) => (b.at < a.at ? b : a));
@@ -107,6 +145,22 @@ export function bindCodexSubagent(payload, { dir = userDataDir(), now = Date.now
   return chosen.id;
 }
 
+/**
+ * How many bound routes the ledger has not finished pricing. A child was
+ * spawned for each, so its saving exists but is not in the ledger until the
+ * next refresh, and the route scan that refreshes it runs at most daily when
+ * little new data arrives. Callers use a non-zero count to refresh now. Bound
+ * within the bind window only: a child still running after that settles at the
+ * regular scan.
+ */
+export function unsettledCodexRoutes({ dir = userDataDir(), now = Date.now() } = {}) {
+  const recent = readCodexBindings({ dir }).filter((b) => now - b.at < BIND_TTL_MS);
+  if (!recent.length) return 0;
+  const pending = new Set(readCodexDelegations({ dir }).filter((r) => now - r.at < PENDING_TTL_MS).map((r) => r.id));
+  const events = loadCodexLedger({ dir }).events;
+  return recent.filter((b) => pending.has(b.id) && !(events[b.id]?.complete || events[b.id]?.aborted)).length;
+}
+
 export function loadCodexLedger({ dir = userDataDir() } = {}) {
   try {
     const data = JSON.parse(readFileSync(ledgerFile(dir), 'utf8'));
@@ -195,7 +249,9 @@ export async function refreshCodexLedger({ dir = userDataDir(), home, now = Date
     const usd = actual === null || counterfactual === null ? null : roundUsd(run.aborted ? -actual : counterfactual - actual);
     const event = { ts: run.endedAt ?? route.at, parentSessionId: route.parentSessionId || run.parentThreadId || null,
       childSessionId: run.sessionId, source: route.source, category: route.category ?? null, scope: route.scope ?? null,
-      from: route.from, to, provider, tokens: run.tokens, calls: run.calls, toolErrors: run.toolErrors, usd, rates: usd === null ? null : rates,
+      from: route.from, to, provider,
+      ...(route.targetRoot !== undefined ? { targetRoot: route.targetRoot } : {}),
+      ...(route.ruleCreatedAt !== undefined ? { ruleCreatedAt: route.ruleCreatedAt } : {}), tokens: run.tokens, calls: run.calls, toolErrors: run.toolErrors, usd, rates: usd === null ? null : rates,
       priceCheckedAt: rates?.checkedAt ?? null, priceSource, complete: run.complete, ...(run.aborted ? { aborted: true } : {}) };
     // A transient price outage must not erase a completed, unchanged priced run.
     if (usd === null && sameRun && previous.complete && Number.isFinite(previous.usd) &&

package/src/codex-panel.js

@@ -1,4 +1,4 @@
-import { resolve, relative, isAbsolute } from 'node:path';
+import { resolve, relative, isAbsolute, basename } from 'node:path';
 import { realpathSync, statSync } from 'node:fs';
 import { stat } from 'node:fs/promises';
 import { readPanelBinding } from './codex-panel-session.js';
@@ -17,7 +17,9 @@ import { formatResetIn } from './format-time.js';
 import { codexDocumentTotals } from './codex-doc2md-ledger.js';
 import { codexHookStatus } from './codex-installer.js';
 import { koreanStyleEnabled } from './korean-style.js';
-import { codexRoutingSavedTotals } from './codex-ledger.js';
+import { codexRoutingSavedTotals, loadCodexLedger } from './codex-ledger.js';
+import { loadCodexModelRules } from './codex-delegation.js';
+import { codexRulesInReview } from './codex-rule-health.js';
 import { readCodexRouteScan, openCodexCandidates } from './codex-route-scan.js';
 import { codexBudgetProvider } from './codex-budget.js';
 
@@ -64,29 +66,41 @@ export function createPanelReader({ root = process.cwd(), home, sessionId: pinne
     files ??= sessionFile && !sessionId ? [] : await discoverCodexSessionFiles({ home, days: sessionId ? Infinity : days });
     const existing = new Set(files.map((f) => f.path));
     for (const path of cache.keys()) if (!existing.has(path)) cache.delete(path);
+    // A rollout is named after its session id. With an id to look for, the
+    // files carrying it are parsed first; without this the first frame of a
+    // pinned panel parsed every rollout Codex has ever written to find one
+    // session. The full search still runs when no file by that name holds the
+    // session (a renamed rollout).
+    const named = sessionId ? files.filter((f) => basename(f.path).includes(sessionId)) : [];
+    const passes = named.length && named.length < files.length ? [named, files] : [files];
     let selected = null;
     let matches = 0;
-    const seen = new Set();
     // Recent rollouts of the same project, for repeats across `codex exec` runs.
-    const recent = [];
-    for (const f of files.slice().reverse()) {
-      let entry = cache.get(f.path);
-      if (!entry || entry.mtime !== f.mtime || entry.size !== f.size) {
-        try {
-          entry = { ...f, session: await parseCodexSessionFile(f.path) };
-          cache.set(f.path, entry);
-        } catch { continue; }
+    let recent = [];
+    for (const pass of passes) {
+      if (selected) break;
+      matches = 0;
+      recent = [];
+      const seen = new Set();
+      for (const f of pass.slice().reverse()) {
+        let entry = cache.get(f.path);
+        if (!entry || entry.mtime !== f.mtime || entry.size !== f.size) {
+          try {
+            entry = { ...f, session: await parseCodexSessionFile(f.path) };
+            cache.set(f.path, entry);
+          } catch { continue; }
+        }
+        const s = entry.session;
+        if ((!sessionId || sessionFile) && s.isSubagent) continue;
+        if (sessionId ? s.sessionId !== sessionId : !insideProject(root, s.projectDir)) continue;
+        const key = s.sessionId || s.filePath;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        matches++;
+        if (!sessionId && Date.now() - f.mtime < RATCHET_SIBLING_MS) recent.push(s.filePath);
+        // Activity timestamps survive archive moves that update filesystem mtime.
+        if (!selected || (s.lastActivity?.getTime() || 0) > (selected.lastActivity?.getTime() || 0)) selected = s;
       }
-      const s = entry.session;
-      if ((!sessionId || sessionFile) && s.isSubagent) continue;
-      if (sessionId ? s.sessionId !== sessionId : !insideProject(root, s.projectDir)) continue;
-      const key = s.sessionId || s.filePath;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      matches++;
-      if (!sessionId && Date.now() - f.mtime < RATCHET_SIBLING_MS) recent.push(s.filePath);
-      // Activity timestamps survive archive moves that update filesystem mtime.
-      if (!selected || (s.lastActivity?.getTime() || 0) > (selected.lastActivity?.getTime() || 0)) selected = s;
     }
     const project = selected?.projectDir ? findProjectRoot(selected.projectDir, { agent: 'codex' }) : root;
     const cfg = loadConfig();
@@ -102,11 +116,16 @@ export function createPanelReader({ root = process.cwd(), home, sessionId: pinne
     }
     let route = [];
     try { route = openCodexCandidates(readCodexRouteScan(), { root: project }); } catch { /* No scan yet. */ }
+    let ruleReview = [];
+    try {
+      const modelRules = loadCodexModelRules();
+      if (modelRules.length) ruleReview = codexRulesInReview({ root: project, rules: modelRules, events: Object.values(loadCodexLedger().events) }).map((r) => r.index);
+    } catch { /* Unreadable rules or ledger show no chip. */ }
     let routingSaved = null;
     try { routingSaved = { ...codexRoutingSavedTotals(), pricesAvailable: isDirectOpenAI(selected?.provider, home ? { home } : {}) || !!readCodexPrices({ provider: codexBudgetProvider(home ? { home } : {}), ...(home ? { home } : {}) }) }; }
     catch { /* Unreadable ledger reads as n/a. */ }
     return { session: selected, matches, root, sessionId, selection, bindingPending: !!sessionFile && !sessionId, days, harness, rules,
-      ratchet: ratchetFor(selected, recent.filter((file) => file !== selected?.filePath)), route, routingSaved,
+      ratchet: ratchetFor(selected, recent.filter((file) => file !== selected?.filePath)), route, ruleReview, routingSaved,
       labelMode: resolveLabelMode({ cfg: statuslineDefaults(), hasFlag }).mode,
       color: statuslineDefaults().color,
       timer: !hasFlag('--no-timer') && (hasFlag('--timer') || statuslineDefaults().timer),
@@ -266,6 +285,7 @@ function panelGroups(data, { now, version = '', full = false, mode = full ? 'tex
     chip(`Ratchet ${data.rules?.global ?? '?'}/${data.rules?.project ?? '?'}`),
     // A repeated failure outranks a delegation candidate, as in the Claude statusline.
     data.ratchet?.length ? chip(`ratchet? #${data.ratchet[0].id} x${data.ratchet[0].count}`, 33) : null,
+    data.ruleReview?.length ? chip(`rule-health #${data.ruleReview[0]}${data.ruleReview.length > 1 ? ` +${data.ruleReview.length - 1}` : ''}`, 33) : null,
     data.route?.length ? chip(`route? R${data.route[0].id} ${terminalText(data.route[0].category)}${data.route.length > 1 ? ` +${data.route.length - 1}` : ''}`, 33) : null,
   ]);
   register('korean', 'preferences', [

package/src/codex-rule-health.js

@@ -1,3 +1,4 @@
+import { resolve } from 'node:path';
 import { loadCodexLedger } from './codex-ledger.js';
 import { isFailedRun } from './route-scan.js';
 import { wilsonLowerBound, HEALTH_ERR_RATE, HEALTH_MIN_SAMPLE_DELEGATED } from './model-rules.js';
@@ -9,10 +10,32 @@ import { wilsonLowerBound, HEALTH_ERR_RATE, HEALTH_MIN_SAMPLE_DELEGATED } from '
  * lower bound of the failure rate clears HEALTH_ERR_RATE over enough runs.
  */
 export function codexRuleHealth(rule, { events = Object.values(loadCodexLedger().events) } = {}) {
+  const since = Date.parse(rule.createdAt);
   const runs = events.filter((e) => e && e.category === rule.category && e.from === rule.from && e.to === rule.model &&
-    (!rule.provider || !e.provider || e.provider === rule.provider) && (e.complete || e.aborted));
+    (!rule.provider || !e.provider || e.provider === rule.provider) && (e.complete || e.aborted) &&
+    (e.scope == null || e.scope === rule.scope) &&
+    // A project run counts only for the project it was recorded in; events from before the field existed cannot be placed.
+    (rule.scope !== 'project' || (typeof e.targetRoot === 'string' && e.targetRoot === rule.targetRoot)) &&
+    // A rule deleted and added again starts a fresh record.
+    (!Number.isFinite(since) || (Number.isFinite(e.ts) && e.ts >= since)));
   const errs = runs.filter((e) => e.aborted || isFailedRun({ toolErrors: e.toolErrors, calls: e.calls })).length;
   const saved = runs.filter((e) => Number.isFinite(e.usd)).reduce((sum, e) => sum + e.usd, 0);
   const review = runs.length >= HEALTH_MIN_SAMPLE_DELEGATED && wilsonLowerBound(errs, runs.length) > HEALTH_ERR_RATE;
   return { runs: runs.length, errs, rate: runs.length ? errs / runs.length : 0, saved, status: review ? 'review' : 'active' };
 }
+
+/**
+ * Rules in review that apply to the project at `root`: global rules, and
+ * project rules whose targetRoot is `root`; a null `root` lists every rule. `index` is the 1-based number the
+ * rule has in `delegate rules --agent codex`, so every surface names it alike.
+ */
+export function codexRulesInReview({ root, rules, events }) {
+  const here = root ? resolve(root) : null;
+  const out = [];
+  (rules || []).forEach((rule, i) => {
+    if (here && rule.scope === 'project' && rule.targetRoot !== here) return;
+    const health = codexRuleHealth(rule, { events });
+    if (health.status === 'review') out.push({ index: i + 1, rule, health });
+  });
+  return out;
+}

package/src/commands/brief.js

@@ -25,7 +25,10 @@ export async function run({ hasFlag }) {
     const parts = [];
     try {
       const { runBrief } = await import('../brief.js');
-      const out = await runBrief({ sessionId: ctx.session_id, transcriptPath: ctx.transcript_path });
+      // `root` is the session's cwd for the same reason routeHint takes it below:
+      // the settings that name the model and the compaction window are the
+      // project's, not those of whatever directory the hook was spawned in.
+      const out = await runBrief({ sessionId: ctx.session_id, transcriptPath: ctx.transcript_path, root: ctx.cwd || process.cwd() });
       if (out) parts.push(out);
     } catch (e) { debug('brief:hook', e); /* briefing is best-effort — never block a prompt */ }
     // State the matching delegation rule as a fact about this request. Registered
@@ -34,7 +37,7 @@ export async function run({ hasFlag }) {
     // the match here removes both steps. Silent unless it is sure — see
     // src/route-inject.js.
     try {
-      const { routeHint, sessionModelRank } = await import('../route-inject.js');
+      const { routeHint, routeMatch, matchCaps, sessionModelRank } = await import('../route-inject.js');
       // The payload names the session but not its model, so the rank comes from
       // the transcript: without it a Sonnet session is told to delegate to
       // Sonnet, which saves nothing.
@@ -46,8 +49,16 @@ export async function run({ hasFlag }) {
       // differ. Claude Code sends `cwd` for that reason and the PreToolUse hook
       // already reads it (src/delegation-guard.js). A payload without the field
       // leaves root undefined, which is the behaviour this had before.
-      const hint = routeHint(ctx.prompt, { sessionRank, root: ctx.cwd });
+      const match = routeMatch(ctx.prompt, { sessionRank });
+      const hint = routeHint(ctx.prompt, { sessionRank, root: ctx.cwd, match });
       if (hint) parts.push(hint);
+      // The delegation guard repeats these caps to the subagent, so the limit it
+      // works under is the one this hint states. A prompt with no match clears
+      // the record of the turn before it.
+      try {
+        const { recordRouteCaps } = await import('../route-caps.js');
+        recordRouteCaps(ctx.session_id, matchCaps(match));
+      } catch (e) { debug('brief:route-caps', e); }
     } catch (e) { debug('brief:route-hint', e); }
     if (parts.length) console.log(parts.join('\n'));
     return;

package/src/commands/codex-delegate.js

@@ -3,7 +3,7 @@ import { configureCodexHooks } from '../codex-installer.js';
 import { validateCodexTarget, loadCodexModelRules, addCodexModelRule, removeCodexModelRule } from '../codex-delegation.js';
 import { findCodexCandidate, resolveCodexCandidate } from '../codex-route-scan.js';
 import { codexRoutingSavedTotals, loadCodexLedger } from '../codex-ledger.js';
-import { codexRuleHealth } from '../codex-rule-health.js';
+import { codexRuleHealth, codexRulesInReview } from '../codex-rule-health.js';
 import { signedUsd } from '../money.js';
 import { codexProviderName } from '../agent.js';
 
@@ -15,7 +15,6 @@ export function run({ args, getArg, hasFlag, root }) {
       throw new Error(`${flag} requires a value.`);
     }
   }
-  const rules = loadCodexModelRules();
   if (sub === 'rules') {
     if (args[2] === 'add') {
       if (hasFlag('--global') === hasFlag('--project')) throw new Error('Choose --global or --project for the rule.');
@@ -35,10 +34,11 @@ export function run({ args, getArg, hasFlag, root }) {
     if (!rules.length) console.log('No Codex model rules. Claude rules are not imported.');
     let events = [];
     try { events = Object.values(loadCodexLedger().events); } catch { /* No ledger yet: rules list without outcomes. */ }
+    const inReview = new Set(codexRulesInReview({ rules, events, root: null }).map((x) => x.index));
     rules.forEach((r, i) => {
       const h = codexRuleHealth(r, { events });
       const outcome = h.runs ? ` | measured x${h.runs}, err ${Math.round(h.rate * 100)}%, saved ${signedUsd(h.saved, 4)}` : '';
-      const warn = h.status === 'review' ? ` | rule-health: ${h.errs}/${h.runs} runs failed, narrow the condition or remove (delegate rules rm ${i + 1} --agent codex)` : '';
+      const warn = inReview.has(i + 1) ? ` | rule-health: ${h.errs}/${h.runs} runs failed, narrow the condition or remove (delegate rules rm ${i + 1} --agent codex)` : '';
       console.log(`#${i + 1} ${r.category} | ${r.from} -> ${r.model} | ${r.scope}${r.targetRoot ? ` ${r.targetRoot}` : ''}${outcome}${warn}`);
     });
     return;
@@ -59,7 +59,10 @@ export function run({ args, getArg, hasFlag, root }) {
   }
   console.log(`Codex delegate: ${cfg.codex?.delegate === true ? 'on' : 'off'} (model routing and guidance)`);
   console.log(`Default target: ${cfg.codex?.delegateTarget?.model || 'inherit (no override)'}`);
-  console.log(`Codex rules: ${rules.length}`);
+  // Turning delegation off must work even when the rule file is damaged.
+  let ruleCount;
+  try { ruleCount = String(loadCodexModelRules().length); } catch (e) { ruleCount = `unreadable (${e.message})`; }
+  console.log(`Codex rules: ${ruleCount}`);
   console.log('Explicit spawn models and custom roles are preserved. Targets must be available from your Codex provider.');
   const saved = codexRoutingSavedTotals();
   console.log(saved.priced

package/src/commands/codex.js

@@ -151,6 +151,8 @@ export async function run({ args, version }) {
     if (args[1] === 'savings') {
       const { refreshCodexLedger, loadCodexLedger, codexRoutingSavedTotals } = await import('../codex-ledger.js');
       if (hasFlag('--refresh')) await refreshCodexLedger();
+      // The prompt hook runs this detached to price finished delegations.
+      if (hasFlag('--quiet')) return;
       const events = Object.entries(loadCodexLedger().events).map(([id, e]) => ({ id, ...e })).sort((a, b) => b.ts - a.ts);
       const totals = codexRoutingSavedTotals();
       if (format === 'json') { console.log(JSON.stringify({ agent: 'codex', totals, events }, null, 2)); return; }

package/src/commands/harness.js

@@ -106,6 +106,12 @@ export async function run({ args, hasFlag }) {
       for (const p of r.backedUp) console.log(`Backed up: ${p}`);
       for (const p of r.wrote) console.log(`Wrote:     ${p}`);
       for (const p of r.skipped) console.log(`Skipped:   ${p}`);
+      if (r.brokenBlock) {
+        // Nothing was written to CLAUDE.md, so claiming success would hide it.
+        console.log('\n🅷 Harness not initialized: repair the block markers in CLAUDE.md, then run this again.');
+        process.exitCode = 1;
+        return;
+      }
       console.log('\n🅷 Harness initialized. Statusline will show 🅷 5/5 on next refresh.');
       return;
     }

package/src/compact-window.js

@@ -111,6 +111,10 @@ export function isOneMillionModel(model) {
   return typeof model === 'string' && ONE_M_RE.test(model);
 }
 
+// A window Claude Code itself reported for the session (statusline payload).
+// Anything this large can only be the 1M window.
+export const LIVE_1M_MIN = 900_000;
+
 /** Effective autoCompactWindow, with the source that won. */
 export function effectiveWindow(root) {
   const env = process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW;
@@ -137,10 +141,14 @@ export function effectiveWindow(root) {
  *
  * `reason` names why it is not ok: 'unset' (no autoCompactWindow anywhere) or
  * 'too-large' (set, but above 700k — still lets context run away).
+ *
+ * `liveWindow` is the window Claude Code reported for the running session. The
+ * model id alone misses every model that is 1M without a `[1m]` suffix, so a
+ * reported size settles it whenever the caller has one.
  */
-export function compactWindowStatus({ root = process.cwd() } = {}) {
+export function compactWindowStatus({ root = process.cwd(), liveWindow = null } = {}) {
   const { model, source: modelSource } = resolveModelId(root);
-  const is1m = isOneMillionModel(model);
+  const is1m = isOneMillionModel(model) || (Number.isFinite(liveWindow) && liveWindow >= LIVE_1M_MIN);
   const win = effectiveWindow(root);
   const base = {
     model,
@@ -163,10 +171,10 @@ export function compactWindowStatus({ root = process.cwd() } = {}) {
  * Statusline chip text, or null when there is nothing to say. Kept to the same
  * short shape as the other 🅷⚠ warnings so the line stays single-width.
  */
-export function compactWindowWarningForStatusline(root = process.cwd(), cfg = null) {
+export function compactWindowWarningForStatusline(root = process.cwd(), cfg = null, { liveWindow = null } = {}) {
   if (cfg && cfg.compactWindow && cfg.compactWindow.enabled === false) return null;
   try {
-    const s = compactWindowStatus({ root });
+    const s = compactWindowStatus({ root, liveWindow });
     return s.ok ? null : 'compact-window?';
   } catch (e) {
     debug('compact-window:statusline', e);

package/src/config.js

@@ -9,10 +9,11 @@
  *   Linux:   $XDG_CONFIG_HOME/claude-token-saver/config.json or ~/.config/...
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { userDataDir } from './paths.js';
 import { labelPreference } from './statusline-mode.js';
+import { writeStateFile } from './state-file.js';
 
 const CONFIG_DIR = userDataDir();
 const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
@@ -31,8 +32,7 @@ export function loadConfig() {
 }
 
 export function saveConfig(cfg) {
-  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + '\n');
+  writeStateFile(CONFIG_PATH, JSON.stringify(cfg, null, 2) + '\n');
 }
 
 // Each keyword maps to a single statusline option toggle.

package/src/cost.js

@@ -91,8 +91,11 @@ function detectPricingTier(model) {
 
   if (m.includes('haiku')) {
     if (/haiku[-_.]?4[-_.]?5/.test(m)) return 'claude-haiku-4-5';
-    if (/haiku[-_.]?3[-_.]?5/.test(m)) return 'claude-haiku-3-5';
-    if (/haiku[-_.]?3\b/.test(m)) return 'claude-haiku-3';
+    // The 3.x ids put the version first (`claude-3-5-haiku-20241022`,
+    // `claude-3-haiku-20240307`), so both orders are matched. With only the
+    // family-first order, 3.5 Haiku fell through to the 4.5 rate.
+    if (/haiku[-_.]?3[-_.]?5|3[-_.]?5[-_.]?haiku/.test(m)) return 'claude-haiku-3-5';
+    if (/haiku[-_.]?3\b|\b3[-_.]?haiku/.test(m)) return 'claude-haiku-3';
     return 'claude-haiku-4-5';
   }
 

package/src/ctx-window-cache.js

@@ -0,0 +1,61 @@
+/**
+ * The context window Claude Code reports for each session.
+ *
+ * Only the statusline payload carries it (`context_window.context_window_size`).
+ * The UserPromptSubmit hook gets a session id and a transcript path, so the
+ * briefing used to guess the window from the configured model id, and a model
+ * that is 1M without a `[1m]` suffix was judged against 200k: the 80% warning
+ * fired at 160k while the statusline of the same session said "Ctx 1M". The
+ * statusline records the size it was given here, and the briefing reads it back
+ * by session id before it falls back to guessing.
+ *
+ * State: <stateDir>/ctx-window.json
+ *   { sessions: { [session_id]: { size, ts } } }
+ * Entries untouched for 7 days are pruned on write.
+ */
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { userDataDir } from './paths.js';
+import { writeStateFile } from './state-file.js';
+
+const PRUNE_MS = 7 * 24 * 60 * 60 * 1000;
+// The statusline renders every few seconds. An unchanged size is rewritten only
+// this often, which is enough to keep a long session's entry from being pruned.
+const REFRESH_MS = 24 * 60 * 60 * 1000;
+
+export function ctxWindowCachePath() {
+  return join(userDataDir(), 'ctx-window.json');
+}
+
+function load() {
+  try {
+    const s = JSON.parse(readFileSync(ctxWindowCachePath(), 'utf8'));
+    return s && s.sessions && typeof s.sessions === 'object' && !Array.isArray(s.sessions) ? s : { sessions: {} };
+  } catch {
+    return { sessions: {} };
+  }
+}
+
+const validSize = (size) => Number.isFinite(size) && size > 0;
+
+/** Record the window the statusline payload reported. Returns true when the file was written. */
+export function recordLiveWindow(sessionId, size, now = Date.now()) {
+  if (typeof sessionId !== 'string' || sessionId === '' || !validSize(size)) return false;
+  const state = load();
+  const prev = state.sessions[sessionId];
+  if (prev && prev.size === size && now - prev.ts < REFRESH_MS) return false;
+  state.sessions[sessionId] = { size, ts: now };
+  for (const [id, s] of Object.entries(state.sessions)) {
+    if (!s || !Number.isFinite(s.ts) || now - s.ts > PRUNE_MS) delete state.sessions[id];
+  }
+  writeStateFile(ctxWindowCachePath(), JSON.stringify(state) + '\n');
+  return true;
+}
+
+/** The recorded window for a session, or null when the statusline never reported one. */
+export function liveWindowFor(sessionId) {
+  if (typeof sessionId !== 'string' || sessionId === '') return null;
+  const s = load().sessions[sessionId];
+  return s && validSize(s.size) ? s.size : null;
+}

package/src/delegation-guard.js

@@ -26,6 +26,7 @@ import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 import { loadConfig, saveConfig } from './config.js';
 import { recentToolPaths } from './session-paths.js';
+import { routeCapsFor } from './route-caps.js';
 
 const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
 
@@ -114,7 +115,7 @@ function ratchetImportMissing(home = homedir()) {
  * English-only prompt, an already-imported ratchet.md, or a session with
  * nothing read yet each drop their own section without blocking the others.
  */
-export async function buildAppendix(payload, { cfg = loadConfig(), home = homedir() } = {}) {
+export async function buildAppendix(payload, { cfg = loadConfig(), home = homedir(), routeCaps = routeCapsFor(payload?.session_id) } = {}) {
   const sections = [];
 
   // Read from `model` first — it is the more specific field when both are set
@@ -125,12 +126,17 @@ export async function buildAppendix(payload, { cfg = loadConfig(), home = homedi
 
   const bounds = boundsText();
   if (bounds) {
-    // Hardcoded per the user's model-fitting ratchet rule
-    // (~/.claude/ratchet-model.md): haiku delegations get a tighter leash
-    // (8 tool calls / 1,500 output tokens) than everything else (20 / 8,000).
-    const capLine = isHaiku
-      ? 'Cap for this delegation: 8 tool calls, 1,500 output tokens.'
-      : 'Cap for this delegation: 20 tool calls, 8,000 output tokens.';
+    // Haiku delegations get a tighter leash (8 tool calls / 1,500 output
+    // tokens) than everything else (20 / 8,000). Those are the defaults of the
+    // model-fitting rules. When this turn's prompt matched a rule, the rule's
+    // own calibrated budget for the tier replaces them, so the subagent is told
+    // the same limit the main model was (see route-caps.js). A T1 rule sets no
+    // call count, and the default one stays in that case.
+    const fallback = isHaiku ? { calls: 8, out: 1500 } : { calls: 20, out: 8000 };
+    const matched = routeCaps?.[isHaiku ? 'T2' : 'T1'];
+    const calls = Number.isFinite(matched?.calls) && matched.calls > 0 ? matched.calls : fallback.calls;
+    const out = Number.isFinite(matched?.out) && matched.out > 0 ? matched.out : fallback.out;
+    const capLine = `Cap for this delegation: ${calls} tool calls, ${out.toLocaleString('en-US')} output tokens.`;
     sections.push(['## Bounds and output shape', bounds, capLine].join('\n\n'));
   }
 
@@ -234,7 +240,7 @@ export async function buildAppendix(payload, { cfg = loadConfig(), home = homedi
  * call, so the caller's contract stays "print nothing, let the tool run
  * exactly as given" for every one of them.
  */
-export async function decideForDelegation(payload, { cfg = loadConfig(), home = homedir() } = {}) {
+export async function decideForDelegation(payload, { cfg = loadConfig(), home = homedir(), routeCaps = routeCapsFor(payload?.session_id) } = {}) {
   if (!delegateEnabled(cfg)) return null;
   if (payload?.tool_name !== 'Task' && payload?.tool_name !== 'Agent') return null;
 
@@ -246,7 +252,7 @@ export async function decideForDelegation(payload, { cfg = loadConfig(), home =
   // same tool_name, must not stack the appendix onto itself.
   if (prompt.includes(DELEGATION_MARKER)) return null;
 
-  const appendix = await buildAppendix(payload, { cfg, home });
+  const appendix = await buildAppendix(payload, { cfg, home, routeCaps });
   if (!appendix) return null;
 
   return { updatedInput: { ...toolInput, prompt: `${prompt}\n\n${appendix}` } };