sprag-cli 3.59.0 → 3.61.0

package/src/codex-delegation.js

@@ -1,13 +1,16 @@
-import { readFileSync, readdirSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
+import { readFileSync, readdirSync, mkdirSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { parse } from 'smol-toml';
 import { userDataDir } from './paths.js';
+import { writeViaTmp } from './state-file.js';
 import { codexUserDir, codexProviderName } from './agent.js';
 import { categorize, ESCALATE_RE, EDIT_RE } from './route-scan.js';
 import { looksPasted } from './route-inject.js';
 import { newRouteId, recordCodexDelegation } from './codex-ledger.js';
 import { readCodexTailLines } from './codex-parser.js';
+import { loadConfig } from './config.js';
+import { loadSharedModelRules, sharedModelRulesForProject, sharedRuleBounds, SHARED_RULE_TIERS } from './shared-model-rules.js';
 
 export const CODEX_ROUTE_CATEGORIES = ['paste', 'translate', 'explore', 'read', 'check', 'run'];
 const MARKER = '<!-- sprag:codex:delegation -->';
@@ -22,6 +25,32 @@ export function validateCodexTarget(model, effort) {
   return { model, ...(effort === undefined ? {} : { effort }) };
 }
 
+export function validateCodexSharedTarget({ tier, from, model, effort, provider }) {
+  validateCodexTarget(model, effort);
+  if (!SHARED_RULE_TIERS.includes(tier)) throw new Error('Shared rule tier must be T1 or T2.');
+  if (!safeId(from) || from === model) throw new Error('--from must name a different parent model.');
+  if (!safeId(provider)) throw new Error('A shared model mapping requires a Codex provider ID.');
+  return { tier, from, model, ...(effort === undefined ? {} : { effort }), provider };
+}
+
+export function codexSharedTargets(cfg) {
+  const targets = cfg?.codex?.sharedRules?.targets;
+  if (!Array.isArray(targets)) return [];
+  return targets.flatMap((target) => {
+    try { return [validateCodexSharedTarget(target)]; } catch { return []; }
+  });
+}
+
+export function sharedCodexModelRules({ cfg = loadConfig(), dir = userDataDir(), root, start = root,
+  model, provider = codexProviderName() } = {}) {
+  if (cfg.codex?.sharedRules?.enabled === false) return [];
+  const targets = codexSharedTargets(cfg).filter((t) => t.from === model && t.provider === provider);
+  return sharedModelRulesForProject(loadSharedModelRules({ dir }), start).flatMap((rule) => {
+    const target = targets.find((t) => t.tier === rule.tier);
+    return target ? [{ ...rule, ...target, source: 'shared', status: 'active' }] : [];
+  });
+}
+
 const rulesFile = (dir) => join(dir, 'codex-model-rules.json');
 export function loadCodexModelRules({ dir = userDataDir() } = {}) {
   try {
@@ -41,8 +70,7 @@ export function loadCodexModelRules({ dir = userDataDir() } = {}) {
 function saveRules(rules, dir) {
   mkdirSync(dir, { recursive: true });
   const file = rulesFile(dir), tmp = `${file}.${randomUUID()}.tmp`;
-  writeFileSync(tmp, JSON.stringify({ version: 1, rules }, null, 2) + '\n', { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, JSON.stringify({ version: 1, rules }, null, 2) + '\n', { mode: 0o600 });
 }
 
 export function addCodexModelRule({ category, model, effort, from, scope, root, provider }, { dir = userDataDir() } = {}) {
@@ -92,6 +120,16 @@ export function matchCodexModelRule(text, { model, root, provider = codexProvide
   return usable.find((r) => r.scope === 'project') || usable[0] || null;
 }
 
+/** A Codex-only rule wins; otherwise the shared policies mapped for this parent, T2 first. */
+function matchingRoutes(text, opts) {
+  const own = matchCodexModelRule(text, { ...opts, rules: opts.rules ?? loadCodexModelRules({ dir: opts.dir }) });
+  if (own) return [own];
+  const category = codexPromptCategory(text);
+  if (!category) return [];
+  return sharedCodexModelRules(opts).filter((r) => r.category === category.id)
+    .sort((a, b) => SHARED_RULE_TIERS.indexOf(a.tier) - SHARED_RULE_TIERS.indexOf(b.tier));
+}
+
 /**
  * Input tokens from the rollout's last token_count record, or 0 when the
  * transcript is missing or unreadable. Only the tail is read: the newest
@@ -111,32 +149,85 @@ export function codexContextTokens(transcriptPath) {
   return 0;
 }
 
+export const DEFAULT_DELEGATE_MIN_CONTEXT = 60000;
+
+/** Parent input tokens below which the prompt hint stays silent. */
+export function codexDelegateMinContext(cfg) {
+  const value = cfg?.codex?.delegateMinContext;
+  return Number.isSafeInteger(value) && value >= 0 ? value : DEFAULT_DELEGATE_MIN_CONTEXT;
+}
+
+// Codex tells the model to set spawn_agent's model only on the user's request,
+// so the shared hint says where this request came from.
+const SHARED_APPROVAL = 'The user approved this policy and its model mapping, so setting model here follows the user\'s request.';
+const SHARED_TIER_GUIDANCE = 'Choose T2 only for a simple bounded lookup or command. Use T1 for multi-step tool chains or work spanning multiple files. If the required tier is not mapped, keep the task on the main agent. Do not delegate design judgement, diagnosis, or irreversible actions.';
+const WAIT_TEXT = 'Wait for it to finish (call wait_agent with timeout_ms of at least 120000, and again if it times out) and do not do the delegated task yourself while it runs; then verify its result and report unfinished work. Do not spawn another CLI process. '
+  + 'If sub-agent tools or the target model are unavailable, keep the task on the main agent and state that delegation was unavailable.';
+
+function sharedTargetText(rule) {
+  return `${rule.tier}: model ${rule.model}${rule.effort ? `, reasoning_effort ${rule.effort}` : ''}. ${sharedRuleBounds(rule)}`.trim();
+}
+
+function sharedDenyReason(routes) {
+  return `[Sprag model routing] This spawn matches the approved shared ${routes[0].category} policy but names no model. ${SHARED_APPROVAL} `
+    // A full-history fork inherits the parent model and refuses overrides.
+    + 'Spawn again with fork_turns "none" and the model and reasoning_effort of the tier you choose, keeping the route line the routing hint gave for that tier:\n'
+    + routes.map(sharedTargetText).join('\n')
+    + `\n${SHARED_TIER_GUIDANCE} To keep the task on your own model, pass that model explicitly. If a model cannot be set, do the task on the main agent instead of spawning again.`;
+}
+
 /**
  * A prompt-time routing suggestion for Codex 0.159.2, where `spawn_agent`
  * never reaches PreToolUse (see codexDelegationTool below). Gated on parent
  * context size: a small parent's own coordination overhead outweighs the
  * savings from a delegated child (measured 2026-09-30, see docs/CODEX.md).
+ *
+ * A shared policy offers both mapped tiers and records one route per tier;
+ * SubagentStart binds the child to the route whose model it runs, and the
+ * next prompt closes the tier that was not chosen.
  */
 export function codexRouteHint(payload, opts = {}) {
+  // The hook passes its loaded config. Without one there are no shared
+  // mappings and the default gate applies, so a caller never routes from the
+  // user's real config by accident.
+  const cfg = opts.cfg ?? {};
   const provider = payload?.model_provider || codexProviderName();
-  const rule = matchCodexModelRule(payload?.prompt, { provider, ...opts, model: payload?.model, root: opts.root || payload?.cwd });
+  const routes = matchingRoutes(payload?.prompt, { cfg, provider, ...opts, model: payload?.model,
+    root: opts.root || payload?.cwd, start: payload?.cwd });
+  const rule = routes[0];
   if (!rule) return null;
-  const minContext = opts.minContext ?? 60000;
+  const minContext = opts.minContext ?? codexDelegateMinContext(cfg);
   const ctx = opts.contextTokens ?? codexContextTokens(payload?.transcript_path);
   if (ctx < minContext) return null;
-  const id = newRouteId();
   const record = opts.record ?? recordCodexDelegation;
-  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,
-      targetRoot: rule.targetRoot ?? null, ruleCreatedAt: rule.createdAt ?? null }, { dir: opts.dir });
-  } catch { /* Accounting is optional; the hint still applies. */ }
+  // Tiers offered by one hint are alternatives. SubagentStart binds by model
+  // alone, so it must know which records compete for the same child.
+  const offerId = routes.length > 1 ? newRouteId() : null;
+  const recordRoute = (route) => {
+    const id = newRouteId();
+    const shared = route.source === 'shared';
+    try {
+      record({ id, parentSessionId: payload?.session_id ?? null, turnId: payload?.turn_id ?? null, via: 'prompt',
+        source: shared ? 'shared' : 'rule', category: route.category, scope: route.scope, from: payload?.model, to: route.model,
+        provider: route.provider || provider, effort: route.effort ?? null, contextTokens: ctx, targetRoot: route.targetRoot ?? null,
+        ...(shared ? { tier: route.tier, sharedSignature: route.sharedSignature, ...(offerId ? { offerId } : {}) }
+          : { ruleCreatedAt: route.createdAt ?? null }) }, { dir: opts.dir });
+    } catch { /* Accounting is optional; the hint still applies. */ }
+    return id;
+  };
+  if (rule.source === 'shared') {
+    const targets = routes.map((route) => `${sharedTargetText(route)} Route line: <!-- sprag:codex:route id=${recordRoute(route)} -->`);
+    return `[Sprag model routing] This request matches the approved shared ${rule.category} policy. ${SHARED_APPROVAL} ${SHARED_TIER_GUIDANCE}\n`
+      + `${targets.join('\n')}\n`
+      + 'Spawn at most one sub-agent with the selected model, reasoning_effort when specified, and fork_turns "none"; a full-history fork ignores the model. '
+      + 'Give it a self-contained task message with the selected cap that ends with that tier\'s route line only. '
+      + WAIT_TEXT;
+  }
+  const id = recordRoute(rule);
   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". `
     + `Give it a self-contained task message that ends with the line <!-- sprag:codex:route id=${id} -->. `
-    + 'Wait for it to finish (call wait_agent with timeout_ms of at least 120000, and again if it times out) and do not do the delegated task yourself while it runs; then verify its result and report unfinished work. Do not spawn another CLI process. '
-    + 'If sub-agent tools or the target model are unavailable, keep the task on the main agent and state that delegation was unavailable.';
+    + WAIT_TEXT;
 }
 
 function customRole(role, root, home) {
@@ -177,7 +268,15 @@ export function codexDelegationTool(payload, { cfg = {}, root = payload?.cwd ||
   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 routes = explicit ? [] : matchingRoutes(input.message, { model: payload.model, provider, root, start: payload.cwd, rules, cfg, dir });
+  // Only the caller can choose a shared policy's tier. A shared match without a
+  // model goes back to the caller with the mapped choices instead of a guessed
+  // downgrade, or a default target that ignores the tier.
+  if (routes[0]?.source === 'shared') {
+    return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny',
+      permissionDecisionReason: sharedDenyReason(routes) } };
+  }
+  const rule = routes[0] ?? null;
   const target = rule || (!explicit && cfg.codex?.delegateTarget);
   const updatedInput = { ...input };
   let routeLine = '';

package/src/codex-doc2md-ledger.js

@@ -1,8 +1,9 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { mkdirSync, readdirSync, readFileSync, writeFileSync, renameSync, realpathSync, statSync } from 'node:fs';
+import { mkdirSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { extname, join, resolve } from 'node:path';
 import { codexUserDir } from './agent.js';
 import { userDataDir } from './paths.js';
+import { writeViaTmp } from './state-file.js';
 import { readResetMarks, isBeforeReset } from './saved-reset.cjs';
 
 const hash = (value) => createHash('sha256').update(value).digest('hex');
@@ -22,8 +23,7 @@ export function recordCodexDocument(source, result, opts) {
       clipped: !!(meta.clipped || meta.truncated) };
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     const tmp = `${file}.${randomUUID()}.tmp`;
-    writeFileSync(tmp, JSON.stringify(event) + '\n', { mode: 0o600 });
-    renameSync(tmp, file);
+    writeViaTmp(tmp, file, JSON.stringify(event) + '\n', { mode: 0o600 });
   } catch { /* Accounting must not prevent document conversion. */ }
 }
 

package/src/codex-doctor.js

@@ -17,13 +17,13 @@ export const CODEX_CAPABILITIES = [
   { feature: 'korean', support: 'supported', command: 'sprag korean status --agent codex', note: 'Session guidance and recognized write-target lint; shared preference.' },
   { feature: 'cohesion', support: 'supported', command: 'sprag cohesion status --agent codex', note: 'Shared English guidance preference.' },
   { feature: 'doc2md', support: 'supported', command: 'sprag doc2md status --agent codex', note: 'Shared converter, prompt paths, supported file reads, and recognized document/cache write guards; not arbitrary shell extraction.' },
-  { feature: 'delegate', support: 'supported', command: 'sprag delegate on --agent codex', note: 'Opt-in native spawn model routing, scoped category rules, and SubagentStart guidance. Explicit models/custom roles preserved; no enforced budget.' },
+  { feature: 'delegate', support: 'supported', command: 'sprag delegate on --agent codex', note: 'Native routing and shared delegation policies with explicit Codex tier mappings. Explicit models/custom roles preserved; bounds are guidance, not enforced limits.' },
   { feature: 'routing-saved', support: 'partial', command: 'sprag route-scan savings --agent codex', note: 'Sprag-routed child usage with matching LiteLLM prices; counterfactual estimate, not billed savings. Unpriced runs stay unknown.' },
   { feature: 'cache-timer', support: 'partial', command: 'sprag cache status --refresh --agent codex', note: 'Documented minimum retention after recorded cache usage; LiteLLM deployments resolved through model/info. Unknown routes show age; exact expiry is not reported.' },
   { feature: 'mode', support: 'partial', command: 'sprag mode --agent codex', note: 'Labels, color, and timer apply to panel/statusline; Claude TTL buckets do not.' },
   { feature: 'upgrade', support: 'manual', command: 'sprag upgrade --print --agent codex', note: 'Skip the Claude npm postinstall; reinstall Codex hooks after upgrade.' },
   { feature: 'route-scan', support: 'supported', command: 'sprag route-scan --agent codex', note: 'Recurring simple turns grouped by project, provider, and parent model; explicit approval before routing.' },
-  { feature: 'seed', support: 'supported', command: 'sprag seed --agent codex', note: 'Agent-compatible ratchet presets; separate decisions and explicit scope. No Claude tier presets.' },
+  { feature: 'seed', support: 'supported', command: 'sprag seed --agent codex', note: 'Shared delegation policies plus agent-compatible ratchet presets. Explicit scope; Codex model mappings required. No Claude installation needed.' },
   { feature: 'transcript ratchet', support: 'supported', command: 'sprag --statusline --agent codex', note: 'Recent repeated tool failures become ratchet? candidates; no automatic rule registration.' },
   { feature: 'compact-window', support: 'native', note: 'Codex uses model_auto_compact_token_limit; no Claude autoCompactWindow heuristic.' },
   { feature: 'cost / exact cache expiry', support: 'unavailable', note: 'Not measured in rollout logs; never estimated with Anthropic prices.' },

package/src/codex-hooks.js

@@ -1,12 +1,13 @@
 import { createRequire } from 'node:module';
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { mkdirSync, openSync, readFileSync, readSync, closeSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { mkdirSync, openSync, readFileSync, readSync, closeSync, statSync } from 'node:fs';
 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 { writeViaTmp } from './state-file.js';
 import { findProjectRoot } from './harness.js';
 import { runCodexBrief } from './codex-brief.js';
 import { codexDocumentTool, codexDocumentNote, convertCodexDocument } from './codex-doc2md.js';
@@ -69,8 +70,7 @@ export function fitCodexContext(parts, { budget = CODEX_CONTEXT_TOKEN_BUDGET, ov
 function writeOverflow(file, text) {
   mkdirSync(join(file, '..'), { recursive: true, mode: 0o700 });
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync(tmp, text, { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, text, { mode: 0o600 });
 }
 
 function overflowFileFor(root) {
@@ -212,8 +212,7 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
       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 }));
+        parts.push(codexRouteHint(payload, { cfg, root: findProjectRoot(payload.cwd || process.cwd(), { agent: 'codex' }) }));
       } catch (e) { debug('codex:route-hint', e); }
     }
     if (cfg?.codex?.brief !== false) {

package/src/codex-installer.js

@@ -1,6 +1,7 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { codexUserDir } from './agent.js';
+import { writeViaTmp } from './state-file.js';
 
 export const CODEX_HANDLERS = {
   SessionStart: { matcher: 'startup|resume|clear|compact', command: 'sprag codex-hook --agent codex --event session-start', timeout: 15 },
@@ -72,8 +73,7 @@ export function configureCodexHooks({ remove = false, panelAuto } = {}) {
     mkdirSync(dirname(file), { recursive: true });
     if (existsSync(file)) writeFileSync(`${file}.bak-${Date.now()}`, readFileSync(file));
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
-    renameSync(tmp, file);
+    writeViaTmp(tmp, file, JSON.stringify(data, null, 2) + '\n');
   }
   return { file, action: remove ? 'removed' : 'configured' };
 }

package/src/codex-ledger.js

@@ -1,7 +1,8 @@
-import { appendFileSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomBytes, randomUUID } from 'node:crypto';
 import { userDataDir } from './paths.js';
+import { writeViaTmp } from './state-file.js';
 import { roundUsd } from './savings-ledger.js';
 import { readResetMarks, isBeforeReset } from './saved-reset.cjs';
 import { discoverCodexSessionFiles, parseCodexTurns } from './codex-parser.js';
@@ -52,8 +53,7 @@ export function pruneCodexDelegations({ dir = userDataDir(), now = Date.now() }
   try { all = readFileSync(pendingFile(dir), 'utf8').split('\n').filter(Boolean).length; } catch { return; }
   if (keep.length === all) return;
   const file = pendingFile(dir), tmp = `${file}.${randomUUID()}.tmp`;
-  writeFileSync(tmp, keep.map((r) => JSON.stringify(r) + '\n').join(''), { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, keep.map((r) => JSON.stringify(r) + '\n').join(''), { mode: 0o600 });
 }
 
 export function readCodexDelegations({ dir = userDataDir() } = {}) {
@@ -88,20 +88,24 @@ 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() } = {}) {
+/** When a later prompt closed each route no child had claimed. Kept in the binds file as `{ id, closed: true, at }` lines. */
+function closedCodexRouteTimes({ dir = userDataDir() } = {}) {
   let text;
-  try { text = readFileSync(bindsFile(dir), 'utf8'); } catch { return new Set(); }
-  const out = new Set();
+  try { text = readFileSync(bindsFile(dir), 'utf8'); } catch { return new Map(); }
+  const out = new Map();
   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);
+      if (b?.closed === true && /^[0-9a-f]{16}$/.test(b.id) && !out.has(b.id)) out.set(b.id, Number.isFinite(b.at) ? b.at : -Infinity);
     } catch { /* Partial trailing line. */ }
   }
   return out;
 }
 
+function closedCodexRouteIds(opts) {
+  return new Set(closedCodexRouteTimes(opts).keys());
+}
+
 /**
  * Close the routes this parent was hinted in an earlier turn and never spawned.
  *
@@ -142,6 +146,9 @@ export function bindCodexSubagent(payload, { dir = userDataDir(), now = Date.now
   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));
+  // Tiers one hint offered together can map to the same model; the model then
+  // cannot say which tier this child is. Leave it to the child's route marker.
+  if (chosen.offerId && pending.some((r) => r !== chosen && r.offerId === chosen.offerId)) return null;
   recordCodexBinding({ id: chosen.id, childSessionId: payload.agent_id, at: now }, { dir });
   return chosen.id;
 }
@@ -173,8 +180,7 @@ export function loadCodexLedger({ dir = userDataDir() } = {}) {
 function saveLedger(data, dir) {
   mkdirSync(dir, { recursive: true });
   const file = ledgerFile(dir), tmp = `${file}.${randomUUID()}.tmp`;
-  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
 }
 
 /**
@@ -221,6 +227,7 @@ export async function refreshCodexLedger({ dir = userDataDir(), home, now = Date
   if (!pending.length) return ledger;
   const byId = new Map(pending.map((r) => [r.id, r]));
   const bindMap = new Map(readCodexBindings({ dir }).filter((b) => byId.has(b.id)).map((b) => [b.childSessionId, b.id]));
+  const closedAt = closedCodexRouteTimes({ dir });
   const oldest = Math.min(...pending.map((r) => r.at));
   const files = await discoverCodexSessionFiles({ home, days: Math.max(1, (now - oldest) / 86400000 + 1) });
   let changed = false;
@@ -233,7 +240,14 @@ export async function refreshCodexLedger({ dir = userDataDir(), home, now = Date
     // The id must come from a spawn this parent made, after the record was written.
     if (!route || (route.parentSessionId && run.parentThreadId && route.parentSessionId !== run.parentThreadId)) continue;
     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 ||
+        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
+    // before the close can be its run; a later marker is a copy, not a spawn.
+    if (closedAt.has(route.id) && !(Number.isFinite(run.startedAt) && run.startedAt < closedAt.get(route.id))) continue;
     if (seen.has(route.id)) continue;
     seen.add(route.id);
     const to = run.model || route.to;
@@ -250,6 +264,7 @@ 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,
+      ...(route.source === 'shared' ? { tier: route.tier, sharedSignature: route.sharedSignature } : {}),
       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-session.js

@@ -1,5 +1,6 @@
-import { readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute } from 'node:path';
+import { writeViaTmp } from './state-file.js';
 
 export function createPanelBinding(file) {
   writeFileSync(file, JSON.stringify({ version: 1, sessionId: null, transcriptPath: null }), { mode: 0o600 });
@@ -27,9 +28,8 @@ export function bindPanelSession(event, payload, { file = process.env.SPRAG_CODE
     if (current.version !== 1) return false;
     if (payload.source === 'compact' && current.sessionId && current.sessionId !== payload.session_id) return false;
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify({ version: 1, sessionId: payload.session_id,
+    writeViaTmp(tmp, file, JSON.stringify({ version: 1, sessionId: payload.session_id,
       transcriptPath: typeof payload.transcript_path === 'string' && isAbsolute(payload.transcript_path) ? payload.transcript_path : null }), { mode: 0o600 });
-    renameSync(tmp, file);
     return true;
   } catch { return false; }
 }

package/src/codex-panel-state.js

@@ -1,8 +1,15 @@
 import { createHash } from 'node:crypto';
-import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { readFileSync, mkdirSync, readdirSync, lstatSync, unlinkSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { userDataDir } from './paths.js';
 import { codexUserDir } from './agent.js';
+import { writeViaTmp, runHousekeeping, sweepStaleTmp } from './state-file.js';
+
+// Every panel session leaves a `-frame` and a `-hook` file behind, keyed by a
+// hash that is not reused once the session is gone. They are diagnostics for a
+// live session, so a file untouched for a week describes one that is over.
+const PANEL_STATE_FILE = /^codex-panel-[0-9a-f]{64}-(?:frame|hook)\.json$/;
+export const PANEL_STATE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 
 export function panelStatePath(root, kind, dir = userDataDir(), sessionId) {
   const key = createHash('sha256').update(codexUserDir() + '\0' + resolve(root) + (sessionId ? `\0${sessionId}` : '')).digest('hex');
@@ -15,17 +22,56 @@ export function recordPanelState(root, kind, value, dir = userDataDir()) {
     const file = panelStatePath(root, kind, dir);
     const tmp = `${file}.${process.pid}.tmp`;
     const text = JSON.stringify({ ...value, at: new Date().toISOString() });
-    writeFileSync(tmp, text);
-    renameSync(tmp, file);
+    writeViaTmp(tmp, file, text);
     if (value.sessionId) {
       const sessionFile = panelStatePath(root, kind, dir, value.sessionId);
       const sessionTmp = `${sessionFile}.${process.pid}.tmp`;
-      writeFileSync(sessionTmp, text);
-      renameSync(sessionTmp, sessionFile);
+      writeViaTmp(sessionTmp, sessionFile, text);
     }
+    // A live panel records a frame every couple of seconds, so the clean-up is
+    // rate-limited to once a day (see runHousekeeping) rather than listing the
+    // directory on every write. This session's own files, of both kinds, are
+    // never candidates: a session that has run for over a week keeps writing
+    // frames while its hook record is just as old.
+    runHousekeeping(dir, {
+      'stale-tmp': () => sweepStaleTmp(dir),
+      'codex-panel': () => sweepPanelState({
+        dir,
+        keep: ['frame', 'hook'].flatMap((k) => [
+          panelStatePath(root, k, dir),
+          ...(value.sessionId ? [panelStatePath(root, k, dir, value.sessionId)] : []),
+        ]),
+      }),
+    });
   } catch { /* Diagnostics must not stop a session or panel. */ }
 }
 
+/**
+ * Remove panel state files untouched for `maxAgeMs`. Only the exact
+ * `codex-panel-<64 hex>-(frame|hook).json` shape is considered, and anything
+ * in `keep` (full paths) is left alone whatever its mtime.
+ *
+ * @returns {number} how many files were removed
+ */
+export function sweepPanelState({ dir = userDataDir(), now = Date.now(), maxAgeMs = PANEL_STATE_MAX_AGE_MS, keep = [] } = {}) {
+  let names;
+  try { names = readdirSync(dir); } catch { return 0; }
+  const protectedPaths = new Set(keep);
+  let removed = 0;
+  for (const name of names) {
+    if (!PANEL_STATE_FILE.test(name)) continue;
+    const path = join(dir, name);
+    if (protectedPaths.has(path)) continue;
+    try {
+      const st = lstatSync(path);
+      if (!st.isFile() || now - st.mtimeMs <= maxAgeMs) continue;
+      unlinkSync(path);
+      removed += 1;
+    } catch { /* already gone, or not ours to remove */ }
+  }
+  return removed;
+}
+
 export function readPanelState(root, kind, dir = userDataDir(), sessionId) {
   try { return JSON.parse(readFileSync(panelStatePath(root, kind, dir, sessionId), 'utf8')); }
   catch { return null; }

package/src/codex-route-scan.js

@@ -1,13 +1,14 @@
-import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { readFileSync, mkdirSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { userDataDir } from './paths.js';
+import { writeViaTmp } from './state-file.js';
 import { loadConfig } from './config.js';
 import { findProjectRoot } from './harness.js';
 import { discoverCodexSessionFiles, parseCodexTurns } from './codex-parser.js';
 import { categorize, isSkippable, tierOf, calibrateThresholds, MIN_RECURRENCE,
   RESCAN_MIN_INTERVAL_MS, RESCAN_BIG_DELTA_BYTES, RESCAN_MAX_AGE_MS } from './route-scan.js';
-import { codexPromptCategory, loadCodexModelRules } from './codex-delegation.js';
+import { codexPromptCategory, loadCodexModelRules, sharedCodexModelRules, codexSharedTargets } from './codex-delegation.js';
 import { codexRunCost, codexPriceBook, isDirectOpenAI, readCodexPrices } from './codex-cache-policy.js';
 import { OPENAI_PRICES_CHECKED_AT } from './openai-prices.js';
 import { refreshCodexLedger } from './codex-ledger.js';
@@ -32,8 +33,7 @@ export function readCodexRouteScan({ dir = userDataDir() } = {}) {
 function writeCache(data, dir) {
   mkdirSync(dir, { recursive: true });
   const file = cacheFile(dir), tmp = `${file}.${randomUUID()}.tmp`;
-  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
 }
 
 /** Candidates not yet approved or dismissed; with `root`, only that project's. */
@@ -149,15 +149,20 @@ export async function runCodexRouteScan({ days = 14, now = Date.now(), home, dir
   }
   let rules = [];
   try { rules = loadCodexModelRules({ dir }); } catch { /* An unreadable rule file only means candidates may repeat. */ }
-  const covered = (g) => rules.some((r) => r.category === g.category && r.from === g.from &&
-    (!r.provider || r.provider === g.provider) &&
-    (r.scope === 'global' || r.targetRoot === g.projectRoot));
+  const covered = (g) => {
+    if (rules.some((r) => r.category === g.category && r.from === g.from &&
+        (!r.provider || r.provider === g.provider) &&
+        (r.scope === 'global' || r.targetRoot === g.projectRoot))) return true;
+    const shared = sharedCodexModelRules({ cfg, dir, root: g.projectRoot, model: g.from, provider: g.provider });
+    return ['T1', 'T2'].every((tier) => !g.tiers[tier] || shared.some((r) => r.category === g.category && r.tier === tier));
+  };
   const known = new Set([...observed, ...rules.filter((r) => r.provider).map((r) => `${r.provider}|${r.model}`)]);
   const target = cfg?.codex?.delegateTarget?.model;
   if (target) {
     if (prices?.provider) known.add(`${prices.provider}|${target}`);
     if (isDirectOpenAI('openai', { home })) known.add(`openai|${target}`);
   }
+  for (const target of codexSharedTargets(cfg)) known.add(`${target.provider}|${target.model}`);
   const prev = readCodexRouteScan({ dir });
   const resolved = new Set(prev?.resolved || []);
   const candidates = [...groups.values()]

package/src/commands/brief.js

@@ -49,7 +49,7 @@ export async function run({ hasFlag }) {
       // differ. Claude Code sends `cwd` for that reason and the PreToolUse hook
       // already reads it (src/delegation-guard.js). A payload without the field
       // leaves root undefined, which is the behaviour this had before.
-      const match = routeMatch(ctx.prompt, { sessionRank });
+      const match = routeMatch(ctx.prompt, { sessionRank, root: ctx.cwd });
       const hint = routeHint(ctx.prompt, { sessionRank, root: ctx.cwd, match });
       if (hint) parts.push(hint);
       // The delegation guard repeats these caps to the subagent, so the limit it