sprag-cli 3.60.0 → 3.62.0

package/docs/CODEX.ko.md

@@ -122,10 +122,10 @@ Codex 0.159.2에서는 `spawn_agent`가 `PreToolUse`를 거치지 않습니다(
 
 이 안내는 부모 세션의 컨텍스트가 `codex.delegateMinContext`(기본 60000 토큰) 아래면 붙지
 않습니다. 2026-09-30 실측에서 작은 세션은 스폰·대기·검증이라는 조율 비용이 자식이 아끼는
-비용보다 커서, 문턱 아래에서는 안내를 붙이는 쪽이 오히려 손해였습니다. 아직 전용 CLI 명령은
-없고, `sprag mode` 실행 시 "Stored config file"로 나오는 설정 파일(맥은
-`~/Library/Application Support/claude-token-saver/config.json`)에서 `codex.delegateMinContext`
-값을 직접 고치면 됩니다. `PreToolUse` 재작성은 spawn을 훅으로 보내는 Codex 버전을 위해 남아
+비용보다 커서, 문턱 아래에서는 안내를 붙이는 쪽이 오히려 손해였습니다. 기준은
+`sprag delegate shared min-context <토큰 수|default> --agent codex`로 바꾸고, 현재 값은
+`delegate shared status`에서 확인합니다. 이 값은 `sprag mode`가 "Stored config file"로 알려 주는
+설정 파일에 `codex.delegateMinContext`로 저장됩니다. `PreToolUse` 재작성은 spawn을 훅으로 보내는 Codex 버전을 위해 남아
 있을 뿐, 0.159.2에서는 호출되지 않습니다. 위임 원장은 자식이 쓴 토큰을 부모 모델 단가로 환산한
 추정치이며, 부모가 조율에 쓴 턴은 빼지 않습니다. 끝나기 전에 중단된 자식은 부모의 일을 대신하지
 못했으므로, 그 비용 전액을 손실로 기록하고 항목에 `aborted`를 표시합니다.
@@ -139,8 +139,81 @@ Codex 0.159.2는 훅 하나가 넘긴 컨텍스트를 약 2,450토큰까지만
 못한 룰과 지침은 Sprag 데이터 디렉터리의 프로젝트별 파일에 쓰고, 컨텍스트 첫머리에서 그 파일을
 먼저 읽으라고 안내합니다. rollout의 `originator`로 `codex exec` 실행을 알아보며, 답할 사람이
 없으므로 seed 제안과 route 안내를 넣지 않습니다.
- `seed`는 Claude의 Haiku·Sonnet 프리셋을 가져오지 않으며,
-Codex의 수락·거절 기록도 Claude 기록과 분리합니다.
+
+`seed`는 공통 위임 정책과 Codex용 래칫 프리셋을 제안합니다.
+래칫과 거절 기록은 도구별로 분리하지만, 승인된 공통 정책은 원래 범위 안에서 중복 제안하지 않습니다.
+
+### 공통 위임 정책
+
+작업 유형, T1·T2 난도, 적용 범위와 상한은 Claude와 Codex가 같은 `model-rules.json`에서
+읽습니다. 기존 Claude 활성 규칙도 복사 없이 표시하며, 삭제되거나 비활성·검토 상태인 규칙은
+Codex에서 위임에 사용하지 않습니다. 프로젝트 정책은 작업 디렉터리에 대해 두 도구가 각각 정하는
+프로젝트 루트 가운데 하나와 일치하면 적용합니다. Claude는 `CLAUDE.md`에서, Codex는 `AGENTS.md`에서
+루트를 정하며, 정책의 루트와 작업 디렉터리의 루트는 심볼릭 링크를 푼 실제 경로로 비교합니다. 모델 ID, 역할, 사용량과 절감액은
+도구별로 유지합니다.
+
+Claude를 설치하지 않은 Codex 첫 사용자도 기록을 쌓기 전에 프리셋을 승인할 수 있습니다.
+
+```sh
+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
+```
+
+등록 전에 전역과 프로젝트 범위를 선택합니다. 프로젝트에만 적용하려면 `--global` 대신
+`--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"`과
+선택한 난도의 route 줄만 전달한 뒤 결과를 기다려 검증합니다. `fork_turns "none"`은 반드시 지정해야
+합니다. 전체 기록을 넘기는 포크는 부모 모델을 그대로 물려받아 모델 지정을 무시하기 때문입니다.
+Codex는 사용자가 요청할 때만 스폰 모델을 지정하므로, 안내 문구는 사용자가 정책과 매핑을 승인했다는
+사실을 함께 밝힙니다.
+
+제시한 난도는 각각 프롬프트 route로 기록합니다. 이 경로는 `spawn_agent`가 `PreToolUse`를 거치지 않는
+Codex 0.159.2에서 Codex 전용 규칙이 쓰는 경로와 같습니다. SubagentStart는 자식이 실행하는 모델과 같은
+route에 자식을 연결하고, 부모에게 다음 프롬프트가 들어오면 고르지 않은 난도의 route를 닫습니다. 그래서
+제시만 하고 연결된 자식이 없는 난도는 실행으로 집계하지 않습니다. `PreToolUse`가 실행되는 버전에서는
+공통 정책에 해당하는 스폰이 모델을 지정하지 않으면 스폰 훅이 매핑된 선택지를 알려 주며 그 스폰을
+거부하고, 난도는 부모가 고릅니다. 스폰 훅은 난도를 임의로 정하거나 명시된 모델·사용자 정의 역할을
+덮어쓰지 않으며, 부모가 자기 모델을 명시하면 작업은 그 모델에 남습니다.
+
+공통 정책 안내도 앞에서 설명한 Codex 전용 규칙과 같은 컨텍스트 기준을 따릅니다. 이 기준은 모델의
+컨텍스트 창 크기를 바꾸지 않으며, 컨텍스트 기록이 없으면 안내하지 않습니다. 매핑은 지정한 출발 모델의 세션에만 적용되므로,
+`status`는 Codex 설정의 기본 모델을 기준으로 빠진 매핑을 알려 줍니다.
+
+```sh
+sprag delegate rules --agent codex
+sprag delegate shared off --agent codex
+sprag delegate shared on --agent codex
+sprag delegate shared unmap T2 --from PARENT_MODEL --agent codex
+sprag delegate shared min-context 30000 --agent codex
+```
+
+`shared off`는 공통 정책과 매핑을 보존하며 Codex 전용 규칙에는 영향을 주지 않습니다.
+`unmap`은 해당 Codex 매핑만 제거합니다. 공통 정책은 `sprag route-scan rules [rm N]`에서
+관리하며, 원본 삭제는 두 도구에 반영됩니다. Codex 실행 기록에는 원본 규칙 식별자와 난도를
+남기지만 사용량·절감액을 Claude 통계에 더하지 않습니다. 안내 생성만으로 실행을 집계하지 않으며,
+route 표지 또는 SubagentStart 연결이 매핑된 모델로 실행한 실제 자식 세션과 일치해야 기록을 연결합니다.
 
 ## 래칫 규칙
 

package/docs/CODEX.md

@@ -176,11 +176,11 @@ The hint is withheld below `codex.delegateMinContext` (default 60000 input
 tokens, read from the parent's own rollout). Measured 2026-09-30: a small
 parent session spends more on the coordinating turn (spawning, waiting,
 verifying) than a delegated child saves, so under the floor Sprag leaves the
-request on the main agent instead of proposing a loss. There is no CLI flag for
-it yet; set it by editing `codex.delegateMinContext` (an integer) in the config
-file `sprag mode` prints under "Stored config file" (`~/Library/Application
-Support/claude-token-saver/config.json` on macOS, `$XDG_CONFIG_HOME/claude-token-saver/config.json`
-or `~/.config/claude-token-saver/config.json` on Linux).
+request on the main agent instead of proposing a loss. Change it with
+`sprag delegate shared min-context <tokens|default> --agent codex`;
+`delegate shared status` shows the current value. It is stored as
+`codex.delegateMinContext` in the config file `sprag mode` prints under
+"Stored config file".
 
 The `PreToolUse` rewrite (native `spawn_agent` arguments using Codex's
 `message`, `model`, and `reasoning_effort` fields, preserving explicit model
@@ -204,7 +204,87 @@ spawns without an explicit model. Category rules (`paste`, `translate`, `explore
 `read`, `check`, `run`) reuse Sprag's classifier and escalation gates, require an
 exact parent model, and prefer project rules over global rules. Matching prompts
 request native delegation; unavailable subagent tools leave work on the main
-agent. Claude tier presets and history are not imported.
+agent. Codex-only rules take precedence over shared policies.
+
+### Shared Delegation Policies
+
+Work categories, T1/T2 difficulty, scope, and caps use the same
+`model-rules.json` registry in Claude Code and Codex. Existing active Claude
+policies are visible immediately; there is no copy or migration. Deleted,
+disabled, and review-state policies are not routed by Codex. Project policies
+remain project-scoped. A project policy applies when its root is the root either
+agent assigns to the working directory (Claude stops at `CLAUDE.md`, Codex at
+`AGENTS.md`), compared as real paths. Model IDs, roles, usage, and savings are
+not shared.
+
+A Codex-first user needs no Claude installation or transcript history:
+
+```sh
+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
+```
+
+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.
+
+The prompt hook offers T2 for a simple bounded task and T1 for multi-step work,
+and gives each mapped tier its own route line. The caller chooses at most one
+model and passes a self-contained task, the cap, `fork_turns "none"`, and only
+the chosen tier's route line. `fork_turns "none"` is required: a full-history
+fork inherits the parent model and ignores a model override. The hint states
+that the user approved the policy and mapping, because Codex sets a spawn model
+only on the user's request. The parent waits for and verifies the result.
+
+Each offered tier is recorded as a prompt route, the same path Codex-only rules
+use on Codex 0.159.2, where `spawn_agent` bypasses `PreToolUse`. SubagentStart
+binds the child to the route whose model it runs, and the parent's next prompt
+closes the tier it did not choose, so an offered tier never counts as a run
+without a matching child. Where `PreToolUse` does run, a spawn that matches a
+shared policy without naming a model is denied with the mapped choices so the
+caller picks the tier. The spawn hook does not guess difficulty or override an
+explicit model or custom role, and naming the parent's own model keeps the task
+on that model.
+
+Shared hints use the same context gate as Codex-only rules, described above;
+it does not change any model's context window, and missing context stays below
+the gate. `status` checks mappings against the default model in Codex config, because a
+mapping routes only sessions on the parent model it names.
+
+```sh
+sprag delegate rules --agent codex
+sprag delegate shared off --agent codex
+sprag delegate shared on --agent codex
+sprag delegate shared unmap T2 --from PARENT_MODEL --agent codex
+sprag delegate shared min-context 30000 --agent codex
+```
+
+`shared off` retains policies and mappings and leaves Codex-only rules intact.
+`unmap` removes only that Codex mapping. Edit/remove common policies through
+`sprag route-scan rules [rm N]`; removal affects both consumers. Codex routing
+records retain the source policy signature and tier, but their token and savings
+totals never enter Claude's statistics. A hint is not proof that a child ran:
+accounting requires the route marker or a SubagentStart binding to a matching
+child rollout that ran the mapped model.
 
 The routing ledger (`Routing Saved` below) prices a child's own tokens at the
 parent model's rate as the counterfactual; it does not charge or subtract the
@@ -279,8 +359,10 @@ the context opens with an instruction to read it. `codex exec` runs, recognized
 from the rollout's `originator`, get no seed offer or route notice, since no one
 can answer them.
 
-`seed` offers only compatible ratchet presets, not Claude model-tier presets.
-Accept and skip decisions are separate from Claude. Both seed acceptance and
+`seed` offers common delegation policies without Claude model names, plus
+compatible Codex ratchet presets. Ratchet and skip decisions remain agent-specific;
+an approved common policy suppresses duplicate offers within its scope in either
+agent. Both seed acceptance and
 route approval require the user's choice of global or project scope. A project
 route is saved for the project where it was observed. Enable delegation with
 `sprag delegate on --agent codex` and trust the hooks before expecting rules to run.
@@ -348,9 +430,10 @@ sprag route-scan savings --refresh --agent codex
 sprag route-scan savings --format json --agent codex
 ```
 
-The separate Codex ledger joins a route ID recorded by Sprag at spawn time to
-the child's own rollout. An explicit model choice or an unrelated cheaper
-subagent earns no credit. The estimate holds the child's measured tokens
+The separate Codex ledger joins a spawn-time route ID, or a validated shared
+prompt-hint marker on clients that skip the spawn hook, to the child's own
+rollout. An unrelated explicit model choice or cheaper subagent earns no credit.
+The estimate holds the child's measured tokens
 constant and prices them at the parent and child rates. Negative differences
 remain negative; this is not a comparison of actual billed totals.
 
@@ -525,7 +608,7 @@ Document counts are not a measurement of Codex billing or avoided tokens.
 
 ## Limits And Removal
 
-Claude's cap/TTL heuristics, Haiku/Sonnet tier presets, and the Claude
+Claude's cap/TTL heuristics, Haiku/Sonnet model identifiers, and the Claude
 `compact-window` command do not apply to Codex. Codex provides its own
 `model_auto_compact_token_limit` setting; Sprag does not apply Claude's 1M
 heuristic or change that setting. Codex's native `tui.status_line` accepts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.60.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/agent.js

@@ -14,6 +14,15 @@ export function codexProviderName({ home = codexUserDir() } = {}) {
   } catch (e) { return e.code === 'ENOENT' ? 'openai' : null; }
 }
 
+/** The default model from Codex config, or null when it names none or cannot be read. */
+export function codexModelName({ home = codexUserDir() } = {}) {
+  try {
+    const cfg = parse(readFileSync(join(home, 'config.toml'), 'utf8'));
+    const model = cfg.profiles?.[cfg.profile]?.model || cfg.model;
+    return typeof model === 'string' && model ? model : null;
+  } catch { return null; }
+}
+
 /** Remove the global selector before positional subcommand parsers see it. */
 export function selectAgent(argv) {
   const args = [];

package/src/codex-delegation.js

@@ -9,6 +9,10 @@ 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';
+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 -->';
@@ -23,6 +27,81 @@ 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 []; }
+  });
+}
+
+// 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 = 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' }] : [];
+  });
+}
+
 const rulesFile = (dir) => join(dir, 'codex-model-rules.json');
 export function loadCodexModelRules({ dir = userDataDir() } = {}) {
   try {
@@ -92,6 +171,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 +200,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 } : {}), ...(route.auto ? { mapping: 'auto' } : {}) }
+          : { 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 +319,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, 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.
+  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-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; 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: '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; 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/codex-hooks.js

@@ -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-ledger.js

@@ -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;
 }
