sprag-cli 3.56.0 → 3.58.0

package/src/brief.js

@@ -29,6 +29,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync, openSync,
 import { join } from 'node:path';
 import { userDataDir } from './paths.js';
 import { resolveModelId, isOneMillionModel, effectiveWindow } from './compact-window.js';
+import { liveWindowFor } from './ctx-window-cache.js';
 
 // Context tiers as a fraction of the session's context window. Tier 1 warns
 // (compaction/cost territory ahead), tier 2 urges wrapping up. A session only
@@ -83,14 +84,21 @@ function saveState(state, now) {
  *
  * `observedMax` stays as a floor: it proves a 1M window even when the model id
  * is unreadable (env override, settings we do not resolve).
+ *
+ * `liveWindow` outranks both. It is the size Claude Code reported to the
+ * statusline for this session, so the briefing and the statusline count against
+ * the same window. The model id cannot stand in for it: a model that is 1M
+ * without a `[1m]` suffix reads as 200k there.
  */
-export function ctxWindowFor(observedMax = 0, root = process.cwd()) {
+export function ctxWindowFor(observedMax = 0, root = process.cwd(), { liveWindow = null } = {}) {
   let modelWindow = observedMax > WINDOW_1M_MIN_INPUT ? 1_000_000 : 200_000;
+  const reported = Number.isFinite(liveWindow) && liveWindow > 0;
+  if (reported) modelWindow = liveWindow;
   let window = modelWindow;
   let compactCapped = false;
   try {
     const { model } = resolveModelId(root);
-    if (isOneMillionModel(model)) modelWindow = window = 1_000_000;
+    if (!reported && isOneMillionModel(model)) modelWindow = window = 1_000_000;
     const cap = effectiveWindow(root).value;
     if (cap !== null && cap < window) {
       window = cap;
@@ -104,7 +112,7 @@ export function ctxWindowFor(observedMax = 0, root = process.cwd()) {
  * Last request's input size for THIS session, from the transcript tail.
  * Reads at most TAIL_BYTES — prompt-submit hooks must stay fast.
  */
-export function sessionCtx(transcriptPath, { root = process.cwd() } = {}) {
+export function sessionCtx(transcriptPath, { root = process.cwd(), liveWindow = null } = {}) {
   let size;
   try { size = statSync(transcriptPath).size; } catch { return null; }
   const start = Math.max(0, size - TAIL_BYTES);
@@ -130,7 +138,7 @@ export function sessionCtx(transcriptPath, { root = process.cwd() } = {}) {
     if (total > 0) { input = total; maxInput = Math.max(maxInput, total); }
   }
   if (input == null) return null;
-  const { window, modelWindow, compactCapped } = ctxWindowFor(maxInput, root);
+  const { window, modelWindow, compactCapped } = ctxWindowFor(maxInput, root, { liveWindow });
   return { input, window, modelWindow, compactCapped, pct: input / window };
 }
 
@@ -166,14 +174,15 @@ export function seedSessionBriefed(sessionId, signatures, now = Date.now()) {
  * (recorded via seedSessionBriefed) are skipped; every other fresh signature
  * is emitted, including on the session's first event.
  */
-export async function runBrief({ sessionId, transcriptPath, now = Date.now() }) {
+export async function runBrief({ sessionId, transcriptPath, root = process.cwd(), now = Date.now() }) {
   if (!sessionId) return null;
+  const liveWindow = liveWindowFor(sessionId);
   const state = loadState();
   const s = state.sessions[sessionId] || { ctxTier: 0, briefed: [] };
   const items = [];
 
   // ── context tier crossing (per-session) ──
-  const ctx = transcriptPath ? sessionCtx(transcriptPath) : null;
+  const ctx = transcriptPath ? sessionCtx(transcriptPath, { root, liveWindow }) : null;
   if (ctx) {
     const tier = ctxTierOf(ctx.pct);
     // The tier is not monotonic: auto-compaction drops the live context back to
@@ -238,7 +247,7 @@ export async function runBrief({ sessionId, transcriptPath, now = Date.now() })
   // never needed. 200k sessions are exempt (their window is already <= 200k).
   try {
     const cw = await import('./compact-window.js');
-    const st = cw.compactWindowStatus({ root: process.cwd() });
+    const st = cw.compactWindowStatus({ root, liveWindow });
     if (!st.ok) {
       const sig = `compact-window|${st.reason}`;
       const briefed = new Set(s.briefed || []);
@@ -246,7 +255,7 @@ export async function runBrief({ sessionId, transcriptPath, now = Date.now() })
         briefed.add(sig);
         s.briefed = [...briefed];
         const now = st.window ? `현재 ${fmtK(st.window)}` : '현재 미설정';
-        items.push(`1M 컨텍스트 모델(${st.model})인데 autoCompactWindow가 ${now}입니다 — 자동 압축이 80만 토큰 근처에서야 걸려 그전까지 모든 요청이 전체 컨텍스트를 재과금합니다. 1M은 너무 크니 ${fmtK(st.recommendedMin)}~${fmtK(st.recommendedMax)} 범위를 권장합니다(그 범위 안이면 경고하지 않습니다). 1M 창 자체는 그대로 두고 압축 시점만 앞당깁니다. 등록: sprag compact-window set --global|--project [--value ${fmtK(st.recommendedMax)}] (기본 ${fmtK(st.recommended)}, 적용 범위는 사용자에게 확인) / 끄기: compact-window off`);
+        items.push(`1M 컨텍스트 모델(${st.model || 'Claude Code 기본 모델'})인데 autoCompactWindow가 ${now}입니다 — 자동 압축이 80만 토큰 근처에서야 걸려 그전까지 모든 요청이 전체 컨텍스트를 재과금합니다. 1M은 너무 크니 ${fmtK(st.recommendedMin)}~${fmtK(st.recommendedMax)} 범위를 권장합니다(그 범위 안이면 경고하지 않습니다). 1M 창 자체는 그대로 두고 압축 시점만 앞당깁니다. 등록: sprag compact-window set --global|--project [--value ${fmtK(st.recommendedMax)}] (기본 ${fmtK(st.recommended)}, 적용 범위는 사용자에게 확인) / 끄기: compact-window off`);
       }
     }
   } catch { /* settings unreadable — other briefings above still apply */ }

package/src/claude-price.js

@@ -16,10 +16,31 @@ export function sessionCost(totals, model, { env = process.env, now } = {}) {
   return price ? estimateCost(totals, model, { price }) : null;
 }
 
-/** Like estimateCostAcross, plus how many sessions had no price and were left out. */
+/** One priced part per model that spent tokens, or the whole at its one model. */
+function partsByModel(x) {
+  if (!x.modelTotals) return [{ totals: x.totals, model: x.model }];
+  return Object.entries(x.modelTotals).map(([model, totals]) => ({ totals, model }));
+}
+
+/**
+ * What a session's cost is made of: the session itself and each subagent run
+ * it spawned (parser.js attaches them as `subagentRuns`). A run has its own
+ * model, so it is priced on its own instead of at the session's rate, and a
+ * session or run that switched model is split again so each model's tokens
+ * meet that model's rate. `own` marks the parts that are the session itself.
+ */
+export function pricedParts(session) {
+  if (!session) return [];
+  return [
+    ...partsByModel(session).map((part) => ({ ...part, own: true })),
+    ...(session.subagentRuns || []).flatMap(partsByModel),
+  ];
+}
+
+/** Like estimateCostAcross, plus how many priced parts (a session, a subagent run, or one model's share of either) had no price and were left out. */
 export function sessionCostAcross(sessions, opts = {}) {
   let unpriced = 0;
-  const total = estimateCostAcross(sessions, (totals, model) => {
+  const total = estimateCostAcross((sessions || []).flatMap(pricedParts), (totals, model) => {
     const c = sessionCost(totals, model, opts);
     if (!c) unpriced++;
     return c;

package/src/codex-brief.js

@@ -1,10 +1,14 @@
 import { createHash } from 'node:crypto';
 import { readFileSync, writeFileSync, mkdirSync, renameSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { codexUserDir } from './agent.js';
 import { userDataDir } from './paths.js';
 import { readCodexSnapshot } from './codex-parser.js';
+import { loadCodexModelRules } from './codex-delegation.js';
+import { loadCodexLedger } from './codex-ledger.js';
+import { codexRulesInReview } from './codex-rule-health.js';
 
+const RESET_TOLERANCE_S = 300;
 const hash = (value) => createHash('sha256').update(value).digest('hex');
 const stateDir = (dir) => join(dir, 'codex', hash(codexUserDir()), 'sessions');
 const fresh = (value, now) => {
@@ -45,7 +49,7 @@ function readState(file) {
 }
 
 /** One file per home/session keeps unrelated sessions out of the same dedup state. */
-export function runCodexBrief({ sessionId, transcriptPath, cwd, now = Date.now(), dir = userDataDir() } = {}) {
+export function runCodexBrief({ sessionId, transcriptPath, cwd, root: projectRoot, now = Date.now(), dir = userDataDir() } = {}) {
   if (typeof sessionId !== 'string' || !sessionId) return null;
   const snapshot = readCodexSnapshot(transcriptPath);
   if (!snapshot || (snapshot.sessionId && snapshot.sessionId !== sessionId)) return null;
@@ -54,6 +58,35 @@ export function runCodexBrief({ sessionId, transcriptPath, cwd, now = Date.now()
   const file = join(directory, `${hash(sessionId)}.json`);
   const state = readState(file);
   const active = Array.isArray(state.active) ? state.active.filter((sig) => typeof sig === 'string') : [];
+  // Codex rewrites resets_at by about a second between records, so a limit
+  // already announced for the same window keeps its first signature.
+  for (const issue of issues) {
+    const m = /^limit:(primary|secondary):(\d+(?:\.\d+)?)$/.exec(issue.signature);
+    if (!m) continue;
+    const resetsAt = Number(m[2]);
+    const known = active.find((sig) => {
+      const k = /^limit:(primary|secondary):(\d+(?:\.\d+)?)$/.exec(sig);
+      return k && k[1] === m[1] && Math.abs(Number(k[2]) - resetsAt) <= RESET_TOLERANCE_S;
+    });
+    if (known) issue.signature = known;
+  }
+  // A failing model rule is announced once per session; the lines never block the other warnings.
+  try {
+    // The hook passes the project root its rule matching uses; a prompt sent from
+    // a subdirectory must still see the project's rules.
+    const root = resolve(projectRoot || cwd || snapshot.projectDir || '.');
+    const rules = loadCodexModelRules({ dir });
+    if (rules.length) {
+      const events = Object.values(loadCodexLedger({ dir }).events);
+      for (const { index, rule, health } of codexRulesInReview({ root, rules, events })) {
+        issues.push({ key: 'rule-health', tier: 1,
+          signature: `rule-health:${rule.scope}:${rule.targetRoot ?? ''}:${rule.category}:${rule.from}:${rule.model}:${rule.createdAt ?? ''}`,
+          level: 'warning',
+          message: `Codex model rule #${index} (${rule.category}, ${rule.from} -> ${rule.model}) failed ${health.errs} of ${health.runs} measured runs.`,
+          advice: `Narrow or remove it: sprag delegate rules rm ${index} --agent codex` });
+      }
+    }
+  } catch { /* An unreadable rule file or ledger only skips this line. */ }
   const next = issues.filter((issue) => !active.includes(issue.signature) &&
     !(issue.key === 'context' && issue.tier === 1 && active.includes('context:2')));
   // Missing or stale measurements do not resolve an earlier warning. A fresh

package/src/codex-delegation.js

@@ -54,7 +54,10 @@ export function addCodexModelRule({ category, model, effort, from, scope, root,
   const rules = loadCodexModelRules({ dir });
   const targetRoot = scope === 'project' ? resolve(root) : null;
   const rule = { category, model, effort, from, scope, targetRoot, ...(provider ? { provider } : {}), status: 'active', createdAt: new Date().toISOString() };
-  const old = rules.findIndex((r) => r.category === category && r.from === from && r.scope === scope && r.targetRoot === targetRoot && r.provider === provider);
+  // A rule saved without a provider has no `provider` key, and a caller with
+  // none passes null. Compared as they are, undefined !== null, so re-adding
+  // the same rule stacked a duplicate instead of replacing it.
+  const old = rules.findIndex((r) => r.category === category && r.from === from && r.scope === scope && r.targetRoot === targetRoot && (r.provider ?? null) === (provider ?? null));
   if (old < 0) rules.push(rule); else rules[old] = rule;
   saveRules(rules, dir);
   return rule;
@@ -126,7 +129,8 @@ export function codexRouteHint(payload, opts = {}) {
   try {
     record({ id, parentSessionId: payload?.session_id ?? null, turnId: payload?.turn_id ?? null, via: 'prompt',
       source: 'rule', category: rule.category, scope: rule.scope, from: payload?.model, to: rule.model,
-      provider, effort: rule.effort ?? null, contextTokens: ctx }, { dir: opts.dir });
+      provider, effort: rule.effort ?? null, contextTokens: ctx,
+      targetRoot: rule.targetRoot ?? null, ruleCreatedAt: rule.createdAt ?? null }, { dir: opts.dir });
   } catch { /* Accounting is optional; the hint still applies. */ }
   return `[Sprag model routing] This request matches the approved ${rule.category} rule (route ${id}). `
     + `Spawn one sub-agent with model ${rule.model}${rule.effort ? `, reasoning_effort ${rule.effort}` : ''} and fork_turns "none". `
@@ -160,7 +164,7 @@ function customRole(role, root, home) {
 
 // Kept for Codex versions that do send spawn_agent through PreToolUse; on
 // 0.159.2 the hook never fires for it, so codexRouteHint above is the live path.
-export function codexDelegationTool(payload, { cfg = {}, root = payload?.cwd || process.cwd(), home = codexUserDir(), rules, dir = userDataDir(), record = recordCodexDelegation } = {}) {
+export function codexDelegationTool(payload, { cfg = {}, root = payload?.cwd || process.cwd(), home = codexUserDir(), rules: given, dir = userDataDir(), record = recordCodexDelegation } = {}) {
   if (cfg.codex?.delegate !== true) return null;
   const tool = payload?.tool_name?.replace(/^(?:functions|tools)\./, '');
   if (!['spawn_agent', 'Agent'].includes(tool)) return null;
@@ -169,6 +173,9 @@ export function codexDelegationTool(payload, { cfg = {}, root = payload?.cwd ||
   const role = input.agent_type || 'default';
   if (!['default', 'worker', 'explorer'].includes(role) || customRole(role, payload.cwd || root, home)) return null;
   const explicit = Object.hasOwn(input, 'model');
+  // An unreadable rule file must not stop the default target or the spawn itself.
+  let rules = given;
+  if (!rules) { try { rules = loadCodexModelRules({ dir }); } catch { rules = []; } }
   const provider = payload.model_provider || codexProviderName({ home });
   const rule = explicit ? null : matchCodexModelRule(input.message, { model: payload.model, provider, root, rules });
   const target = rule || (!explicit && cfg.codex?.delegateTarget);
@@ -184,7 +191,8 @@ export function codexDelegationTool(payload, { cfg = {}, root = payload?.cwd ||
       try {
         record({ id, parentSessionId: typeof payload.session_id === 'string' ? payload.session_id : null,
           source: rule ? 'rule' : 'default', category: rule?.category ?? null, scope: rule?.scope ?? null,
-          from: payload.model, to: target.model, provider, effort: updatedInput.reasoning_effort ?? null }, { dir });
+          from: payload.model, to: target.model, provider, effort: updatedInput.reasoning_effort ?? null,
+          ...(rule ? { targetRoot: rule.targetRoot ?? null, ruleCreatedAt: rule.createdAt ?? null } : {}) }, { dir });
         routeLine = `\n<!-- sprag:codex:route id=${id} -->`;
       } catch { /* Accounting is optional; the route itself still applies. */ }
     }

package/src/codex-harness.js

@@ -14,14 +14,22 @@ const sections = [
   ['Default Safe Path', 'Ask before destructive or external actions unless already authorized. Proceed with reads, local edits, and tests within the granted permissions.'],
 ];
 
+const scopeDir = (root, scope) => (scope === 'global' ? codexUserDir() : root);
+
 export function codexHarnessPaths(root, scope = 'project') {
-  const dir = scope === 'global' ? codexUserDir() : root;
+  const dir = scopeDir(root, scope);
   // Codex reads the override instead of AGENTS.md when it is non-empty.
   const override = join(dir, 'AGENTS.override.md');
   const file = existsSync(override) && readFileSync(override, 'utf8').trim() ? override : join(dir, 'AGENTS.md');
   return { file, ratchet: scope === 'global' ? join(dir, 'ratchet.md') : join(dir, '.codex', 'ratchet.md') };
 }
 
+/** Every instruction file of a scope that init may have written to, active or not. */
+function harnessFiles(root, scope) {
+  const dir = scopeDir(root, scope);
+  return [join(dir, 'AGENTS.override.md'), join(dir, 'AGENTS.md')];
+}
+
 export function codexHarnessBlock() {
   return `${CODEX_BEGIN}\n## Sprag Harness\n\n${sections.map(([name, text], i) => `### ${i + 1}. ${name}\n${text}`).join('\n\n')}\n\nRead the global and project Codex ratchet files before working when present. Run \`sprag harness list --agent codex --global\` and \`sprag harness list --agent codex --project\` to retrieve them. These are instructions, not Claude-style @ imports.\nUse \`sprag doc2md <file> --agent codex\` before reading PDF, Office, or Figma documents. Delegate only through available Codex tools and configured roles; do not assume Claude model names or Task/Agent arguments. A [Sprag model routing] note on a request means the user has asked for that request to be delegated: spawn the sub-agent it describes (its model, reasoning_effort, fork_turns "none", and a self-contained message ending with the route line it gives), wait for it to finish instead of doing the same task yourself, then verify the result before replying.\n${CODEX_END}\n`;
 }
@@ -40,8 +48,11 @@ export function initCodexHarness({ root, scope = 'project' }) {
   const existing = existsSync(paths.file) ? readFileSync(paths.file, 'utf8') : '';
   const span = range(existing);
   const block = codexHarnessBlock();
+  // Trailing newlines are dropped before the separator is added, so the gap
+  // above the block is always one blank line however the file ended.
+  const body = existing.replace(/\n+$/, '');
   const next = span ? existing.slice(0, span[0]) + block.trimEnd() + existing.slice(span[1])
-    : existing + (existing ? '\n\n' : '') + block;
+    : body + (body ? '\n\n' : '') + block;
   mkdirSync(dirname(paths.file), { recursive: true });
   if (next !== existing) {
     if (existing) writeFileSync(`${paths.file}.bak-${Date.now()}`, existing);
@@ -54,15 +65,38 @@ export function initCodexHarness({ root, scope = 'project' }) {
   return paths;
 }
 
+/**
+ * The file without the block, and without the blank lines init put around it.
+ * Cutting the block alone left those behind, so each install and uninstall
+ * added three more.
+ */
+function withoutBlock(text, [begin, end]) {
+  const before = text.slice(0, begin).replace(/\n+$/, '');
+  const after = text.slice(end).replace(/^\n+/, '');
+  if (!before) return after;
+  return after ? `${before}\n\n${after}` : `${before}\n`;
+}
+
+/**
+ * Removes the block from every file of the scope that holds one. The active
+ * file alone is not enough: init writes AGENTS.md, and an AGENTS.override.md
+ * created afterwards becomes the active file while the block stays in the
+ * other one, where a later uninit never looked.
+ */
 export function uninitCodexHarness({ root, scope = 'project' }) {
   const { file } = codexHarnessPaths(root, scope);
-  if (!existsSync(file)) return { file, removed: false };
-  const existing = readFileSync(file, 'utf8');
-  const span = range(existing);
-  if (!span) return { file, removed: false };
-  writeFileSync(`${file}.bak-${Date.now()}`, existing);
-  writeFileSync(file, existing.slice(0, span[0]) + existing.slice(span[1]));
-  return { file, removed: true };
+  const cleaned = [];
+  for (const candidate of harnessFiles(root, scope)) {
+    if (!existsSync(candidate)) continue;
+    const existing = readFileSync(candidate, 'utf8');
+    const span = range(existing);
+    if (!span) continue;
+    writeFileSync(`${candidate}.bak-${Date.now()}`, existing);
+    writeFileSync(candidate, withoutBlock(existing, span));
+    cleaned.push(candidate);
+  }
+  if (!cleaned.length) return { file, removed: false };
+  return { file: cleaned.includes(file) ? file : cleaned[0], removed: true, ...(cleaned.length > 1 ? { files: cleaned } : {}) };
 }
 
 export function codexHarnessStatus({ root, scope = 'project' }) {

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;
+}