sprag-cli 3.61.0 → 3.62.0

package/docs/CODEX.ko.md

@@ -158,19 +158,29 @@ Claude를 설치하지 않은 Codex 첫 사용자도 기록을 쌓기 전에 프
 sprag seed --agent codex
 sprag seed accept all --global --agent codex
 sprag delegate shared status --agent codex
+sprag delegate on --agent codex
+# 자동으로 정해진 난도별 모델을 바꾸고 싶을 때만:
 sprag delegate shared map T2 --from PARENT_MODEL --model SMALL_MODEL --effort high --agent codex
 sprag delegate shared map T1 --from PARENT_MODEL --model MEDIUM_MODEL --effort medium --agent codex
-sprag delegate on --agent codex
 ```
 
 등록 전에 전역과 프로젝트 범위를 선택합니다. 프로젝트에만 적용하려면 `--global` 대신
-`--project`를 지정하십시오. 위 모델명은 예시 자리표시자이므로, 공급자에서 사용할 수 있고
-부모보다 저렴한 실제 모델 ID로 바꿔야 합니다. 매핑을 저장했다는 사실만으로 사용 가능 여부나
-절감 효과를 확인한 것은 아닙니다. 공급자는 Codex 설정에서 읽으며 `--provider ID`로 지정할 수도 있습니다.
-
-매핑은 출발 모델·공급자·난도가 일치할 때만 적용하고, 한 번 지정하면 승인된 모든 작업 유형에서
-사용합니다. 매핑하지 않은 난도는 메인 모델이 처리합니다. Codex에서 승인할 때 `.claude` 파일은
-만들지 않으며, 나중에 Claude를 시작하면 같은 정책을 Claude용 모델 표기로 생성합니다.
+`--project`를 지정하십시오.
+
+`map` 줄은 선택 사항입니다. 매핑하지 않은 난도는 Claude Code가 `haiku`와 `sonnet`을 실제 모델로
+풀듯이 자동으로 정해집니다. 부모 모델의 공급자에서 가격이 매겨져 있고(게이트웨이 `/model/info` 가격,
+OpenAI 직접 호출이면 공개 가격), 부모보다 싸며, 이 사용자의 Codex 세션에서 이미 실행된 모델 가운데
+가장 싼 모델이 T2, 그다음 모델이 T1이 됩니다. 그런 모델이 하나뿐이면 T1은 메인 모델이 처리하고, 하나도
+없으면 두 난도 모두 메인 모델이 처리합니다. 자동 결정은 `delegate on` 상태에서만 동작하고, route-scan이
+기록한 실행 모델을 쓰며, 아무것도 저장하지 않으므로 가격이나 실행 이력이 바뀌면 그대로 따라갑니다.
+`delegate shared status`와 설치 출력에 정해진 모델이 표시되고, 정해지지 않으면 그 이유가 표시됩니다.
+끄려면 `sprag delegate shared auto off --agent codex`를 실행하십시오.
+
+명시한 매핑은 해당 난도에서 자동 결정보다 우선합니다. 매핑은 출발 모델·공급자·난도가 일치할 때만
+적용하고, 한 번 지정하면 승인된 모든 작업 유형에서 사용합니다. 공급자는 Codex 설정에서 읽으며
+`--provider ID`로 지정할 수도 있습니다. 매핑이나 자동 결정만으로 절감 효과를 확인한 것은 아닙니다.
+Codex에서 승인할 때 `.claude` 파일은 만들지 않으며, 나중에 Claude를 시작하면 같은 정책을 Claude용
+모델 표기로 생성합니다.
 
 프롬프트 훅은 단순 작업에 T2, 여러 단계가 필요한 작업에 T1을 제시하고, 매핑된 난도마다 route 줄을
 따로 줍니다. 부모는 작업에 맞는 모델 하나를 선택하고 독립적인 작업 명세, 상한, `fork_turns "none"`과

package/docs/CODEX.md

@@ -223,16 +223,27 @@ A Codex-first user needs no Claude installation or transcript history:
 sprag seed --agent codex
 sprag seed accept all --global --agent codex  # or --project, after choosing scope
 sprag delegate shared status --agent codex
+sprag delegate on --agent codex
+# optional, to override the automatic tier models:
 sprag delegate shared map T2 --from PARENT_MODEL --model SMALL_MODEL --effort high --agent codex
 sprag delegate shared map T1 --from PARENT_MODEL --model MEDIUM_MODEL --effort medium --agent codex
-sprag delegate on --agent codex
 ```
 
