sprag-cli 3.63.0 → 3.65.0

package/src/commands/codex-delegate.js

@@ -2,13 +2,14 @@ import { loadConfig, saveConfig } from '../config.js';
 import { configureCodexHooks } from '../codex-installer.js';
 import { validateCodexTarget, loadCodexModelRules, addCodexModelRule, removeCodexModelRule,
   validateCodexSharedTarget, codexSharedTargets, codexDelegateMinContext, DEFAULT_DELEGATE_MIN_CONTEXT,
-  autoCodexSharedTargets, codexDelegateEnabled } from '../codex-delegation.js';
+  autoCodexSharedTargets, codexDelegateEnabled, codexImplementationHint } from '../codex-delegation.js';
 import { findCodexCandidate, resolveCodexCandidate } from '../codex-route-scan.js';
 import { codexRoutingSavedTotals, loadCodexLedger } from '../codex-ledger.js';
-import { codexRuleHealth, codexRulesInReview } from '../codex-rule-health.js';
+import { codexRuleHealth, codexRulesInReview, codexSharedRuleHealth } from '../codex-rule-health.js';
 import { signedUsd } from '../money.js';
 import { codexProviderName, codexModelName } from '../agent.js';
 import { loadSharedModelRules, sharedModelRulesForProject, SHARED_RULE_TIERS } from '../shared-model-rules.js';
+import { codexDelegationDiagnostics } from '../codex-delegation-diagnostics.js';
 
 // Starts from the working directory, as the hooks do, so a project policy
 // stored under either agent's project root is counted.
@@ -22,6 +23,10 @@ function printShared(cfg, { details = false } = {}) {
   if (details) {
     for (const r of policies) console.log(`shared ${r.tier} ${r.category} | ${r.scope}${r.targetRoot ? ` ${r.targetRoot}` : ''}`);
     for (const t of targets) console.log(`${t.provider} | ${t.from} | ${t.tier} -> ${t.model}${t.effort ? ` (${t.effort})` : ''}`);
+    for (const { rule, health, provider: source, from, model } of codexSharedRuleHealth({ root: process.cwd() })) {
+      console.log(`shared ${rule.tier} ${rule.category} | ${source} | ${from} -> ${model} | measured x${health.runs}, err ${Math.round(health.rate * 100)}%, saved ${signedUsd(health.saved, 4)}`
+        + (health.status === 'review' ? ` | rule-health: ${health.errs}/${health.runs} runs failed; review the mapping or pause with sprag delegate shared off --agent codex` : ''));
+    }
   }
   // A mapping routes only sessions on the parent model it names, so a tier
   // mapped for another model still leaves the configured model unrouted. A tier
@@ -57,6 +62,15 @@ export function run({ args, getArg, hasFlag, root }) {
     }
   }
   const cfg = loadConfig();