@@ -220,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;
@@ -232,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;
@@ -249,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-route-scan.js

@@ -8,7 +8,7 @@ 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';
@@ -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

package/src/commands/codex-delegate.js

@@ -1,20 +1,108 @@
 import { loadConfig, saveConfig } from '../config.js';
 import { configureCodexHooks } from '../codex-installer.js';
-import { validateCodexTarget, loadCodexModelRules, addCodexModelRule, removeCodexModelRule } from '../codex-delegation.js';
+import { validateCodexTarget, loadCodexModelRules, addCodexModelRule, removeCodexModelRule,
+  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';
 import { signedUsd } from '../money.js';
-import { codexProviderName } from '../agent.js';
+import { codexProviderName, codexModelName } from '../agent.js';
+import { loadSharedModelRules, sharedModelRulesForProject, SHARED_RULE_TIERS } from '../shared-model-rules.js';
+
+// Starts from the working directory, as the hooks do, so a project policy
+// stored under either agent's project root is counted.
+function printShared(cfg, { details = false } = {}) {
+  const policies = sharedModelRulesForProject(loadSharedModelRules(), process.cwd());
+  const targets = codexSharedTargets(cfg);
+  const provider = codexProviderName();
+  const parent = codexModelName();
+  console.log(`Shared delegation policies: ${policies.length} in this project (${cfg.codex?.sharedRules?.enabled === false ? 'off' : 'on'}); Codex tier mappings: ${targets.length}`);
+  if (!policies.length) console.log('First use: sprag seed --agent codex. Approve policies with seed accept <id>|all --global|--project; no Claude installation or history is required.');
+  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})` : ''}`);
+  }
+  // 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
+  // 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(', ')}`
+      + `${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)'}. `
+    + 'Change: sprag delegate shared min-context <tokens|default> --agent codex');
+  console.log('Shared policies keep their original scope and bounds. Models require an exact parent/provider mapping; agent-specific roles and usage totals are not imported.');
+}
 
 export function run({ args, getArg, hasFlag, root }) {
   const sub = args[1] || 'status';
   if (args.some((arg) => arg.startsWith('--hook'))) throw new Error('Use codex-hook for Codex hook payloads.');
-  for (const flag of ['--model', '--effort', '--from']) {
+  for (const flag of ['--model', '--effort', '--from', '--provider']) {
     if (args.some((arg) => arg === flag || arg.startsWith(`${flag}=`)) && (!getArg(flag) || getArg(flag).startsWith('-'))) {
       throw new Error(`${flag} requires a value.`);
     }
   }
+  const cfg = loadConfig();
+  if (sub === 'shared') {
+    const action = args[2] || 'status';
+    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}=`));
+    if (!['map', 'unmap'].includes(action) && ['--model', '--effort', '--from', '--provider'].some(provided)) {
+      throw new Error('Model options require delegate shared map or unmap.');
+    }
+    const targets = codexSharedTargets(cfg);
+    if (action === 'map' || action === 'unmap') {
+      const tier = args[3];
+      const from = getArg('--from');
+      const provider = getArg('--provider') ?? codexProviderName();
+      if (!SHARED_RULE_TIERS.includes(tier)) throw new Error('Shared rule tier must be T1 or T2.');
+      const same = (t) => t.tier === tier && t.from === from && t.provider === provider;
+      if (action === 'map') {
+        const target = validateCodexSharedTarget({ tier, from, provider, model: getArg('--model'), effort: getArg('--effort') });
+        cfg.codex = { ...cfg.codex, sharedRules: { ...cfg.codex?.sharedRules, targets: [...targets.filter((t) => !same(t)), target] } };
+      } else {
+        if (provided('--model') || provided('--effort')) throw new Error('unmap accepts only tier, --from and --provider.');
+        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') {
+        cfg.codex = { ...cfg.codex };
+        delete cfg.codex.delegateMinContext;
+      } else if (/^\d+$/.test(value ?? '') && Number.isSafeInteger(Number(value))) {
+        cfg.codex = { ...cfg.codex, delegateMinContext: Number(value) };
+      } else {
+        throw new Error(`min-context takes a whole number of parent input tokens, or default (${DEFAULT_DELEGATE_MIN_CONTEXT}).`);
+      }
+    } else if (action !== 'status') {
+      cfg.codex = { ...cfg.codex, sharedRules: { ...cfg.codex?.sharedRules, enabled: action === 'on' } };
+    }
+    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.`);
+    return;
+  }
   if (sub === 'rules') {
     if (args[2] === 'add') {
       if (hasFlag('--global') === hasFlag('--project')) throw new Error('Choose --global or --project for the rule.');
@@ -31,7 +119,7 @@ export function run({ args, getArg, hasFlag, root }) {
     } else if (args[2] === 'rm') removeCodexModelRule(Number(args[3]));
     else if (args[2]) throw new Error('Usage: delegate rules [add <category|R<N>> --from <model> --model <model> --global|--project | rm <N>]');
     const rules = loadCodexModelRules();
-    if (!rules.length) console.log('No Codex model rules. Claude rules are not imported.');
+    if (!rules.length) console.log('No Codex-only model rules.');
     let events = [];
     try { events = Object.values(loadCodexLedger().events); } catch { /* No ledger yet: rules list without outcomes. */ }
     const inReview = new Set(codexRulesInReview({ rules, events, root: null }).map((x) => x.index));
@@ -41,10 +129,10 @@ export function run({ args, getArg, hasFlag, root }) {
       const warn = inReview.has(i + 1) ? ` | rule-health: ${h.errs}/${h.runs} runs failed, narrow the condition or remove (delegate rules rm ${i + 1} --agent codex)` : '';
       console.log(`#${i + 1} ${r.category} | ${r.from} -> ${r.model} | ${r.scope}${r.targetRoot ? ` ${r.targetRoot}` : ''}${outcome}${warn}`);
     });
+    printShared(cfg, { details: true });
     return;
   }