-Replace the model placeholders with available, lower-cost models from your
-provider; mappings do not prove availability or savings. Each mapping applies
-to one exact parent model, provider, and tier, across every approved category.
-`--provider ID` overrides the provider read from Codex config. Without a mapping,
-that tier stays on the main agent. No Haiku/Sonnet-to-GPT equivalence is assumed.
+The map lines are optional. A tier without a mapping resolves automatically,
+the way Claude Code resolves `haiku` and `sonnet`: the cheapest model that is
+priced on the parent's provider (gateway `/model/info` prices, or OpenAI list
+prices for direct calls), costs less than the parent, and has already run in
+your Codex sessions becomes T2, and the next one up becomes T1. With a single
+such model T1 stays on the main agent; with none, both do. Resolution needs
+`delegate on`, uses the route scan's observed models, and follows price or
+history changes without storing anything. `delegate shared status` and the
+install output show the resolved models and, when nothing resolves, why.
+`sprag delegate shared auto off --agent codex` turns it off.
+
+An explicit mapping wins for its tier. Each one applies to one exact parent
+model, provider, and tier, across every approved category; `--provider ID`
+overrides the provider read from Codex config. Mappings and automatic choices
+do not prove savings, and no Haiku/Sonnet-to-GPT equivalence is assumed.
 Codex seed acceptance writes the common registry without creating `.claude`;
 Claude renders its own view when it is installed or starts later.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.61.0",
+  "version": "3.62.0",
   "description": "Lower your Claude Code bill without changing how you work: simple tasks go to cheaper models, documents go in as compact Markdown, and the statusline shows spend and savings live. Works with Codex too.",
   "type": "module",
   "bin": {

package/src/codex-delegation.js

@@ -11,6 +11,8 @@ 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';
+import { codexPriceBook, readCodexPrices } from './codex-cache-policy.js';
+import { codexRunCost } from './gateway-prices.js';
 
 export const CODEX_ROUTE_CATEGORIES = ['paste', 'translate', 'explore', 'read', 'check', 'run'];
 const MARKER = '<!-- sprag:codex:delegation -->';
@@ -41,10 +43,59 @@ export function codexSharedTargets(cfg) {
   });
 }
 