+  if (sub === 'doctor') {
+    const report = codexDelegationDiagnostics({ sessionId: getArg('--session'), model: getArg('--from') || undefined });
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  if (sub === 'implementation') {
+    console.log(codexImplementationHint({ model: getArg('--from'), provider: getArg('--provider'), sessionId: getArg('--session'), cfg }));
+    return;
+  }
   if (sub === 'shared') {
     const action = args[2] || 'status';
     if (!['status', 'on', 'off', 'map', 'unmap', 'min-context', 'auto'].includes(action)) {

package/src/commands/codex.js

@@ -25,7 +25,9 @@ Usage: sprag <command> --agent codex [options]
   handoff [--cwd path]           Write Git state and Codex usage to HANDOFF-*.md
   saved [reset|undo]             Show, reset or restore the saved-money counters
   delegate on|off|status         Native model routing and SubagentStart guidance
+  delegate doctor               Local CLI features, model catalog and matched child activity
   delegate model <model>         Default target for spawns without an explicit model
+  delegate implementation       After design: resolve T1 with --from, --provider, --session
   delegate rules                Codex rules and shared delegation policies
   delegate shared on|off|status  Reuse approved policies; keep original scopes
   delegate shared map T1|T2     Map a tier: --from <parent> --model <target>
@@ -42,6 +44,7 @@ Usage: sprag <command> --agent codex [options]
   harness init|uninit|check|promote|list|rm|prune
                                 Rules in Codex AGENTS.md and ratchet files
   korean / cohesion / doc2md     Writing guidance and document conversion
+  doc2md savings                Codex document estimates; --format json for reasons and totals
   mode                          Shared label/color preferences
   install [--no-panel]           Register hooks and global harness; trust via /hooks
   uninstall                     Remove global integration; keep rules and shared state
@@ -141,6 +144,10 @@ export async function run({ args, version }) {
       console.log(`Hooks: ${report.hooks.error || `${report.hooks.events.filter((hook) => hook.registered).length}/${report.hooks.events.length} registered; trust unknown`}`);
       for (const hook of report.hooks.events) console.log(`  ${hook.event}: ${hook.registered ? 'registered' : 'missing/outdated; run sprag install --agent codex'}`);
       if (report.config.hooksDisabled) console.log('WARNING: user config disables hooks. Review features.hooks in Codex config.');
+      if (report.config.agentsDisabled) console.log('WARNING: user config disables agent tools. Review agents.enabled and features.multi_agent in Codex config.');
+      console.log(`Delegation: ${report.delegation.settled} completed, ${report.delegation.bound} bound, ${report.delegation.pending} pending, ${report.delegation.unclaimed} unclaimed offers (session)`);
+      console.log(`Agent tools: ${report.delegation.tools}`);
+      if (report.delegation.offers && !report.delegation.settled && !report.delegation.bound) console.log('Routing hints have no matched child. Check native subagent tool availability in the active session; preference and hook registration do not prove execution.');
       for (const [scope, harness] of Object.entries(report.harness)) console.log(`Harness ${scope}: ${harness.error ? terminalText(harness.error) : `${harness.configured}/${harness.total}`}`);
       console.log(`Session: ${report.session ? `${terminalText(report.session.id)} (${terminalText(report.session.model)})` : 'no matching rollout log'}`);
       console.log(`Panel: ${report.panel.live ? 'recent rendered frame observed' : 'no recent rendered frame'}`);
@@ -263,7 +270,7 @@ export async function run({ args, version }) {
   const statusline = hasFlag('--statusline') || format === 'statusline';
   if (statusline && (!cmd || cmd.startsWith('-'))) {
     const { createPanelReader, formatCodexPanel } = await import('../codex-panel.js');
-    const data = await createPanelReader({ root: selectedRoot, sessionId: getArg('--session'), days: numArg('--days', { dflt: 7, min: 0 }), hasFlag })();
+    const data = await createPanelReader({ root: selectedRoot, sessionId: getArg('--session'), days: numArg('--days', { dflt: 7, min: 0 }), hasFlag, version })();
     const columns = numArg('--columns', { dflt: process.stdout.columns || 100, min: 1, max: 10000 });
     const text = formatCodexPanel(data, { compact: true, columns: hasFlag('--single-line') ? 100000 : columns,
       rows: 10000, version, color: !hasFlag('--no-color') && !process.env.NO_COLOR && !!process.stdout.isTTY && data.color });
@@ -354,7 +361,7 @@ export async function run({ args, version }) {
     return runCodexPanel({
       read: createPanelReader({ root: getArg('--project') ? resolve(getArg('--project')) : root,
         sessionId: getArg('--session'), sessionFile: getArg('--session-file'), days: numArg('--days', { dflt: 7, min: 0 }), readBudget: readBudget.read,
-        readCachePolicy: hasFlag('--once') ? async (session) => {
+        version, refreshUpdate: !hasFlag('--once'), readCachePolicy: hasFlag('--once') ? async (session) => {
           const { readCodexCachePolicy } = await import('../codex-cache-policy.js');
           try { return readCodexCachePolicy(session) || await refreshCodexCachePolicy(session); }
           catch (e) { debug('codex:cache-policy', e); return null; }
@@ -364,7 +371,7 @@ export async function run({ args, version }) {
       fitRows: createInlinePanelResizer(),
       onFrame: (data) => {
         renderedSessionId = data.sessionId || data.session?.sessionId;
-        recordPanelState(panelRoot, 'frame', { status: 'rendered', pid: process.pid, sessionId: renderedSessionId });
+        recordPanelState(panelRoot, 'frame', { status: 'rendered', pid: process.pid, version, sessionId: renderedSessionId });
       },
       onClose: () => recordPanelState(panelRoot, 'frame', { status: 'closed', pid: process.pid, sessionId: renderedSessionId }),
     });
@@ -392,7 +399,7 @@ export async function run({ args, version }) {
         }
         return;
       }
-      const out = await codexHookOutput(getArg('--event'), payload);
+      const out = await codexHookOutput(getArg('--event'), payload, { version });
       if (out) console.log(JSON.stringify(out));
     } catch (e) { debug('codex:hook', e); /* Hook failures must not break the agent loop. */ }
     return;
@@ -440,8 +447,11 @@ export async function run({ args, version }) {
     if (hasFlag('--purge')) throw new Error('Codex uninstall keeps shared Sprag state; --purge is not supported.');
     const hook = configureCodexHooks({ remove: true });
     const h = uninitCodexHarness({ root, scope: 'global' });
+    const { installPanelShell } = await import('../codex-panel-shell.js');
+    const shellFile = installPanelShell({ remove: true });
     console.log(`Codex hooks: ${hook.file} (${hook.action})`);
     console.log(`Codex harness: ${h.file} (${h.removed ? 'removed' : 'absent'})`);
+    console.log(`Codex shell wrapper removed: ${shellFile}. Open a new shell to use the standalone codex command.`);
     console.log('Ratchet rules, project harnesses, backups, and shared Sprag state kept.');
     return;
   }
@@ -547,9 +557,27 @@ export async function run({ args, version }) {
     console.log('Prompt conversion, supported reads, and document/cache write guards require trusted hooks. Review in Codex /hooks.');
     return;
   }
+  if (cmd === 'doc2md' && args[1] === 'savings') {
+    const { codexDocumentTotals } = await import('../codex-doc2md-ledger.js');
+    const totals = codexDocumentTotals();
+    if (format === 'json') console.log(JSON.stringify({ agent: 'codex', ...totals }, null, 2));
+    else {
+      console.log(`Doc2md saved ${totals.savings.priced ? `${signedUsd(totals.savings.total, 4)} estimated` : 'n/a'} | ${totals.docs} docs, ${totals.savings.unpriced} unpriced`);
+      console.log('Estimate: Office XML versus prepared Markdown at UTF-8 bytes/4, priced at the recorded Codex model input rate. Not billed savings.');
+      for (const [reason, count] of Object.entries(totals.savings.reasons)) console.log(`${reason}: ${count}`);
+    }
+    return;
+  }
   if (cmd === 'doc2md' && args[1] && !args[1].startsWith('-') && args[1] !== 'install-converter') {
     const { convertCodexDocument } = await import('../codex-doc2md.js');
-    const result = convertCodexDocument(resolve(args[1]));
+    const sessionId = getArg('--session') || process.env.CODEX_THREAD_ID;
+    let identity = {};
+    if (sessionId) {
+      const { createPanelReader } = await import('../codex-panel.js');
+      const { session } = await createPanelReader({ root, sessionId })();
+      if (session) identity = { model: session.model, provider: session.provider };
+    }
+    const result = convertCodexDocument(resolve(args[1]), identity);
     if (!result.ok) {
       console.error(`Doc2md failed: ${result.reason}`);
       if (result.reason === 'no-markitdown') console.error('Run sprag doc2md install-converter --agent codex, then retry.');
@@ -560,21 +588,25 @@ export async function run({ args, version }) {
     console.log(`Source ${result.meta.size} bytes; Markdown ${result.meta.markdownBytes} bytes.`);
     if (result.meta.clipped || result.meta.truncated) console.log('Text extraction is incomplete; inspect the source for omitted content.');
     if (result.meta.note) console.log(result.meta.note);
+    const saving = result.meta.codexSaving;
+    console.log(`Doc2md saved ${Number.isFinite(saving?.usd) ? `${signedUsd(saving.usd, 4)} estimated (Office XML vs Markdown, bytes/4)` : `n/a (${saving?.reason || 'unknown'})`}`);
     return;
   }
   if (cmd === 'upgrade') {
-    const command = 'npm i -g sprag-cli --ignore-scripts';
+    const { upgradeInstructions } = await import('../update-notice.js');
+    const [command, setup] = upgradeInstructions('codex');
     if (!hasFlag('--print')) throw new Error(`For a Codex-only upgrade, run ${command}, then sprag install --agent codex.`);
     console.log(command);
-    console.log('sprag install --agent codex');
+    console.log(setup);
     return;
   }
   const shared = new Set(['korean', 'cohesion', 'doc2md', 'mode', 'feedback', 'update-check']);
   if (shared.has(cmd)) {
     if (args.some((a) => a.startsWith('--hook'))) throw new Error('Use codex-hook for Codex hook payloads.');
     if (cmd === 'cohesion' && args[1] === 'on') configureCodexHooks();
+    if (cmd === 'korean' && args[1] === 'reply' && args[2] === 'on') configureCodexHooks();
     const { userDataDir } = await import('../paths.js');
-    const result = await (await import(`./${cmd}.js`)).run({ args, getArg, hasFlag, numArg, version, dataDir: userDataDir() });
+    const result = await (await import(`./${cmd}.js`)).run({ args, getArg, hasFlag, numArg, version, agent: 'codex', dataDir: userDataDir() });
     if (cmd === 'cohesion' && args[1] === 'on') console.log('Review/trust the Sprag hooks in Codex /hooks.');
     return result;
   }

package/src/commands/route-scan.js

@@ -360,48 +360,14 @@ export async function run({ args, hasFlag, numArg }) {
       // — the refresh runs detached off the statusline path, never here.
       let updateBlock = null;
       try {
-        const { updateStatus, maybeSpawnUpdateCheck, SESSION_START_CHECK_INTERVAL_MS } = await import('../update-check.js');
+        const { updateOffer } = await import('../update-notice.js');
         const pkgVersion = readPackageVersion();
         // Session start is the one moment where a stale cache matters most, so
         // kick the detached refresh here too, on a shorter interval than the
         // statusline's 24h: releases can land several times a day, and a
         // session opened that afternoon should hear about them. It lands in
         // time for the statusline and for the next session, not for this line.
-        if (pkgVersion) maybeSpawnUpdateCheck(pkgVersion, { intervalMs: SESSION_START_CHECK_INTERVAL_MS });
-        const u = pkgVersion ? updateStatus(pkgVersion) : null;
-        // `dismissed` is the whole point of asking once: a user who said no to
-        // this version must not be asked again every `/clear`.
-        if (u && u.available && !u.dismissed) {
-          // What the release adds, when we managed to read it. "A newer version
-          // exists" is not a reason to upgrade; the reason is in this list, and
-          // without it the user is being asked to decide on no information.
-          const notes = Array.isArray(u.highlights) ? u.highlights : [];
-          const koNotes = notes.length
-            ? ['  이 버전에서 새로 생긴 것:', ...notes.map((n) => `    · ${n}`)]
-            : [];
-          const enNotes = notes.length
-            ? ['  What this release adds:', ...notes.map((n) => `    · ${n}`)]
-            : [];
-          updateBlock = lang === 'ko'
-            ? [
-                `[sprag update] 새 버전이 나와 있습니다: v${u.current} → ${u.latest}.`,
-                ...koNotes,
-                notes.length
-                  ? '  위 내용을 사용자에게 보여 주고 업그레이드할지 물어보십시오. 승낙하면 아래 명령을 실행하고, 묻지 않고 설치하지는 마십시오.'
-                  : '  사용자에게 지금 업그레이드할지 물어보고, 승낙하면 아래 명령을 실행하십시오. 묻지 않고 설치하지는 마십시오.',
-                '  sprag upgrade                  # 업그레이드 실행',
-                '  sprag update-check --dismiss   # 사용자가 원치 않으면 (다음 버전이 나올 때까지 다시 묻지 않습니다)',
-              ].join('\n')
-            : [
-                `[sprag update] A newer version is available: v${u.current} → ${u.latest}.`,
-                ...enNotes,
-                notes.length
-                  ? '  Show that list to the user and ask whether to upgrade. Run the command below only if they agree; do not install without asking.'
-                  : 'Ask the user whether to upgrade now, and run the command below only if they agree. Do not install without asking.',
-                '  sprag upgrade                  # perform the upgrade',
-                '  sprag update-check --dismiss   # if they decline (stays quiet until a newer release)',
-              ].join('\n');
-        }
+        if (pkgVersion) updateBlock = updateOffer(pkgVersion, { lang });
       } catch (e) { debug('route-scan:update-check', e); /* the offer is optional */ }
 
       if (open.length === 0 && reviewRules.length === 0) {

package/src/commands/saved.js

@@ -22,7 +22,7 @@ const SCOPE_SETS = {
   codex: ['codex-routing', 'codex-docs'],
 };
 
-/** Totals since each scope's mark: { usd } for money counters, { docs } for the Codex document counter. */
+/** Totals since each scope's mark; Codex keeps unavailable estimates explicit. */
 async function currentTotals(scope, dir) {
   if (scope === 'routing') {
     const { delegationSavedTotals } = await import('../savings-ledger.js');
@@ -34,10 +34,12 @@ async function currentTotals(scope, dir) {
   }
   if (scope === 'codex-routing') {
     const { codexRoutingSavedTotals } = await import('../codex-ledger.js');
-    return { usd: codexRoutingSavedTotals({ dir }).total };
+    const totals = codexRoutingSavedTotals({ dir });
+    return { usd: totals.priced ? totals.total : null, unpriced: totals.runs - totals.priced };
   }
   const { codexDocumentTotals } = await import('../codex-doc2md-ledger.js');
-  return { docs: codexDocumentTotals({ dir }).docs };
+  const totals = codexDocumentTotals({ dir });
+  return { docs: totals.docs, usd: totals.savings.priced ? totals.savings.total : null, unpriced: totals.savings.unpriced };
 }
 
 /**
@@ -75,7 +77,11 @@ export async function run({ args, hasFlag, agent = 'claude', dir: dirArg, rescan
   const suffix = agent === 'codex' ? ' --agent codex' : '';
 
   const money = (v) => (v < 0 ? `-$${(-v).toFixed(2)}` : `$${v.toFixed(2)}`);
-  const fmtTotal = (t) => (t.docs !== undefined ? (ko ? `${t.docs}건` : `${t.docs} doc(s)`) : money(t.usd));
+  const fmtTotal = (t) => {
+    const value = Number.isFinite(t.usd) ? money(t.usd) : 'n/a';
+    return t.docs !== undefined ? `${ko ? `${t.docs}건` : `${t.docs} doc(s)`}, ${value} (${ko ? 'XML 대비 추정' : 'XML estimate'}; ${t.unpriced} unpriced)`
+      : `${value}${t.unpriced ? ` +${t.unpriced} unpriced` : ''}`;
+  };
   const fmtTime = (ms) => new Date(ms).toLocaleString(ko ? 'ko-KR' : 'en-US');
   const label = (scope) => ({
     routing: ko ? '라우팅 절감' : 'Routing saved',

package/src/commands/update-check.js

@@ -11,7 +11,7 @@
  * command detached so the render itself stays offline and instant.
  */
 
-export async function run({ hasFlag, version }) {
+export async function run({ hasFlag, version, agent = 'claude' }) {
   const {
     updateStatus,
     refreshUpdateState,
@@ -56,7 +56,10 @@ export async function run({ hasFlag, version }) {
     console.log(lang === 'ko'
       ? `새 버전이 있습니다: v${version} → ${s.latest}`
       : `Update available: v${version} → ${s.latest}`);
-    console.log(lang === 'ko'
+    if (agent === 'codex') {
+      const { upgradeInstructions } = await import('../update-notice.js');
+      for (const command of upgradeInstructions(agent)) console.log(command);
+    } else console.log(lang === 'ko'
       ? `업그레이드: ${upgradeCommand()}   (또는 sprag upgrade)`
       : `Upgrade with: ${upgradeCommand()}   (or: sprag upgrade)`);
     if (s.dismissed) {
@@ -71,7 +74,7 @@ export async function run({ hasFlag, version }) {
     : `Up to date (v${version}).`);
   if (!s.latest) {
     console.log(lang === 'ko'
-      ? `아직 확인된 기록이 없습니다. 지금 확인하려면: sprag update-check --refresh (기록 파일: ${updateStatePath()})`
-      : `No check has completed yet. Run: sprag update-check --refresh (state: ${updateStatePath()})`);
+      ? `아직 확인된 기록이 없습니다. 지금 확인하려면: sprag update-check --refresh${agent === 'codex' ? ' --agent codex' : ''} (기록 파일: ${updateStatePath()})`
+      : `No check has completed yet. Run: sprag update-check --refresh${agent === 'codex' ? ' --agent codex' : ''} (state: ${updateStatePath()})`);
   }
 }

package/src/formatters/statusline.js

@@ -396,10 +396,16 @@ function buildRulesSeg(stats, c, g) {
 }
 
 /**
- * This session's subagent runs: `3 (haiku 2 · sonnet 1)`. Counts every
- * subagent the session started, not only the ones a routing rule sent, so it
- * answers "how much did this session fan out" rather than "how many rules
- * fired". Null when the session ran none, which is the common case.
+ * This session's subagent runs: `3 (haiku 2 · sonnet 1) spent $0.42`. Counts
+ * every subagent the session started, not only the ones a routing rule sent,
+ * so it answers "how much did this session fan out" rather than "how many
+ * rules fired", and what that fan-out cost. Null when the session ran none,
+ * which is the common case.
+ *
+ * The cost uses the routing headline's word, `spent`, and its shape: runs a
+ * gateway could not price are counted (`+1 unpriced`) rather than read as
+ * free, and a session whose every run went unpriced reads `n/a`. A summary
+ * without `usd` (an older caller) draws no cost at all.
  */
 function buildSessionDelegationSeg(sd, c, isIcon, verbose, g) {
   const total = Number(sd && sd.total) || 0;
@@ -411,7 +417,14 @@ function buildSessionDelegationSeg(sd, c, isIcon, verbose, g) {
     ? `${g.routing} ${verbose ? 'Subagents this session' : 'this session'}`
     : 'Subagents this session';
   const split = families.length ? ` ${c(GRAY)}(${families.join(' · ')})${c(RESET)}` : '';
-  return `${c(CYAN)}${label} ${total}${c(RESET)}${split}`;
+  const usd = Number(sd.usd);
+  const unpriced = Number(sd.unpriced) || 0;
+  let spent = '';
+  if (sd.usd != null && Number.isFinite(usd)) {
+    const amt = usd > 0 || unpriced === 0 ? formatMoney(usd) : 'n/a';
+    spent = ` ${c(GRAY)}spent ${amt}${unpriced > 0 ? ` +${unpriced} unpriced` : ''}${c(RESET)}`;
+  }
+  return `${c(CYAN)}${label} ${total}${c(RESET)}${split}${spent}`;
 }
 
 /**
@@ -634,9 +647,23 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     ? ` ${c(GRAY)}${verbose ? `last scan ${scanAge} ago` : `scan ${scanAge}`}${c(RESET)}`
     : '';
 
+  // What the same delegated runs cost on the models they ran on, read beside
+  // the saving so the reader sees what it was bought with: "saved $14.7 ·
+  // spent $5.2". Gray, since it is context for the saving rather than a result.
+  // Shown once any run carries a cost; runs whose event has none (recorded
+  // before costs were kept and not rescanned since, or unpriced) are counted
+  // instead of being read as free.
+  //   text:  "Routing saved $14.7 · spent $5.2 since 10/9"
+  //   icon:  "🔀 $14.7 · spent $5.2 (10/9~)"
+  const spentUsd = Number(totals && totals.spent) || 0;
+  const spentMissing = Number(totals && totals.spentMissing) || 0;
+  const spentTag = spentUsd > 0
+    ? ` ${c(GRAY)}· spent ${formatMoney(spentUsd)}${spentMissing > 0 ? ` +${spentMissing} unpriced` : ''}${c(RESET)}`
+    : '';
+
   const savedTone = delegationSaved < 0 ? RED : delegationSaved > 0 ? GREEN : GRAY;
   const savingsChip = delegationSaved !== 0 || routingSince
-    ? `${c(savedTone)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}${sinceInline(routingSince)}${scanTag}`
+    ? `${c(savedTone)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}${spentTag}${sinceInline(routingSince)}${scanTag}`
     : null;
   // The unresolved count stands in only while there are no savings to show, so
   // a dated zero keeps both: the reset and the dropped runs are separate facts.
@@ -707,8 +734,8 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // a row of rolling windows it read as a breakdown of whichever one it
   // touched. A single lifetime total makes the whole line one timeframe with
   // nothing to mismatch.
-  //   icon:  "🔀 Routing saved $9.8 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
-  //   text:  "Routing saved $9.8 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
+  //   icon:  "🔀 Routing saved $9.8 · spent $3.1 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
+  //   text:  "Routing saved $9.8 · spent $3.1 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
   let totalsLine = null;
   const totalsNum = Number(totals && totals.total);
   // A zero total gets its line only when a reset mark explains it; see the
@@ -737,7 +764,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     totalsLine =
       `${c(tone)}${c(BOLD)}${head}${c(RESET)} ` +
       `${c(tone)}${formatMoney(totalsNum)}${c(RESET)}` +
-      sinceWord(routingSince) + scanTag +
+      spentTag + sinceWord(routingSince) + scanTag +
       (pairText ? `  ${c(GRAY)}|${c(RESET)}  ${pairText}` : '');
   }
 

package/src/implementation-delegation.js

@@ -0,0 +1,34 @@
+/** Shared policy, rendered with each client's native model selector. */
+export function implementationDelegationRule(agent = 'claude', lang = 'en') {
+  const target = agent === 'codex'
+    ? 'the resolved T1 model for the current parent model and provider (explicit mapping first, automatic resolution otherwise)'
+    : 'a model: sonnet subagent';
+  if (lang === 'ko') return [
+    '- **구현 분업**: 여러 파일을 고칠 때 설계와 스펙 확정은 메인 모델이 맡습니다.',
+    `  구현은 ${agent === 'codex' ? '현재 부모 모델과 프로바이더의 T1 모델' : 'model: sonnet 서브에이전트'}에 위임합니다.`,
+    '  Claude는 sonnet을 쓰고, Codex는 명시적 T1 매핑을 우선하며 없으면 자동 해석한 T1을 씁니다.',
+    '  두 모델의 성능이 같다고 가정하지 않으며 haiku나 T2에 구현을 맡기지 않습니다.',
+    '  위임 프롬프트에는 설계, 수정할 파일, 제약, 완료 기준, 테스트 명령, 예산과',
+    '  권장 모델 및 선택 이유를 적어 다른 문맥 없이 실행할 수 있게 합니다.',
+    '  이미 읽은 파일의 약 50줄 이하 변경이나 의존 단계가 하나인 짧은 구현은',
+    '  분업 비용을 고려해 메인 모델이 직접 처리합니다. Codex에서 T1을 해석하지 못하면',
+    '  메인이 이어받습니다. 위임이 꺼져 있거나 하위 모델 또는 위임 도구를 사용할 수',
+    '  없어도 메인이 처리하고 그 이유를 알립니다.',
+    '  메인 모델은 위임 완료를 기다리고 같은 구현을 중복 실행하지 않습니다.',
+    '  반환된 diff와 테스트 결과를 직접 검증한 뒤 완료로 보고합니다.',
+  ].join('\n');
+  return [
+    '- **Implementation split**: the main model fixes the design and specification,',
+    `  then delegates multi-file implementation to ${target}.`,
+    '  Claude uses sonnet; Codex uses its resolved T1, not a presumed Sonnet equivalent.',
+    '  Never use haiku or T2 for implementation. Give a self-contained specification',
+    '  with owned files, constraints, completion criteria, test commands, a budget,',
+    '  and the recommended model with a one-line reason. Changes of roughly',
+    '  50 lines or less in files already in context, or one short dependency chain,',
+    '  stay on the main model. Codex also stays on the main model if T1 is unresolved.',
+    '  If delegation is off, or the model or subagent tools are unavailable,',
+    '  stay on the main model and say why.',
+    '  Wait for the child instead of duplicating its implementation. The main model',
+    '  verifies the diff and actual test results before reporting completion.',
+  ].join('\n');
+}

package/src/model-rules.js

@@ -36,6 +36,7 @@ import { userLanguage } from './config.js';
 import { agentPhrase, agentPhraseEn } from './agents.js';
 import { writeStateFile } from './state-file.js';
 import { signedUsd } from './money.js';
+import { implementationDelegationRule } from './implementation-delegation.js';
 
 // Post-promotion delegated-category error rate above this flags the rule
 // for review (rule-health). Calibrated against local T0 avg error incidence.
@@ -267,15 +268,7 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     '- **위임 배치**: 서브에이전트 비용의 지배 항은 생성이 아니라 컨텍스트',
     '  적재다. 같은 파일들을 읽어야 하는 작업 여러 개는 에이전트 하나에 묶어',
     '  보내고, 읽는 영역이 다른 작업만 나눈다.',
-    '- **구현 분업**: 여러 파일에 걸친 구현은 설계·스펙 확정은 메인 모델이 하고,',
-    '  출력 토큰이 많은 실제 코드 작성은 스펙을 자기완결적으로(참조 없이 실행',
-    '  가능하게) 적어 model: sonnet 서브에이전트에 위임한다. haiku에는 맡기지',
-    '  않는다. 위임 프롬프트에는 작업별 권장 모델과 그 이유를 한 줄로 적는다.',
-    '  스펙을 쓴 쪽이 난도를 제일 잘 알기 때문이다. 단, 이미 컨텍스트에 있는',
-    '  파일의 약 50줄 이하 변경이나 의존 단계가 하나뿐인 짧은 구현은 분해',
-    '  오버헤드가 더 크므로 메인 모델이 직접 한다. 위임한 구현이 돌아오면 메인',
-    '  모델이 diff와 테스트 결과를 검증하고 나서 완료로 보고한다. 이 검증',
-    '  비용까지가 위임 비용이다.',
+    implementationDelegationRule('claude', lang),
     '- **에스컬레이션**: 같은 에러 2회 반복, 답이 복수 후보로 갈림, 서브에이전트가',
     '  질문을 멈추고 헛도는 징후가 보이면 즉시 인계한다. 대응 순서는',
     '  ① 재지시 후 재시도 → ② 한 티어 상향 → ③ 메인 모델이 직접 수습.',
@@ -326,17 +319,7 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     '- **Batching**: a subagent\'s dominant cost is context ingestion, not',
     '  generation. Bundle tasks that read the same files into one agent; split',
     '  only when the areas they read differ.',
-    '- **Implementation split**: for multi-file implementation, the main model',
-    '  fixes the design and writes a self-contained spec (executable without',
-    '  back-references), then delegates the output-heavy code writing to a',
-    '  model: sonnet subagent — never haiku. The delegation prompt names the',
-    '  recommended model per task with a one-line why: whoever wrote the spec',
-    '  knows the difficulty best. A change of roughly 50 lines or less in files',
-    '  already in context, or a short implementation with a single dependency',
-    '  chain, stays on the main model: decomposition overhead outweighs the',
-    '  saving. When a delegated implementation comes back, the',
-    '  main model verifies the diff and test results before reporting done —',
-    '  that verification is part of the delegation cost.',
+    implementationDelegationRule('claude', lang),
     '- **Escalation**: hand off immediately on the same error twice, an answer',
     '  splitting into multiple candidates, or a subagent spinning without asking',
     '  questions. Order: ① re-instruct and retry → ② move up one tier → ③ the',

package/src/reply-language.cjs

@@ -149,11 +149,12 @@ function readTailLines(path) {
  * null when the reply is fine (or cannot be judged), otherwise the measured
  * ratios so a caller can report them. Never throws.
  */
-function checkReplyLanguage(transcriptPath) {
+function checkReplyLanguage(transcriptPath, { parseTurn = lastTurn, reply } = {}) {
   try {
     if (!transcriptPath) return null;
-    const turn = lastTurn(readTailLines(transcriptPath));
+    const turn = parseTurn(readTailLines(transcriptPath));
     if (!turn) return null;
+    if (typeof reply === 'string') turn.reply = reply;
     if (ENGLISH_REQUESTED.test(turn.prompt)) return null;
     if (!isKoreanPrompt(turn.prompt) || !isEnglishReply(turn.reply)) return null;
     const u = letterCounts(turn.prompt);

package/src/route-scan.js

@@ -374,7 +374,26 @@ export function worthDelegating(tier, rank) {
  */
 export function runSaving(run, mainModel) {
   if (!run.model || !mainModel) return null;
-  const totals = {
+  const totals = runTotals(run);
+  const actual = sessionCost(totals, run.model);
+  const counterfactual = sessionCost(totals, mainModel);
+  if (!actual || !counterfactual) return null;
+  return counterfactual.actual - actual.actual;
+}
+
+/**
+ * USD a delegated run cost on the model it ran on: the price side of
+ * runSaving, recorded beside the saving so the statusline can show what the
+ * saving was bought with. null when the model has no price.
+ */
+export function runCost(run) {
+  if (!run.model) return null;
+  const actual = sessionCost(runTotals(run), run.model);
+  return actual ? actual.actual : null;
+}
+
+function runTotals(run) {
+  return {
     input: run.input,
     cacheCreation: run.cacheCreation,
     cacheRead: run.cacheRead,
@@ -383,10 +402,6 @@ export function runSaving(run, mainModel) {
     output: run.out,
     ...(run.long ? { long: run.long } : {}),
   };
-  const actual = sessionCost(totals, run.model);
-  const counterfactual = sessionCost(totals, mainModel);
-  if (!actual || !counterfactual) return null;
-  return counterfactual.actual - actual.actual;
 }
 
 const clamp = (v, [lo, hi]) => Math.min(hi, Math.max(lo, v));
@@ -865,6 +880,7 @@ export async function runRouteScan({ days = 14 } = {}) {
         key: e.run.path,
         ts: e.run.endedAt ?? e.run.startedAt ?? Date.now(),
         usd,
+        cost: runCost(e.run),
         rule: rule.signature,
         from: baseline,
         to: e.run.model,

package/src/savings-ledger.js

@@ -10,10 +10,13 @@
  *
  * File: <userDataDir>/delegation-ledger.json
  *   { "version": 2,
- *     "events": { "<run path>": { "ts", "usd", "rule", "from", "to" } } }
+ *     "events": { "<run path>": { "ts", "usd", "cost", "rule", "from", "to" } } }
  *
  * `from`/`to` are the models the routing decision moved between, and `usd` is
- * the price difference between them for this run's tokens. Version 1 priced
+ * the price difference between them for this run's tokens. `cost` is what the
+ * run itself cost on the model it ran on, so the statusline can show what the
+ * saving was bought with. Events written before `cost` existed lack it until a
+ * scan that still covers the run fills it in. Version 1 priced
  * every downgraded subagent run against the session's priciest model, which
  * credited the tool for runs no rule of its own had routed; those events are
  * discarded rather than migrated, since the number they carry cannot be
@@ -81,11 +84,12 @@ export function loadLedger() {
 
 /**
  * Upsert saving events. `events` is an array of
- * { key, ts, usd, rule, from, to } where `key` is the run's transcript path
- * (unique per subagent run) and `from`/`to` name the models the routing
+ * { key, ts, usd, cost, rule, from, to } where `key` is the run's transcript
+ * path (unique per subagent run) and `from`/`to` name the models the routing
  * decision moved between. `usd` is signed: a run on a pricier model is a loss
  * and is recorded as a negative amount so it reduces the totals. Only
- * non-finite amounts (unpriced runs) are skipped.
+ * non-finite amounts (unpriced runs) are skipped. A non-finite `cost` is left
+ * out of the event while its saving is still recorded.
  */
 export function recordDelegationEvents(events) {
   if (!Array.isArray(events) || events.length === 0) return;
@@ -101,12 +105,16 @@ export function recordDelegationEvents(events) {
     const prevKey = keyOf.get(id) ?? e.key;
     const prev = data.events[prevKey];
     const usd = roundUsd(e.usd);
-    if (prev && prev.ts === e.ts && prev.usd === usd) continue;
+    const cost = Number.isFinite(e.cost) ? roundUsd(e.cost) : undefined;
+    // An event recorded before `cost` existed compares unequal here, so the
+    // first scan that still covers the run fills its cost in.
+    if (prev && prev.ts === e.ts && prev.usd === usd && prev.cost === cost) continue;
     if (prevKey !== e.key) delete data.events[prevKey];
     keyOf.set(id, e.key);
     data.events[e.key] = {
       ts: e.ts,
       usd,
+      ...(cost !== undefined ? { cost } : {}),
       ...(e.rule ? { rule: e.rule } : {}),
       ...(e.from ? { from: e.from } : {}),
       ...(e.to ? { to: e.to } : {}),
@@ -143,13 +151,17 @@ export function modelFamily(model) {
  * lifetime rollup by family-level model change, priciest first. `now` is
  * injectable for tests. Never throws — an unreadable ledger yields zeros.
  *
+ * `spent` is the lifetime sum of what the same runs cost on the models they
+ * ran on, and `spentMissing` counts the runs whose event carries no `cost`
+ * (written before the field existed, or unpriced), which `spent` leaves out.
+ *
  * Events before the `routing` reset mark (`sprag saved reset`) are skipped
  * everywhere, and `since` reports the mark (null when never reset). `dir` is
  * the user data directory the mark is read from.
  */
 export function delegationSavedTotals(now = Date.now(), dir = userDataDir()) {
   const since = readResetMarks(dir).routing;
-  const empty = () => ({ week: 0, month: 0, total: 0, pairs: [], since });
+  const empty = () => ({ week: 0, month: 0, total: 0, spent: 0, spentMissing: 0, pairs: [], since });
   const totals = empty();
   const byPair = new Map();
   try {
@@ -158,6 +170,8 @@ export function delegationSavedTotals(now = Date.now(), dir = userDataDir()) {
       const usd = Number(e.usd);
       if (!Number.isFinite(usd)) continue;
       totals.total += usd;
+      if (Number.isFinite(e.cost)) totals.spent += e.cost;
+      else totals.spentMissing += 1;
       if (Number.isFinite(e.ts)) {
         if (now - e.ts <= WEEK_MS) totals.week += usd;
         if (now - e.ts <= MONTH_MS) totals.month += usd;