sprag-cli 3.62.0 → 3.64.0

package/src/codex-harness.js

@@ -1,11 +1,16 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { codexUserDir } from './agent.js';
+import { loadConfig } from './config.js';
+import { koreanStyleEnabled, koreanStyleInjection } from './korean-style.js';
 import { codexToolEvents, codexLegacyToolEvent, readCodexTailLines, forkedCopyFilter } from './codex-parser.js';
+import { implementationDelegationRule } from './implementation-delegation.js';
 
 export const CODEX_BEGIN = '<!-- sprag:codex:harness:begin -->';
 export const CODEX_END = '<!-- sprag:codex:harness:end -->';
+export const CODEX_KOREAN_BEGIN = '<!-- sprag:codex:korean-style:begin -->';
+export const CODEX_KOREAN_END = '<!-- sprag:codex:korean-style:end -->';
 const sections = [
   ['Ratchet', 'When a mistake recurs, propose a concise condition/action rule. Ask the user for global or project scope before registering it with `sprag harness promote --agent codex --global|--project "rule"`.'],
   ['Evidence', 'Support completion claims with actual test results, command output, a file diff, or a screenshot. State any verification you could not run.'],
@@ -16,11 +21,15 @@ const sections = [
 
 const scopeDir = (root, scope) => (scope === 'global' ? codexUserDir() : root);
 
+/** Codex reads the override instead of AGENTS.md when it is non-empty. */
+function activeInstructionFile(dir) {
+  const override = join(dir, 'AGENTS.override.md');
+  return existsSync(override) && readFileSync(override, 'utf8').trim() ? override : join(dir, 'AGENTS.md');
+}
+
 export function codexHarnessPaths(root, scope = 'project') {
   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');
+  const file = activeInstructionFile(dir);
   return { file, ratchet: scope === 'global' ? join(dir, 'ratchet.md') : join(dir, '.codex', 'ratchet.md') };
 }
 
@@ -31,18 +40,21 @@ function harnessFiles(root, scope) {
 }
 
 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`;
+  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\n${implementationDelegationRule('codex')}\nAfter fixing the design, resolve T1 with \`sprag delegate implementation --agent codex --from <active-parent-model> --provider <active-provider> --session <parent-session-id>\`. This implementation-split policy is the user's delegation request, including selection of the returned model. Do not infer the active model from the default config. Send the returned route line only at the end of the child message, use fork_turns "none", and wait with wait_agent (timeout_ms at least 120000, repeating if needed). If tools are unavailable, do not run the resolver or launch another CLI; work on the main agent and disclose it.\n${CODEX_END}\n`;
 }
 
-function range(content) {
-  const begin = content.indexOf(CODEX_BEGIN);
-  const end = content.indexOf(CODEX_END);
-  if ((begin < 0) !== (end < 0) || (begin >= 0 && end < begin) || content.indexOf(CODEX_BEGIN, begin + CODEX_BEGIN.length) >= 0) {
-    throw new Error('Malformed Sprag Codex harness markers; repair them before updating this file.');
+/** The [start, end) span of a marker block, null when absent; malformed markers throw. */
+function range(content, beginMarker = CODEX_BEGIN, endMarker = CODEX_END, label = 'harness') {
+  const begin = content.indexOf(beginMarker);
+  const end = content.indexOf(endMarker);
+  if ((begin < 0) !== (end < 0) || (begin >= 0 && end < begin) || content.indexOf(beginMarker, begin + beginMarker.length) >= 0) {
+    throw new Error(`Malformed Sprag Codex ${label} markers; repair them before updating this file.`);
   }
-  return begin < 0 ? null : [begin, end + CODEX_END.length];
+  return begin < 0 ? null : [begin, end + endMarker.length];
 }
 
+const koreanRange = (content) => range(content, CODEX_KOREAN_BEGIN, CODEX_KOREAN_END, 'korean-style');
+
 export function initCodexHarness({ root, scope = 'project' }) {
   const paths = codexHarnessPaths(root, scope);
   const existing = existsSync(paths.file) ? readFileSync(paths.file, 'utf8') : '';
@@ -95,10 +107,74 @@ export function uninitCodexHarness({ root, scope = 'project' }) {
     writeFileSync(candidate, withoutBlock(existing, span));
     cleaned.push(candidate);
   }
+  // The Korean style block lives only in the global file; project scope never has one.
+  if (scope === 'global') {
+    for (const candidate of removeKoreanBlocks(scopeDir(root, scope))) if (!cleaned.includes(candidate)) 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 } : {}) };
 }
 
+/**
+ * Backup next to the file. A fresh install writes two backups in one
+ * millisecond (harness block, then Korean block); `wx` and a counter keep the
+ * second from overwriting the first, which holds the user's original text.
+ */
+function backupFile(file, text) {
+  const base = `${file}.bak-${Date.now()}`;
+  for (let i = 0; ; i++) {
+    try { writeFileSync(i ? `${base}-${i}` : base, text, { flag: 'wx' }); return; }
+    catch (e) { if (e?.code !== 'EEXIST') throw e; }
+  }
+}
+
+/** Removes the Korean block from every instruction file of `dir` that holds one; returns those files. */
+function removeKoreanBlocks(dir) {
+  const cleaned = [];
+  for (const candidate of [join(dir, 'AGENTS.override.md'), join(dir, 'AGENTS.md')]) {
+    if (!existsSync(candidate)) continue;
+    const existing = readFileSync(candidate, 'utf8');
+    const span = koreanRange(existing);
+    if (!span) continue;
+    const next = withoutBlock(existing, span);
+    if (next.trim()) backupFile(candidate, existing);
+    writeFileSync(candidate, next);
+    cleaned.push(candidate);
+  }
+  return cleaned;
+}
+
+/**
+ * Keeps the Korean style guide in the global Codex instruction file. Codex
+ * keeps only about 2,000 tokens of one hook's context, which the guide never
+ * fits, but it loads the global AGENTS.md in full every session. The block is
+ * written while the style is enabled and removed when it is not.
+ * Returns { action: 'written' | 'unchanged' | 'removed' | 'absent' | 'skipped', file }.
+ * `skipped` means the Codex directory does not exist, so nothing was touched.
+ */
+export function syncCodexKoreanBlock({ cfg = loadConfig(), home } = {}) {
+  const dir = home ? resolve(home) : codexUserDir();
+  const file = activeInstructionFile(dir);
+  if (!existsSync(dir)) return { action: 'skipped', file };
+  const text = koreanStyleEnabled(cfg) ? koreanStyleInjection({ cfg }) : null;
+  if (!text) {
+    const cleaned = removeKoreanBlocks(dir);
+    return cleaned.length ? { action: 'removed', file: cleaned.includes(file) ? file : cleaned[0] } : { action: 'absent', file };
+  }
+  const block = `${CODEX_KOREAN_BEGIN}\n${text}\n${CODEX_KOREAN_END}`;
+  const existing = existsSync(file) ? readFileSync(file, 'utf8') : '';
+  const span = koreanRange(existing);
+  if (span && existing.slice(...span) === block) return { action: 'unchanged', file };
+  const body = existing.replace(/\n+$/, '');
+  const next = span ? existing.slice(0, span[0]) + block + existing.slice(span[1])
+    : body + (body ? '\n\n' : '') + block + '\n';
+  // Replacing our own block loses nothing; the first addition to a user file gets a copy.
+  if (!span && existing.trim()) backupFile(file, existing);
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, next);
+  return { action: 'written', file };
+}
+
 export function codexHarnessStatus({ root, scope = 'project' }) {
   const { file } = codexHarnessPaths(root, scope);
   const text = existsSync(file) ? readFileSync(file, 'utf8') : '';

package/src/codex-hooks.js

@@ -6,17 +6,18 @@ import { join, resolve } from 'node:path';
 import { loadConfig, userLanguage } from './config.js';
 import { koreanStyleInjection, koreanStyleEnabled } from './korean-style.js';
 import { cohesionInjection } from './cohesion.js';
-import { codexHarnessPaths } from './codex-harness.js';
+import { codexHarnessPaths, syncCodexKoreanBlock } from './codex-harness.js';
 import { writeViaTmp } from './state-file.js';
 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 { codexDocumentTool, codexDocumentNote, convertCodexDocument, codexDocumentContext } from './codex-doc2md.js';
+import { codexDelegationTool, codexRouteHint, codexDelegateEnabled } from './codex-delegation.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';
 import { debug } from './debug.js';
+import { updateOffer } from './update-notice.js';
 
 const require = createRequire(import.meta.url);
 const lint = require('./korean-lint.cjs');
@@ -162,10 +163,16 @@ export function lintCodexTool(payload, { scope = 'all' } = {}) {
   return messages.length ? messages.join('\n\n') : null;
 }
 
-export async function codexHookOutput(event, payload, { cfg = loadConfig(), refreshLedger = defaultLedgerRefresh } = {}) {
+export async function codexHookOutput(event, payload, { cfg = loadConfig(), refreshLedger = defaultLedgerRefresh, version } = {}) {
   if (!payload || typeof payload !== 'object') return null;
+  if (event === 'stop') {
+    if (payload.stop_hook_active || !koreanStyleEnabled(cfg) || cfg?.koreanReplyCheck === false) return null;
+    const { checkCodexReplyLanguage } = await import('./codex-reply-language.js');
+    if (!checkCodexReplyLanguage(payload)) return null;
+    return { decision: 'block', reason: '사용자는 한국어로 질문했는데 마지막 답변이 영어로 작성됐습니다. 같은 내용을 한국어로 다시 답하십시오. 코드, 명령어, 오류 원문, 커밋 메시지는 그대로 유지하십시오.' };
+  }
   if (event === 'session-start' || event === 'subagent-start') {
-    if (event === 'subagent-start' && cfg?.codex?.delegate !== true) return null;
+    if (event === 'subagent-start' && !codexDelegateEnabled(cfg)) return null;
     if (event === 'subagent-start') {
       try { bindCodexSubagent(payload); } catch (e) { debug('codex:bind', e); }
     }
@@ -193,11 +200,17 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
     }
     if (event === 'subagent-start') parts.push({ priority: 0, text:
       '[Sprag Codex delegation]\nStay within the assigned task and any caller-provided budget. Return findings with file references and actual verification results; state unfinished work. Use only available Codex tools and configured roles. Do not infer a model tier or invent a tool-call budget.' });
-    parts.push({ priority: 2, spill: true, text: koreanStyleInjection({ cfg }) },
-      { priority: 3, spill: true, text: await cohesionInjection({ cfg }) });
+    // Codex reads the Korean guide from the global AGENTS.md, so the hook adds it
+    // only when that block was just written (this session may have loaded the old
+    // file) or could not be synced. Children read the same file.
+    let korean = null;
+    try { korean = syncCodexKoreanBlock({ cfg }); } catch (e) { debug('codex:korean-sync', e); }
+    if (korean?.action !== 'unchanged') parts.push({ priority: 2, spill: true, text: koreanStyleInjection({ cfg }) });
+    parts.push({ priority: 3, spill: true, text: await cohesionInjection({ cfg }) });
     if (process.env.CTS_NO_DOC2MD !== '1' && cfg?.codex?.doc2md !== false) parts.push({ priority: 4, spill: true, text: codexDocumentNote() });
     // Offers ask the user a question; a `codex exec` run has no one to answer it.
     if (event === 'session-start' && payload.source !== 'compact' && !isCodexExecSession(payload.transcript_path)) {
+      if (version) parts.push({ priority: 5, text: updateOffer(version, { agent: 'codex', lang: userLanguage() }) });
       try { parts.push({ priority: 5, text: await routeNotice(root) }); } catch (e) { debug('codex:route-notice', e); }
       try { parts.push({ priority: 6, text: seedOfferBlock({ root, agent: 'codex' }) }); } catch (e) { debug('codex:seed-offer', e); }
     }
@@ -206,7 +219,7 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
   }
   if (event === 'prompt') {
     const parts = [];
-    if (cfg?.codex?.delegate === true) {
+    if (codexDelegateEnabled(cfg)) {
       // 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); }
@@ -223,7 +236,8 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
       catch (e) { debug('codex:brief', e); }
     }
     if (process.env.CTS_NO_DOC2MD !== '1' && cfg?.codex?.doc2md !== false) {
-      parts.push(doc2md.contextForPrompt(payload, { lang: userLanguage(), agent: 'codex', convert: convertCodexDocument }));
+      const identity = codexDocumentContext(payload);
+      parts.push(doc2md.contextForPrompt(payload, { lang: userLanguage(), agent: 'codex', convert: (source) => convertCodexDocument(source, identity) }));
     }
     return context('UserPromptSubmit', parts.filter(Boolean).join('\n\n'));
   }

package/src/codex-installer.js

@@ -9,6 +9,7 @@ export const CODEX_HANDLERS = {
   PreToolUse: { matcher: '^(Bash|Read|read_file|Edit|Write|Agent|spawn_agent|mcp__filesystem__read_(?:text_)?file|(?:functions\\.|tools\\.)?(?:exec_command|shell_command|shell|apply_patch|spawn_agent))$', command: 'sprag codex-hook --agent codex --event pre-tool', timeout: 600 },
   PostToolUse: { matcher: '^(Bash|apply_patch|Edit|Write|(?:functions\\.|tools\\.)?(?:exec_command|shell_command|shell|apply_patch))$', command: 'sprag codex-hook --agent codex --event post-tool', timeout: 15 },
   SubagentStart: { command: 'sprag codex-hook --agent codex --event subagent-start', timeout: 15 },
+  Stop: { command: 'sprag codex-hook --agent codex --event stop', timeout: 15 },
 };
 const ownCommands = new Set(Object.values(CODEX_HANDLERS).map((h) => h.command));
 const PANEL_COMMAND = 'sprag codex-hook --agent codex --event panel-start';

package/src/codex-ledger.js

@@ -177,6 +177,29 @@ export function loadCodexLedger({ dir = userDataDir() } = {}) {
   return { version: 1, events: {} };
 }
 
+/** Offers are not executions. Count tier alternatives as one offer per prompt. */
+export function codexDelegationStatus({ dir = userDataDir(), sessionId, now = Date.now() } = {}) {
+  const routes = readCodexDelegations({ dir }).filter((r) => now - r.at < PENDING_TTL_MS && r.at <= now &&
+    (!sessionId || r.parentSessionId === sessionId));
+  const bound = new Set(readCodexBindings({ dir }).map((b) => b.id));
+  const events = loadCodexLedger({ dir }).events;
+  const closed = closedCodexRouteIds({ dir });
+  const offers = new Map();
+  for (const r of routes) {
+    const key = r.offerId || r.id;
+    if (!offers.has(key)) offers.set(key, []);
+    offers.get(key).push(r);
+  }
+  const result = { offers: offers.size, bound: 0, settled: 0, pending: 0, unclaimed: 0 };
+  for (const group of offers.values()) {
+    if (group.some((r) => events[r.id]?.complete || events[r.id]?.aborted)) result.settled++;
+    else if (group.some((r) => bound.has(r.id) || events[r.id])) result.bound++;
+    else if (group.every((r) => closed.has(r.id) || now - r.at >= BIND_TTL_MS)) result.unclaimed++;
+    else result.pending++;
+  }
+  return result;
+}
+
 function saveLedger(data, dir) {
   mkdirSync(dir, { recursive: true });
   const file = ledgerFile(dir), tmp = `${file}.${randomUUID()}.tmp`;
@@ -242,7 +265,7 @@ export async function refreshCodexLedger({ dir = userDataDir(), home, now = Date
     if (route.provider && route.provider !== run.provider) continue;
     // A shared policy names its model only through the caller's choice, so
     // credit it only for a child of that parent that ran the mapped model.
-    if (route.source === 'shared' && (run.model !== route.to || !route.parentSessionId ||
+    if (['shared', 'implementation'].includes(route.source) && (run.model !== route.to || !route.parentSessionId ||
         run.parentThreadId !== route.parentSessionId)) continue;
     if (Number.isFinite(run.startedAt) && run.startedAt < route.at - 5000) continue;
     // A closed route ended with its hinted turn. Only a child that started
@@ -265,6 +288,7 @@ export async function refreshCodexLedger({ dir = userDataDir(), home, now = Date
     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,
       ...(route.source === 'shared' ? { tier: route.tier, sharedSignature: route.sharedSignature } : {}),
+      ...(route.source === 'implementation' ? { tier: route.tier } : {}),
       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,

package/src/codex-panel.js

@@ -17,15 +17,16 @@ 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, loadCodexLedger } from './codex-ledger.js';
-import { loadCodexModelRules } from './codex-delegation.js';
-import { codexRulesInReview } from './codex-rule-health.js';
+import { codexRoutingSavedTotals, loadCodexLedger, codexDelegationStatus } from './codex-ledger.js';
+import { loadCodexModelRules, codexDelegateEnabled } from './codex-delegation.js';
+import { codexRulesInReview, codexSharedRuleHealth } from './codex-rule-health.js';
 import { readCodexRouteScan, openCodexCandidates } from './codex-route-scan.js';
 import { codexBudgetProvider } from './codex-budget.js';
+import { readUpdateChip } from './update-notice.js';
 
 export const CODEX_SEGMENT_ORDER = [
-  'cap-warn', 'usage', 'ctx', 'ttl', 'model', 'effort',
-  'hit', 'saved', 'doc2md', 'harness', 'korean', 'version',
+  'cap-warn', 'update', 'usage', 'ctx', 'ttl', 'model', 'effort',
+  'hit', 'saved', 'doc2md', 'routing', 'harness', 'korean', 'version',
 ];
 
 // Only cache full-session parses. A moving time cutoff would make an unchanged
@@ -34,7 +35,8 @@ export const CODEX_SEGMENT_ORDER = [
 const RATCHET_SIBLING_MS = 30 * 60000;
 
 export function createPanelReader({ root = process.cwd(), home, sessionId: pinnedId, sessionFile, days = 7, readBudget = () => null,
-  readCachePolicy = (session) => readCodexCachePolicy(session, { home }), hasFlag = () => false } = {}) {
+  readCachePolicy = (session) => readCodexCachePolicy(session, { home }), hasFlag = () => false,
+  version, refreshUpdate = false } = {}) {
   if (pinnedId && sessionFile) throw new Error('Choose --session or --session-file, not both.');
   const cache = new Map();
   const ratchetCache = new Map();
@@ -121,11 +123,15 @@ export function createPanelReader({ root = process.cwd(), home, sessionId: pinne
       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 sharedRuleReview = [];
+    try { sharedRuleReview = codexSharedRuleHealth({ root: project }).filter((r) => r.health.status === 'review'); }
+    catch { /* Shared policy health must not hide the rest of the panel. */ }
     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, ruleReview, routingSaved,
+      ratchet: ratchetFor(selected, recent.filter((file) => file !== selected?.filePath)), route, ruleReview, sharedRuleReview, routingSaved,
+      delegation: codexDelegationStatus({ sessionId: sessionId || selected?.sessionId }),
       labelMode: resolveLabelMode({ cfg: statuslineDefaults(), hasFlag }).mode,
       color: statuslineDefaults().color,
       timer: !hasFlag('--no-timer') && (hasFlag('--timer') || statuslineDefaults().timer),
@@ -138,8 +144,9 @@ export function createPanelReader({ root = process.cwd(), home, sessionId: pinne
       lint: cfg?.koreanStyle?.lint || 'block',
       cohesion: cfg?.cohesion?.enabled === true,
       brief: cfg?.codex?.brief !== false,
-      delegate: cfg?.codex?.delegate === true,
+      delegate: codexDelegateEnabled(cfg),
       doc2md: cfg?.codex?.doc2md !== false && process.env.CTS_NO_DOC2MD !== '1',
+      update: version ? readUpdateChip(version, { refresh: refreshUpdate }) : null,
       updatedAt: new Date() };
   };
 }
@@ -276,16 +283,27 @@ function panelGroups(data, { now, version = '', full = false, mode = full ? 'tex
     chip(`Reasoning ${short(s.reasoningOutputTokens)} (in output)`),
   ] : []);
   const docs = data.documents;
-  register('doc2md', 'documents', docs?.scope === 'codex-total' && docs.docs > 0 ? [
-    chip(`${icon('doc')}Doc2md ${number(docs.docs)} docs (Codex total)`, 32),
+  const docSavings = docs?.scope === 'codex-total' ? docs.savings : null;
+  register('doc2md', 'savings', [
+    chip(`Doc2md saved ${docSavings?.priced ? `${signedMoney(docSavings.total)} est. (XML vs MD)`
+      : `n/a (${docs?.docs ? `${docs.docs} unpriced docs` : 'no documents'})`}`, docSavings?.priced ? (docSavings.total < 0 ? 33 : 32) : 90),
+    ...(docSavings?.priced && docSavings.unpriced ? [chip(`${docSavings.unpriced} docs unpriced`)] : []),
+    ...(docs?.scope === 'codex-total' && docs.docs > 0 ? [chip(`${icon('doc')}Doc2md ${number(docs.docs)} docs (Codex total)`, 32),
     ...(docs.byExt || []).map((row) => chip(`${terminalText(row.ext)} ${number(row.docs)}x`)),
-  ] : []);
+    ] : []),
+  ]);
+  const delegation = data.delegation;
+  register('routing', 'savings', [routingChip(data.routingSaved, chip),
+    delegation?.offers ? chip(`Delegation ${delegation.settled} completed / ${delegation.bound} bound / ${delegation.pending} pending / ${delegation.unclaimed} unclaimed (session)`,
+      delegation.unclaimed && !delegation.settled && !delegation.bound ? 33 : 90) : null,
+  ]);
   register('harness', 'preferences', [
     chip(`${icon('harness')}Harness ${h?.error ? 'ERROR' : h ? `${h.configured}/${h.total}` : 'n/a'}`, h?.configured === 5 ? 32 : 33),
     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.sharedRuleReview?.length ? chip(`rule-health shared ${terminalText(data.sharedRuleReview[0].rule.tier)} ${terminalText(data.sharedRuleReview[0].rule.category)}${data.sharedRuleReview.length > 1 ? ` +${data.sharedRuleReview.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', [
@@ -294,8 +312,11 @@ function panelGroups(data, { now, version = '', full = false, mode = full ? 'tex
     chip(`${icon('doc')}Doc2md ${data.doc2md ? 'on' : 'off'} (prefs)`),
     ...(data.hooks ? [chip(`Hooks ${data.hooks.filter((hook) => hook.registered).length}/${data.hooks.length} registered`)] : []),
     ...(data.brief !== undefined ? [chip(`Brief ${data.brief ? 'on' : 'off'}`)] : []),
-    ...(data.delegate !== undefined ? [chip(`Delegate ${data.delegate ? 'on' : 'off'} (model routing)`)] : []),
-    routingChip(data.routingSaved, chip),
+    ...(data.delegate !== undefined ? [chip(`Delegate ${data.delegate ? 'on' : 'off'} (preference; tools unverified)`)] : []),
+  ]);
+  register('update', 'priority', [
+    data.update?.available && !data.update.dismissed
+      ? chip(`${icon('upgrade')}v${terminalText(version)} -> ${terminalText(data.update.latest)}`, 33) : null,
   ]);
   register('version', 'preferences', [
     chip(`SPRAG${version ? ` v${terminalText(version)}` : ''} / ${s ? age(s.lastActivity, now) : 'waiting'}`,
@@ -453,7 +474,7 @@ export async function runCodexPanel({ read, interval = 2000, once = false, color
       try { lastData = await read(); }
       catch (e) { lastData = { ...lastData, error: e.message }; }
       if (stopped) break;
-      if (compact && !once) fitRows(formatCodexPanel(lastData, { columns: (output.columns || 100) - 1, rows: 10000, color: false, compact: true }).split('\n').length);
+      if (compact && !once) fitRows(formatCodexPanel(lastData, { columns: (output.columns || 100) - 1, rows: 10000, color: false, compact: true, version }).split('\n').length);
       draw();
       if (once) break;
       await wait();

package/src/codex-reply-language.js

@@ -0,0 +1,43 @@
+import { createRequire } from 'node:module';
+import { forkedCopyFilter, codexToolEvents } from './codex-parser.js';
+
+const { checkReplyLanguage } = createRequire(import.meta.url)('./reply-language.cjs');
+
+/** Ignore copied history and commentary; only the current turn's final reply counts. */
+export function lastCodexTurn(lines, { turnId, sessionId } = {}) {
+  const copied = forkedCopyFilter();
+  let prompt = null, reply = '', currentTurn = null;
+  for (const line of lines) {
+    let e;
+    try { e = JSON.parse(line); } catch { continue; }
+    if (copied(e)) continue;
+    const p = e?.payload;
+    if (!p) continue;
+    if (e.type === 'session_meta' && sessionId && (p.id || p.session_id) !== sessionId) return null;
+    if (e.type === 'event_msg' && p.type === 'task_started') {
+      currentTurn = p.turn_id;
+      prompt = null;
+      reply = '';
+    }
+    for (const ev of codexToolEvents(e)) {
+      if (ev.kind !== 'user' || (sessionId && ev.threadId && ev.threadId !== sessionId)) continue;
+      currentTurn = ev.turnId || currentTurn;
+      prompt = ev.text;
+      reply = '';
+    }
+    if (e.type === 'response_item' && p.type === 'message' && p.role === 'assistant' && p.phase === 'final_answer') {
+      reply = (Array.isArray(p.content) ? p.content : []).filter((b) => b?.type === 'output_text' && typeof b.text === 'string').map((b) => b.text).join('\n');
+    }
+    if (e.type === 'event_msg' && p.type === 'task_complete' && (!p.turn_id || p.turn_id === currentTurn) &&
+        typeof p.last_agent_message === 'string') reply = p.last_agent_message;
+  }
+  if (prompt === null || (turnId && currentTurn !== turnId)) return null;
+  return { prompt, reply };
+}
+
+export function checkCodexReplyLanguage(payload) {
+  return checkReplyLanguage(payload.transcript_path, {
+    parseTurn: (lines) => lastCodexTurn(lines, { turnId: payload.turn_id, sessionId: payload.session_id }),
+    reply: payload.last_assistant_message,
+  });
+}

package/src/codex-rule-health.js

@@ -2,6 +2,7 @@ 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';
+import { loadSharedModelRules, sharedModelRulesForProject, realProjectRoot } from './shared-model-rules.js';
 
 /**
  * Measured outcome of one Codex rule, judged as Claude's rule health judges
@@ -18,12 +19,34 @@ export function codexRuleHealth(rule, { events = Object.values(loadCodexLedger()
     (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)));
+  return healthOf(runs.filter((e) => e.source !== 'shared'));
+}
+
+function healthOf(runs) {
   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' };
 }
 
+/** Shared policies keep Codex outcomes separate, including each provider/model pair. */
+export function codexSharedRuleHealth({ root = process.cwd(), dir, events = Object.values(loadCodexLedger({ dir }).events) } = {}) {
+  const policies = sharedModelRulesForProject(loadSharedModelRules({ dir }), root);
+  return policies.flatMap((rule) => {
+    const groups = new Map();
+    for (const e of events) {
+      if (e?.source !== 'shared' || !(e.complete || e.aborted) || e.sharedSignature !== rule.sharedSignature ||
+          e.category !== rule.category || e.tier !== rule.tier || e.scope !== rule.scope ||
+          (rule.scope === 'project' && (typeof e.targetRoot !== 'string' || realProjectRoot(e.targetRoot) !== rule.targetRoot))) continue;
+      const key = JSON.stringify([e.provider, e.from, e.to]);
+      if (!groups.has(key)) groups.set(key, []);
+      groups.get(key).push(e);
+    }
+    return [...groups.values()].map((runs) => ({ rule, provider: runs[0].provider, from: runs[0].from,
+      model: runs[0].to, health: healthOf(runs) }));
+  });
+}
+
 /**
  * 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

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 } 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
@@ -32,7 +37,7 @@ function printShared(cfg, { details = false } = {}) {
   const tiers = [...new Set(policies.map((r) => r.tier))];
   for (const tier of tiers) {
     const t = own(tier) || auto.targets.find((a) => a.tier === tier);
-    if (t) console.log(`${tier} -> ${t.model}${t.effort ? ` (${t.effort})` : ''}${t.auto ? ' (auto: cheaper priced model already run in Codex)' : ''}`);
+    if (t) console.log(`${tier} -> ${t.model}${t.effort ? ` (${t.effort})` : ''}${t.auto ? ' (auto: cheaper priced model Codex runs or lists)' : ''}`);
   }
   const missing = tiers.filter((tier) => !own(tier) && !auto.targets.some((a) => a.tier === tier));
   if (missing.length) {
@@ -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)) {
@@ -100,7 +114,7 @@ export function run({ args, getArg, hasFlag, root }) {
     }
     if (action !== 'status') saveConfig(cfg);
     printShared(cfg, { details: true });
-    console.log(`Codex delegation is ${cfg.codex?.delegate === true ? 'on' : 'off; enable with sprag delegate on --agent codex'}. Target availability and lower cost must be verified with your provider.`);
+    console.log(`Codex delegation is ${codexDelegateEnabled(cfg) ? 'on' : 'off; enable with sprag delegate on --agent codex'}. Target availability and lower cost must be verified with your provider.`);
     return;
   }
   if (sub === 'rules') {
@@ -145,7 +159,7 @@ export function run({ args, getArg, hasFlag, root }) {
     if (target !== undefined) cfg.codex.delegateTarget = target;
     saveConfig(cfg);
   }
-  console.log(`Codex delegate: ${cfg.codex?.delegate === true ? 'on' : 'off'} (model routing and guidance)`);
+  console.log(`Codex delegate: ${codexDelegateEnabled(cfg) ? 'on' : 'off'} (model routing and guidance)`);
   console.log(`Default target: ${cfg.codex?.delegateTarget?.model || 'inherit (no override)'}`);
   // Turning delegation off must work even when the rule file is damaged.
   let ruleCount;