-export function sharedCodexModelRules({ cfg = loadConfig(), dir = userDataDir(), root, start = root,
+// A request of this shape (input to output about 5:1) ranks models by price.
+const RANKING_USAGE = { input: 10000, output: 2000 };
+const routeScanFile = (dir) => join(dir, 'codex-route-scan.json');
+
+function observedCodexModels(dir, provider) {
+  try {
+    const data = JSON.parse(readFileSync(routeScanFile(dir), 'utf8'));
+    const prefix = `${provider}|`;
+    return (Array.isArray(data?.observedModels) ? data.observedModels : [])
+      .filter((key) => typeof key === 'string' && key.startsWith(prefix)).map((key) => key.slice(prefix.length));
+  } catch { return []; }
+}
+
+/**
+ * The models Codex resolves T2 and T1 to when the user mapped none, the way
+ * Claude Code resolves `haiku` and `sonnet`. Only a model that is priced on the
+ * parent's provider, costs less than the parent, and has already run in this
+ * user's Codex sessions qualifies, so the hint never names a model the gateway
+ * cannot serve. The cheapest is T2 and the next one up is T1; with a single
+ * candidate T1 stays on the main agent. Returns { targets, reason }.
+ */
+export function autoCodexSharedTargets({ dir = userDataDir(), home = codexUserDir(), model, provider, now = Date.now() } = {}) {
+  if (!safeId(model) || !safeId(provider)) return { targets: [], reason: 'unknown parent model or provider' };
+  const book = codexPriceBook(provider, readCodexPrices({ now, home, dir }), { home });
+  if (!book) return { targets: [], reason: `no price table for ${provider}` };
+  const cost = (m) => codexRunCost(RANKING_USAGE, book.prices[m]);
+  const parent = cost(model);
+  if (parent === null) return { targets: [], reason: `${model} is not priced on ${provider}` };
+  const cheaper = [...new Set(observedCodexModels(dir, provider))]
+    .filter((m) => m !== model && safeId(m)).map((m) => ({ model: m, usd: cost(m) }))
+    .filter((x) => x.usd !== null && x.usd < parent).sort((a, b) => a.usd - b.usd || a.model.localeCompare(b.model));
+  if (!cheaper.length) return { targets: [], reason: `no cheaper priced model has run in your Codex sessions on ${provider}` };
+  const targets = cheaper.slice(0, 2).map((x, i) => ({ tier: i === 0 ? 'T2' : 'T1', from: model, model: x.model, provider, auto: true }));
+  return { targets, reason: null };
+}
+
+/**
+ * Explicit mappings win per tier. Without one, a tier resolves automatically
+ * unless the user turned that off; resolution runs only for an enabled Codex
+ * delegation, so a caller without the hook's config never routes by accident.
+ */
+export function codexTierTargets({ cfg = loadConfig(), dir = userDataDir(), home = codexUserDir(), model, provider = codexProviderName() } = {}) {
+  const explicit = codexSharedTargets(cfg).filter((t) => t.from === model && t.provider === provider);
+  if (cfg.codex?.delegate !== true || cfg.codex?.sharedRules?.auto === false) return explicit;
+  const auto = autoCodexSharedTargets({ dir, home, model, provider }).targets
+    .filter((t) => !explicit.some((e) => e.tier === t.tier));
+  return [...explicit, ...auto];
+}
+
+export function sharedCodexModelRules({ cfg = loadConfig(), dir = userDataDir(), home = codexUserDir(), 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);
+  const targets = codexTierTargets({ cfg, dir, home, model, 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' }] : [];
@@ -210,7 +261,7 @@ export function codexRouteHint(payload, opts = {}) {
       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 } : {}) }
+        ...(shared ? { tier: route.tier, sharedSignature: route.sharedSignature, ...(offerId ? { offerId } : {}), ...(route.auto ? { mapping: 'auto' } : {}) }
           : { ruleCreatedAt: route.createdAt ?? null }) }, { dir: opts.dir });
     } catch { /* Accounting is optional; the hint still applies. */ }
     return id;