-  if (!['on', 'off', 'status', 'model'].includes(sub)) throw new Error('Usage: delegate on|off|status|model <model>|rules --agent codex');
-  const cfg = loadConfig();
+  if (!['on', 'off', 'status', 'model'].includes(sub)) throw new Error('Usage: delegate on|off|status|model <model>|rules|shared --agent codex');
   let target;
   if (sub === 'model') target = args[2] === 'off' ? null : validateCodexTarget(args[2], getArg('--effort'));
   else if (getArg('--model') !== undefined) target = validateCodexTarget(getArg('--model'), getArg('--effort'));
@@ -63,6 +151,7 @@ export function run({ args, getArg, hasFlag, root }) {
   let ruleCount;
   try { ruleCount = String(loadCodexModelRules().length); } catch (e) { ruleCount = `unreadable (${e.message})`; }
   console.log(`Codex rules: ${ruleCount}`);
+  printShared(cfg);
   console.log('Explicit spawn models and custom roles are preserved. Targets must be available from your Codex provider.');
   const saved = codexRoutingSavedTotals();
   console.log(saved.priced

package/src/commands/codex.js

@@ -26,11 +26,17 @@ Usage: sprag <command> --agent codex [options]
   saved [reset|undo]             Show, reset or restore the saved-money counters
   delegate on|off|status         Native model routing and SubagentStart guidance
   delegate model <model>         Default target for spawns without an explicit model
-  delegate rules                Codex-only category rules; add/rm with explicit scope
+  delegate rules                Codex rules and shared delegation policies
+  delegate shared on|off|status  Reuse approved policies; keep original scopes
+  delegate shared map T1|T2     Map a tier: --from <parent> --model <target>
+                                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
-  seed [accept|skip|reset]       Bundled Codex ratchet presets; acceptance needs a scope
+  seed [accept|skip|reset]       Shared delegation and Codex ratchet presets; explicit scope
   cache [auto|off|<duration>]    Display timer policy (e.g. 30m); never changes retention
   cache status --refresh        Resolve the session's gateway deployment and cache policy
   harness init|uninit|check|promote|list|rm|prune
@@ -413,6 +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.');
+    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/model-rules.js

@@ -147,15 +147,17 @@ export function modelRuleBaseText(g, lang = userLanguage(), { root } = {}) {
 // this, so an XDG_CONFIG_HOME override moves every state file together.
 const stateDir = userDataDir;
 
-export function modelRulesPath() {
-  return join(stateDir(), 'model-rules.json');
+export function modelRulesPath({ dir = stateDir() } = {}) {
+  return join(dir, 'model-rules.json');
 }
 
-export function loadModelRules() {
+export function loadModelRules({ dir = stateDir(), strict = false } = {}) {
   try {
-    const data = JSON.parse(readFileSync(modelRulesPath(), 'utf8'));
-    return Array.isArray(data.rules) ? data : { rules: [] };
-  } catch {
+    const data = JSON.parse(readFileSync(modelRulesPath({ dir }), 'utf8'));
+    if (!Array.isArray(data?.rules)) throw new Error('Invalid registry');
+    return data;
+  } catch (error) {
+    if (strict && error.code !== 'ENOENT') throw new Error('Cannot parse model rules; file left unchanged.');
     return { rules: [] };
   }
 }
@@ -189,8 +191,9 @@ export function saveModelRules(data) {
 
 /** Add (or re-activate) a promoted rule; returns the stored entry. */
 export function addModelRule(entry) {
-  const data = loadModelRules();
-  const existing = data.rules.find((r) => r.signature === entry.signature && r.scope === entry.scope);
+  const data = loadModelRules({ strict: true });
+  const existing = data.rules.find((r) => r.signature === entry.signature && r.scope === entry.scope &&
+    (r.scope === 'global' || r.targetRoot === entry.targetRoot));
   if (existing) {
     Object.assign(existing, entry, { status: 'active' });
     saveModelRules(data);

package/src/route-inject.js

@@ -33,6 +33,7 @@
 
 import { categorizeScored, ESCALATE_RE, EDIT_RE, worthDelegating } from './route-scan.js';
 import { loadModelRules, budgetCapPhrase, ruleBudget } from './model-rules.js';
+import { sharedProjectRoots, realProjectRoot, scopeRank } from './shared-model-rules.js';
 import { agentPhrase, agentPhraseEn } from './agents.js';
 import { userLanguage } from './config.js';
 import { aliasForRole, resolveModelAlias } from './model-alias.js';
@@ -121,7 +122,7 @@ export function sessionModelRank({ env = process.env, transcriptPath = null, sna
  *   model filters nothing.
  * @returns {{cat: object, t2: object|undefined, t1: object|undefined}|null}
  */
-export function routeMatch(text, { rules, sessionRank = null } = {}) {
+export function routeMatch(text, { rules, sessionRank = null, root } = {}) {
   const t = String(text || '').trim();
   if (t.length < MIN_LEN) return null;
   // Judgement and irreversible work stay on the top tier. This check comes
@@ -148,7 +149,13 @@ export function routeMatch(text, { rules, sessionRank = null } = {}) {
   if (cat.id === 'paste' && !looksPasted(t)) return null;
 
   const all = rules || loadModelRules().rules || [];
-  const matched = all.filter((r) => r && r.category === cat.id);
+  // The registry is shared with Codex, so a project rule approved in one
+  // project must not route another. A session whose directory is unknown gets
+  // global rules only.
+  const roots = root ? sharedProjectRoots(root) : [];
+  const inScope = (r) => r.scope !== 'project' ||
+    (typeof r.targetRoot === 'string' && roots.includes(realProjectRoot(r.targetRoot)));
+  const matched = all.filter((r) => r && r.category === cat.id && inScope(r));
   if (!matched.length) return null;
   // A rule only saves anything when its target tier is cheaper than the model
   // reading the hint. A T1 rule states "delegate to model: sonnet", which in a
@@ -161,8 +168,10 @@ export function routeMatch(text, { rules, sessionRank = null } = {}) {
     : matched.filter((r) => worthDelegating(r.tier, sessionRank));
   if (!usable.length) return null;
 
-  const t2 = usable.find((r) => r.tier === 'T2');
-  const t1 = usable.find((r) => r.tier === 'T1');
+  // The closest scope states the cap, whatever order the registry holds.
+  const nearest = [...usable].sort((a, b) => scopeRank(b) - scopeRank(a));
+  const t2 = nearest.find((r) => r.tier === 'T2');
+  const t1 = nearest.find((r) => r.tier === 'T1');
   return t2 || t1 ? { cat, t2, t1 } : null;
 }
 
@@ -186,7 +195,7 @@ export function matchCaps(match) {
  * @returns {string|null} the line to inject, or null to stay quiet
  */
 export function routeHint(text, { rules, lang = userLanguage(), root, sessionRank = null, match } = {}) {
-  const found = match === undefined ? routeMatch(text, { rules, sessionRank }) : match;
+  const found = match === undefined ? routeMatch(text, { rules, sessionRank, root }) : match;
   if (!found) return null;
   const { cat, t2, t1 } = found;
   const ko = lang === 'ko';

package/src/seed-rules.js

@@ -25,16 +25,16 @@
 
 import { readFileSync } from 'node:fs';
 import { CLI_NAME } from './cli-name.js';
-import { join, dirname } from 'node:path';
+import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createHash } from 'node:crypto';
+import { sharedModelRulesForProject, loadSharedModelRules, sharedProjectRoots, realProjectRoot } from './shared-model-rules.js';
 import { userDataDir } from './paths.js';
 import { userLanguage } from './config.js';
 import { writeStateFile } from './state-file.js';
 import {
   addModelRule,
   composeRuleText,
-  loadModelRules,
   modelRuleBaseText,
   syncAllFiles,
 } from './model-rules.js';
@@ -102,22 +102,12 @@ const stripDate = (t) => t.replace(/^\d{4}-\d{2}-\d{2}(\s*\([^)]*\))?:\s*/, '').
  * Everything still worth asking about: presets the user has not answered and
  * that are not already covered by a rule they have.
  *
- * "Already covered" is deliberately loose for model presets — any registered
- * rule for the same tier and category wins, whatever its scope or agent. A user
- * whose own route-scan already promoted that shape does not need ours, and
- * offering it anyway would read as the tool failing to notice its own state.
+ * A shared policy covers its tier and category only within its approved scope.
+ * A decision in another project must not suppress this project's offer.
  */
 export function pendingSeeds({ lang = userLanguage(), root = findProjectRoot(), agent = 'claude' } = {}) {
   const { decided } = loadSeedState({ agent });
-  // Codex model routing comes from its own measured route-scan candidates;
-  // Claude tier presets name models Codex does not run.
-  const registered = agent === 'codex' ? [] : (() => {
-    try {
-      return loadModelRules().rules;
-    } catch {
-      return [];
-    }
-  })();
+  const registered = sharedModelRulesForProject(loadSharedModelRules({ includeInactive: true }), root);
   const haveModel = new Set(registered.map((r) => `${r.tier}|${r.category}`));
 
   const haveText = new Set();
@@ -128,16 +118,23 @@ export function pendingSeeds({ lang = userLanguage(), root = findProjectRoot(),
   }
 
   const out = [];
-  for (const p of agent === 'codex' ? [] : modelPresets()) {
-    if (decided[p.id]) continue;
+  const roots = sharedProjectRoots(root);
+  for (const p of modelPresets()) {
+    const decision = decided[p.id];
+    if (decision?.action === 'skipped') continue;
+    // An answer recorded before decisions kept targetRoot cannot name its
+    // project, so it stays decided everywhere, as it was when it was given.
+    if (decision?.action === 'accepted' && (decision.scope !== 'project' || !decision.targetRoot ||
+        roots.includes(realProjectRoot(decision.targetRoot)))) continue;
     if (haveModel.has(`${p.tier}|${p.category}`)) continue;
     out.push({
       kind: 'model',
       id: p.id,
       tier: p.tier,
       label: lang === 'ko' ? p.label : p.labelEn,
-      agent: p.agent,
-      ruleText: composeRuleText(modelRuleBaseText(p, lang), { budget: p.budget }, lang),
+      agent: agent === 'codex' ? `Codex ${p.tier} mapping` : p.agent,
+      ruleText: agent === 'codex' ? codexSeedText(p, lang)
+        : composeRuleText(modelRuleBaseText(p, lang), { budget: p.budget }, lang),
       preset: p,
     });
   }
@@ -151,6 +148,13 @@ export function pendingSeeds({ lang = userLanguage(), root = findProjectRoot(),
   return out;
 }
 
+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}. Codex resolves the execution model automatically or from a mapping.`;
+  return composeRuleText(text, p, lang);
+}
+
 /** One pending seed by id, or null. Ids are matched exactly. */
 export function findSeed(id, opts = {}) {
   return pendingSeeds(opts).find((s) => s.id === id) || null;
@@ -222,12 +226,16 @@ export async function acceptSeed(id, { scope, root = findProjectRoot(), lang = u
     // Marks the rule as seeded rather than measured, so the rendered file does
     // not report someone else's recurrence count as this user's evidence.
     origin: 'preset',
+    approvedBy: agent,
     promotedAt: today,
     lastSeen: today,
   });
-  const written = syncAllFiles();
-  recordDecision(id, 'accepted', { scope }, { agent });
-  return { id, kind: 'model', scope, paths: written, rule: composeRuleText(entry.rule, entry, lang) };
+  // Codex-first installs need only the registry. Claude renders its view when
+  // it is installed or starts a session, without creating .claude here.
+  const written = agent === 'codex' ? [] : syncAllFiles();
+  recordDecision(id, 'accepted', { scope, targetRoot: scope === 'project' ? resolve(root) : null }, { agent });
+  return { id, kind: 'model', scope, paths: written,
+    rule: agent === 'codex' ? codexSeedText(p, lang) : composeRuleText(entry.rule, entry, lang) };
 }
 
 /**
@@ -277,13 +285,14 @@ export function seedOfferBlock({ lang = userLanguage(), root = findProjectRoot()
     // Codex hook text stays English; the rule text itself follows the user's language.
     const cmd = (s) => `${CLI_NAME} seed ${s} --agent codex`;
     return [
-      `[Sprag seed] ${pending.length} recommended Codex ratchet rule(s) from the bundled presets are not registered yet.`,
+      `[Sprag seed] ${pending.length} recommended shared delegation and Codex ratchet rule(s) from the bundled presets are not registered yet.`,
       'Ask in your first reply, after answering any request the user opened with. Offer these choices in this order:',
       `  1. Register all, globally: ${cmd('accept all --global')}`,
       `  2. Register all, this project only: ${cmd('accept all --project')}`,
       '  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; 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');
   }

package/src/shared-model-rules.js

@@ -0,0 +1,73 @@
+import { realpathSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { loadModelRules, ruleBudget } from './model-rules.js';
+import { findProjectRoot } from './harness.js';
+
+export const SHARED_RULE_TIERS = ['T2', 'T1'];
+const CATEGORIES = new Set(['paste', 'translate', 'explore', 'read', 'check', 'run']);
+
+/** A root as a real path, so a symlinked checkout or macOS /var names one directory once. */
+export function realProjectRoot(path) {
+  try { return realpathSync(path); } catch { return resolve(path); }
+}
+
+/**
+ * Every root either agent assigns to a working directory. Claude stops at
+ * CLAUDE.md and Codex at AGENTS.md, so a subdirectory holding only one of them
+ * gets a different root from each agent for the same project.
+ */
+export function sharedProjectRoots(start) {
+  const from = start || process.cwd();
+  return [...new Set(['claude', 'codex'].map((agent) => realProjectRoot(findProjectRoot(from, { agent }))))];
+}
+
+/** Read a policy view of the existing registry, never its model roles or statistics. */
+export function loadSharedModelRules({ includeInactive = false, ...opts } = {}) {
+  return loadModelRules(opts).rules.flatMap((r) => {
+    if (!r || !(r.status === 'active' || (includeInactive && ['off', 'review'].includes(r.status))) ||
+        !SHARED_RULE_TIERS.includes(r.tier) || !CATEGORIES.has(r.category) ||
+        !['global', 'project'].includes(r.scope)) return [];
+    if (r.scope === 'project' && (typeof r.targetRoot !== 'string' || !isAbsolute(r.targetRoot))) return [];
+    const targetRoot = r.scope === 'project' ? realProjectRoot(r.targetRoot) : null;
+    const budget = ruleBudget(r);
+    return [{ category: r.category, tier: r.tier, scope: r.scope, targetRoot,
+      sharedSignature: typeof r.signature === 'string' && r.signature.length <= 512 ? r.signature
+        : `${r.tier}|${r.category}|${targetRoot || '*'}`,
+      budget: {
+        calls: Number.isSafeInteger(budget?.calls) && budget.calls > 0 ? budget.calls : null,
+        out: Number.isSafeInteger(budget?.out) && budget.out > 0 ? budget.out : null,
+      } }];
+  });
+}
+
+/**
+ * How close a rule's scope is to the working directory: a project rule ranks
+ * by the depth of its root, so in a nested project the inner root wins, and
+ * any project rule outranks a global one. Registry order never decides.
+ */
+export function scopeRank(rule) {
+  return rule.scope === 'project' && typeof rule.targetRoot === 'string' ? realProjectRoot(rule.targetRoot).length : -1;
+}
+
+/**
+ * One policy per category and tier, the closest scope first (see scopeRank).
+ * `start` is the working directory when known; a project policy applies when
+ * its root is the root either agent assigns to that directory.
+ */
+export function sharedModelRulesForProject(rules, start) {
+  const roots = new Set(sharedProjectRoots(start));
+  const chosen = new Map();
+  for (const rule of rules) {
+    if (rule.scope !== 'global' && !roots.has(rule.targetRoot)) continue;
+    const key = `${rule.category}|${rule.tier}`;
+    if (!chosen.has(key) || scopeRank(rule) > scopeRank(chosen.get(key))) chosen.set(key, rule);
+  }
+  return [...chosen.values()];
+}
+
+export function sharedRuleBounds(rule) {
+  const caps = [];
+  if (rule.budget?.calls) caps.push(`${rule.budget.calls} tool calls`);
+  if (rule.budget?.out) caps.push(`${rule.budget.out} output tokens`);
+  return caps.length ? `Caller-approved cap: ${caps.join(' / ')}. Stop and report partial work before exceeding it.` : '';
+}