@@ -268,7 +319,7 @@ 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 routes = explicit ? [] : matchingRoutes(input.message, { model: payload.model, provider, root, start: payload.cwd, rules, cfg, dir });
+  const routes = explicit ? [] : matchingRoutes(input.message, { model: payload.model, provider, root, start: payload.cwd, rules, cfg, dir, home });
   // 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.

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: 'Native routing and shared delegation policies with explicit Codex tier mappings. Explicit models/custom roles preserved; bounds are guidance, not enforced limits.' },
+  { feature: 'delegate', support: 'supported', command: 'sprag delegate on --agent codex', note: 'Native routing and shared delegation policies; tier models resolve from priced models already run in Codex, or from explicit 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: 'Shared delegation policies plus agent-compatible ratchet presets. Explicit scope; Codex model mappings required. No Claude installation needed.' },
+  { feature: 'seed', support: 'supported', command: 'sprag seed --agent codex', note: 'Shared delegation policies plus agent-compatible ratchet presets. Explicit scope; tier models resolve automatically or by mapping. 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/commands/codex-delegate.js

@@ -1,7 +1,8 @@
 import { loadConfig, saveConfig } from '../config.js';
 import { configureCodexHooks } from '../codex-installer.js';
 import { validateCodexTarget, loadCodexModelRules, addCodexModelRule, removeCodexModelRule,
-  validateCodexSharedTarget, codexSharedTargets, codexDelegateMinContext, DEFAULT_DELEGATE_MIN_CONTEXT } from '../codex-delegation.js';
+  validateCodexSharedTarget, codexSharedTargets, codexDelegateMinContext, DEFAULT_DELEGATE_MIN_CONTEXT,
+  autoCodexSharedTargets } 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';
@@ -23,13 +24,23 @@ function printShared(cfg, { details = false } = {}) {
     for (const t of targets) console.log(`${t.provider} | ${t.from} | ${t.tier} -> ${t.model}${t.effort ? ` (${t.effort})` : ''}`);
   }
   // A mapping routes only sessions on the parent model it names, so a tier
-  // mapped for another model still leaves the configured model unrouted.
-  const mapped = (tier) => targets.some((t) => t.provider === provider && t.tier === tier && (!parent || t.from === parent));
-  const missing = [...new Set(policies.map((r) => r.tier))].filter((tier) => !mapped(tier));
+  // mapped for another model still leaves the configured model unrouted. A tier
+  // without one resolves automatically, the way Claude Code resolves haiku/sonnet.
+  const own = (tier) => targets.find((t) => t.provider === provider && t.tier === tier && (!parent || t.from === parent));
+  const autoOn = cfg.codex?.sharedRules?.auto !== false;
+  const auto = autoOn && parent ? autoCodexSharedTargets({ model: parent, provider }) : { targets: [], reason: autoOn ? 'Codex config names no default model' : 'off' };
+  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)' : ''}`);
+  }
+  const missing = tiers.filter((tier) => !own(tier) && !auto.targets.some((a) => a.tier === tier));
   if (missing.length) {
-    console.log(`Unmapped tiers for ${parent || 'any parent model'} on ${provider || 'unknown provider'}: ${missing.join(', ')}. `
+    console.log(`Unmapped tiers for ${parent || 'any parent model'} on ${provider || 'unknown provider'}: ${missing.join(', ')}`
+      + `${autoOn && auto.reason ? ` (auto: ${auto.reason})` : ''}. `
       + `Set: sprag delegate shared map <T1|T2> --from ${parent || '<parent-model>'} --model <target-model> --agent codex`);
   }
+  console.log(`Automatic tier models: ${autoOn ? 'on' : 'off'} (turn ${autoOn ? 'off' : 'on'}: sprag delegate shared auto ${autoOn ? 'off' : 'on'} --agent codex)`);
   if (!parent && targets.length) console.log('Codex config names no default model; each mapping routes only sessions on its --from model.');
   const minimum = codexDelegateMinContext(cfg);
   console.log(`Shared prompt guidance starts at ${minimum} parent input tokens${cfg.codex?.delegateMinContext === minimum ? '' : ' (default)'}. `
@@ -48,8 +59,8 @@ export function run({ args, getArg, hasFlag, root }) {
   const cfg = loadConfig();
   if (sub === 'shared') {
     const action = args[2] || 'status';
-    if (!['status', 'on', 'off', 'map', 'unmap', 'min-context'].includes(action)) {
-      throw new Error('Usage: delegate shared status|on|off|map <T1|T2>|unmap <T1|T2>|min-context <tokens|default> --agent codex');
+    if (!['status', 'on', 'off', 'map', 'unmap', 'min-context', 'auto'].includes(action)) {
+      throw new Error('Usage: delegate shared status|on|off|map <T1|T2>|unmap <T1|T2>|min-context <tokens|default>|auto on|off --agent codex');
     }
     if (hasFlag('--global') || hasFlag('--project')) throw new Error('Shared policies retain their approved scope; mappings do not change it.');
     const provided = (flag) => args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
@@ -71,6 +82,9 @@ export function run({ args, getArg, hasFlag, root }) {
         if (!targets.some(same)) throw new Error('No matching shared tier mapping; specify --from and the correct provider.');
         cfg.codex = { ...cfg.codex, sharedRules: { ...cfg.codex?.sharedRules, targets: targets.filter((t) => !same(t)) } };
       }
+    } else if (action === 'auto') {
+      if (!['on', 'off'].includes(args[3])) throw new Error('Usage: delegate shared auto on|off --agent codex');
+      cfg.codex = { ...cfg.codex, sharedRules: { ...cfg.codex?.sharedRules, auto: args[3] === 'on' } };
     } else if (action === 'min-context') {
       const value = args[3];
       if (value === 'default') {

package/src/commands/codex.js

@@ -32,6 +32,7 @@ Usage: sprag <command> --agent codex [options]
                                 Optional --provider <id> and --effort <level>
   delegate shared unmap T1|T2   Remove a mapping: --from <parent> [--provider <id>]
   delegate shared min-context N Parent input tokens before shared guidance; default resets
+  delegate shared auto on|off   Resolve unmapped tiers from priced models already run in Codex
   route-scan [--refresh]         Discover recurring simple turns in local logs
   route-scan dismiss R<N>       Dismiss a candidate without registering a rule
   route-scan savings            Attributed routing estimates; --refresh or --format json
@@ -418,7 +419,16 @@ export async function run({ args, version }) {
     console.log('After approval, start or resume Codex and run: sprag panel doctor --agent codex');
     if (panel.mode === 'window') console.log('Some Codex versions defer SessionStart until the first prompt. For immediate opening on typing codex: sprag panel shell install --agent codex (optional zsh integration).');
     console.log('Existing config.toml, Claude Code settings, and ratchet rules are preserved.');
-    console.log('First-use delegation: sprag seed --agent codex, then sprag delegate shared status --agent codex. Approve a scope and map the tiers before enabling delegation. No Claude installation is required.');
+    try {
+      const { codexModelName, codexProviderName } = await import('../agent.js');
+      const { autoCodexSharedTargets } = await import('../codex-delegation.js');
+      const parent = codexModelName(), provider = codexProviderName();
+      const auto = parent ? autoCodexSharedTargets({ model: parent, provider }) : { targets: [], reason: 'Codex config names no default model' };
+      console.log(auto.targets.length
+        ? `Delegation tiers for ${parent} on ${provider} (auto): ${auto.targets.map((t) => `${t.tier} -> ${t.model}`).join(', ')}. Change: sprag delegate shared status --agent codex`
+        : `Delegation tiers: not resolved yet (${auto.reason}). They resolve once a cheaper priced model has run in Codex, or map one: sprag delegate shared map T2 --from <parent> --model <target> --agent codex`);
+    } catch (e) { debug('codex:auto-tiers', e); }
+    console.log('First-use delegation: sprag seed --agent codex to approve policies, then sprag delegate on --agent codex. No Claude installation is required.');
     console.log('Korean guidance is opt-in: sprag korean on --agent codex');
     return;
   }

package/src/seed-rules.js

@@ -150,8 +150,8 @@ export function pendingSeeds({ lang = userLanguage(), root = findProjectRoot(),
 
 function codexSeedText(p, lang) {
   const text = lang === 'ko'
-    ? `"${p.label}" 유형의 ${p.tier === 'T2' ? '단순' : '중간 난도'} 작업은 ${p.tier}에 위임합니다. 실행 모델은 Codex 매핑에서 정합니다.`
-    : `${p.tier === 'T2' ? 'Simple' : 'Moderate'} "${p.labelEn}" tasks use ${p.tier}. The execution model comes from the Codex mapping.`;
+    ? `"${p.label}" 유형의 ${p.tier === 'T2' ? '단순' : '중간 난도'} 작업은 ${p.tier}에 위임합니다. 실행 모델은 Codex가 자동으로 정하거나 매핑으로 지정합니다.`
+    : `${p.tier === 'T2' ? 'Simple' : 'Moderate'} "${p.labelEn}" tasks use ${p.tier}. Codex resolves the execution model automatically or from a mapping.`;
   return composeRuleText(text, p, lang);
 }
 
@@ -292,7 +292,7 @@ export function seedOfferBlock({ lang = userLanguage(), root = findProjectRoot()
       '  3. Decide one at a time: ask about each rule below and run its command as soon as they answer',
       `  4. Register none: ${cmd('skip all')} (never offered again)`,
       'Always confirm the scope with the user before running an accept command.',
-      'Delegation policies are shared across Claude and Codex; approval retains the chosen scope. Codex execution also requires delegate on and explicit tier mappings: sprag delegate shared status --agent codex. Never assume Claude model names are Codex models.',
+      'Delegation policies are shared across Claude and Codex; approval retains the chosen scope. Codex execution also requires delegate on; tier models resolve from cheaper priced models already run in Codex, or from mappings: sprag delegate shared status --agent codex. Never assume Claude model names are Codex models.',
       ...pending.map((s) => `  [${s.id}] ${s.ruleText}`),
     ].join('\n');
   }