sprag-cli 3.61.0 → 3.63.0

package/docs/CODEX.ko.md

@@ -133,6 +133,12 @@ Codex 0.159.2에서는 `spawn_agent`가 `PreToolUse`를 거치지 않습니다(
 SessionStart는 캐시된 후보를 읽고 필요할 때 별도 프로세스에서 갱신합니다. 명시적인 `--refresh`는
 대기 주기를 건너뜁니다.
 
+한국어 지침이 켜져 있는 동안 Sprag는 지침 전문을 전역 Codex `AGENTS.md`(`AGENTS.override.md`가
+비어 있지 않으면 그 파일)의 `<!-- sprag:codex:korean-style:begin -->`과 `end` 표지 사이에 둡니다.
+Codex는 이 파일을 세션마다 전부 읽지만 아래 훅 예산에는 지침이 들어가지 않기 때문입니다. 설치,
+`korean on|off`, 세션 시작 때마다 이 블록을 맞추고, `sprag uninstall --agent codex`가 지웁니다. 훅은
+블록을 방금 쓴 세션에서만 지침을 자기 컨텍스트에 함께 넣습니다.
+
 Codex 0.159.2는 훅 하나가 넘긴 컨텍스트를 약 2,450토큰까지만 보존하고, 그보다 길면 가운데를
 잘라 냅니다. 그래서 SessionStart는 추정치 2,000토큰 안에 들어가는 항목만 잘리지 않은 상태로
 넣습니다. 우선순위는 ratchet 룰, 한국어 지침, 응집성 지침, 문서 변환 안내, 제안 순입니다. 들어가지
@@ -158,19 +164,28 @@ Claude를 설치하지 않은 Codex 첫 사용자도 기록을 쌓기 전에 프
 sprag seed --agent codex
 sprag seed accept all --global --agent codex
 sprag delegate shared status --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 세션에서 이미 실행됐거나(OpenAI 기본 공급자라면 Codex가 이 계정에 보여 주는
+`models_cache.json` 모델 목록에 있는) 모델 가운데 가장 싼 모델이 T2, 그다음 모델이 T1이 됩니다. 그런 모델이 하나뿐이면 T1은 메인 모델이 처리하고, 하나도
+없으면 두 난도 모두 메인 모델이 처리합니다. 위임은 기본으로 켜져 있고(`sprag delegate off --agent codex`로 끕니다), 자동 결정은 위임이 켜진 동안
+동작합니다. 아무것도 저장하지 않으므로 가격이나 실행 이력, 모델 목록이 바뀌면 그대로 따라갑니다.
+`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

@@ -58,6 +58,14 @@ sprag korean lint warn --agent codex
 sprag doc2md install-converter --agent codex
 ```
 
+While Korean guidance is on, Sprag keeps it in the global Codex `AGENTS.md`
+(or `AGENTS.override.md` when that is non-empty), between
+`<!-- sprag:codex:korean-style:begin -->` and `...:end -->` markers, because
+Codex loads that file in full every session and the hook budget below is too
+small for the guide. `install`, `korean on|off`, and each session start keep the
+block in step; `sprag uninstall --agent codex` removes it. The hook adds the
+guide to its own context only in the session that just wrote the block.
+
 `korean on`, `cohesion on`, `brief on`, `doc2md on`, and `delegate on`
 register Codex hooks before saving the enabled preference. If hook registration
 fails, the preference stays unchanged. Review new or changed definitions in
@@ -151,7 +159,7 @@ warning records. A handoff file is never overwritten and identifies quota
 values as recorded snapshots, not live responses. Fill in its remaining-work
 sections before using it to continue in another session.
 
-Delegation is independently opt-in via `delegate on`. As of Codex 0.159.2,
+Delegation is on by default; `sprag delegate off --agent codex` turns it off. As of Codex 0.159.2,
 `spawn_agent` never reaches `PreToolUse` (measured directly: a recording hook
 saw only `Bash` calls while a spawn happened), so the rewrite below cannot see
 or steer it. The live path instead runs at prompt time: `UserPromptSubmit`
@@ -223,16 +231,28 @@ 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
+# 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 is available becomes
+T2, and the next one up becomes T1. A model is available when it has already
+run in your Codex sessions, or, on the built-in OpenAI provider only, when
+Codex lists it for your account in its `models_cache.json`. With a single
+such model T1 stays on the main agent; with none, both do. Resolution runs
+while delegation is on (the default) and follows price, history, and catalog
+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.
 
@@ -341,7 +361,8 @@ after an hour. `--refresh` bypasses that schedule.
 
 Codex 0.159.2 keeps about 2,450 tokens of one hook's context and cuts the
 middle of anything longer. SessionStart therefore fits its parts whole within a
-2,000-token estimate, in priority order: ratchet rules, Korean guidance,
+2,000-token estimate, in priority order: ratchet rules, Korean guidance
+(only while it is not yet in the global `AGENTS.md`; see below),
 cohesion guidance, the document note, then offers. Rules and guidance that do
 not fit are written to a per-project file under the Sprag data directory, and
 the context opens with an instruction to read it. `codex exec` runs, recognized
@@ -353,8 +374,8 @@ compatible Codex ratchet presets. Ratchet and skip decisions remain agent-specif
 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.
+route is saved for the project where it was observed. Delegation is on by default
+(`sprag delegate off --agent codex` turns it off); trust the hooks before expecting rules to run.
 
 ## Reports
 

package/mod/sprag-delegation-meter/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "sprag-delegation-meter",
+  "version": "0.1.0",
+  "description": "Measures what each delegated subagent actually spent, from the API's own usage, and keeps one record per run",
+  "author": { "name": "DeepPulse", "url": "https://www.youtube.com/@DeepPulseKR" }
+}

package/mod/sprag-doc2md/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "sprag-doc2md",
+  "version": "0.1.0",
+  "description": "Reads the Markdown that sprag doc2md converted instead of the binary document, with no denied Read in between",
+  "author": { "name": "DeepPulse", "url": "https://www.youtube.com/@DeepPulseKR" }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.61.0",
+  "version": "3.63.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": {
@@ -15,11 +15,14 @@
     "release:notes": "node scripts/release-notes.mjs",
     "site:docs": "node scripts/build-site-docs.mjs",
     "test": "node --test",
+    "test:mods": "claude plugin test mod/sprag-doc2md && claude plugin test mod/sprag-delegation-meter",
     "version": "node scripts/sync-site-version.mjs"
   },
   "files": [
     "bin/",
     "src/",
+    "mod/*/.claude-plugin/plugin.json",
+    "mod/*/hooks/",
     "presets/",
     "examples/",
     "README.md",

package/src/codex-delegation.js

@@ -11,12 +11,21 @@ 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 -->';
 const safeId = (value) => typeof value === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9._:/-]{0,255}$/.test(value);
 const validEffort = (value) => value === undefined || ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(value);
 
+/**
+ * Delegation is on unless the user turned it off. A fresh install writes no
+ * setting, so requiring `delegate === true` meant nothing ever delegated; only
+ * `sprag delegate off --agent codex` stores `false`.
+ */
+export function codexDelegateEnabled(cfg) { return cfg?.codex?.delegate !== false; }
+
 export function validateCodexTarget(model, effort) {
   if (!safeId(model)) throw new Error('Provide a literal Codex model ID.');
   if (!validEffort(effort)) {
@@ -41,10 +50,81 @@ 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 []; }
+}
+
+/**
+ * Model slugs Codex's own catalog lists for this account
+ * (`<codex home>/models_cache.json`, entries with visibility "list"). A new
+ * user has no session history, so the catalog is the only evidence of what
+ * Codex can run. Unreadable or malformed files give [].
+ */
+function catalogCodexModels(home) {
+  try {
+    const data = JSON.parse(readFileSync(join(home, 'models_cache.json'), 'utf8'));
+    return (Array.isArray(data?.models) ? data.models : [])
+      .filter((m) => m && m.visibility === 'list' && typeof m.slug === 'string').map((m) => m.slug);
+  } catch { return []; }
+}
+
+/**
+ * The models Codex resolves T2 and T1 to when the user mapped none, the way
+ * Claude Code resolves `haiku` and `sonnet`. Candidates are the models that
+ * already ran in this user's Codex sessions plus, for the built-in OpenAI
+ * provider only, the models Codex's catalog lists for the account (a gateway
+ * serves its own set, which the catalog does not describe). A candidate
+ * qualifies only if it is priced on the parent's provider and costs less than
+ * the parent, 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 available = [...new Set([...observedCodexModels(dir, provider), ...(provider === 'openai' ? catalogCodexModels(home) : [])])];
+  const cheaper = available
+    .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: available.length
+      ? `${model} is already the cheapest available model on ${provider}`
+      : `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 (!codexDelegateEnabled(cfg) || 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 +290,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;
@@ -256,7 +336,7 @@ function customRole(role, root, home) {
 // Kept for Codex versions that do send spawn_agent through PreToolUse; on
 // 0.159.2 the hook never fires for it, so codexRouteHint above is the live path.
 export function codexDelegationTool(payload, { cfg = {}, root = payload?.cwd || process.cwd(), home = codexUserDir(), rules: given, dir = userDataDir(), record = recordCodexDelegation } = {}) {
-  if (cfg.codex?.delegate !== true) return null;
+  if (!codexDelegateEnabled(cfg)) return null;
   const tool = payload?.tool_name?.replace(/^(?:functions|tools)\./, '');
   if (!['spawn_agent', 'Agent'].includes(tool)) return null;
   const input = payload.tool_input;
@@ -268,7 +348,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/codex-harness.js

@@ -1,11 +1,15 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { codexUserDir } from './agent.js';
+import { loadConfig } from './config.js';
+import { koreanStyleEnabled, koreanStyleInjection } from './korean-style.js';
 import { codexToolEvents, codexLegacyToolEvent, readCodexTailLines, forkedCopyFilter } from './codex-parser.js';
 
 export const CODEX_BEGIN = '<!-- sprag:codex:harness:begin -->';
 export const CODEX_END = '<!-- sprag:codex:harness:end -->';
+export const CODEX_KOREAN_BEGIN = '<!-- sprag:codex:korean-style:begin -->';
+export const CODEX_KOREAN_END = '<!-- sprag:codex:korean-style:end -->';
 const sections = [
   ['Ratchet', 'When a mistake recurs, propose a concise condition/action rule. Ask the user for global or project scope before registering it with `sprag harness promote --agent codex --global|--project "rule"`.'],
   ['Evidence', 'Support completion claims with actual test results, command output, a file diff, or a screenshot. State any verification you could not run.'],
@@ -16,11 +20,15 @@ const sections = [
 
 const scopeDir = (root, scope) => (scope === 'global' ? codexUserDir() : root);
 
+/** Codex reads the override instead of AGENTS.md when it is non-empty. */
+function activeInstructionFile(dir) {
+  const override = join(dir, 'AGENTS.override.md');
+  return existsSync(override) && readFileSync(override, 'utf8').trim() ? override : join(dir, 'AGENTS.md');
+}
+
 export function codexHarnessPaths(root, scope = 'project') {
   const dir = scopeDir(root, scope);
-  // Codex reads the override instead of AGENTS.md when it is non-empty.
-  const override = join(dir, 'AGENTS.override.md');
-  const file = existsSync(override) && readFileSync(override, 'utf8').trim() ? override : join(dir, 'AGENTS.md');
+  const file = activeInstructionFile(dir);
   return { file, ratchet: scope === 'global' ? join(dir, 'ratchet.md') : join(dir, '.codex', 'ratchet.md') };
 }
 
@@ -34,15 +42,18 @@ export function codexHarnessBlock() {
   return `${CODEX_BEGIN}\n## Sprag Harness\n\n${sections.map(([name, text], i) => `### ${i + 1}. ${name}\n${text}`).join('\n\n')}\n\nRead the global and project Codex ratchet files before working when present. Run \`sprag harness list --agent codex --global\` and \`sprag harness list --agent codex --project\` to retrieve them. These are instructions, not Claude-style @ imports.\nUse \`sprag doc2md <file> --agent codex\` before reading PDF, Office, or Figma documents. Delegate only through available Codex tools and configured roles; do not assume Claude model names or Task/Agent arguments. A [Sprag model routing] note on a request means the user has asked for that request to be delegated: spawn the sub-agent it describes (its model, reasoning_effort, fork_turns "none", and a self-contained message ending with the route line it gives), wait for it to finish instead of doing the same task yourself, then verify the result before replying.\n${CODEX_END}\n`;
 }
 
-function range(content) {
-  const begin = content.indexOf(CODEX_BEGIN);
-  const end = content.indexOf(CODEX_END);
-  if ((begin < 0) !== (end < 0) || (begin >= 0 && end < begin) || content.indexOf(CODEX_BEGIN, begin + CODEX_BEGIN.length) >= 0) {
-    throw new Error('Malformed Sprag Codex harness markers; repair them before updating this file.');
+/** The [start, end) span of a marker block, null when absent; malformed markers throw. */
+function range(content, beginMarker = CODEX_BEGIN, endMarker = CODEX_END, label = 'harness') {
+  const begin = content.indexOf(beginMarker);
+  const end = content.indexOf(endMarker);
+  if ((begin < 0) !== (end < 0) || (begin >= 0 && end < begin) || content.indexOf(beginMarker, begin + beginMarker.length) >= 0) {
+    throw new Error(`Malformed Sprag Codex ${label} markers; repair them before updating this file.`);
   }
-  return begin < 0 ? null : [begin, end + CODEX_END.length];
+  return begin < 0 ? null : [begin, end + endMarker.length];
 }
 
+const koreanRange = (content) => range(content, CODEX_KOREAN_BEGIN, CODEX_KOREAN_END, 'korean-style');
+
 export function initCodexHarness({ root, scope = 'project' }) {
   const paths = codexHarnessPaths(root, scope);
   const existing = existsSync(paths.file) ? readFileSync(paths.file, 'utf8') : '';
@@ -95,10 +106,74 @@ export function uninitCodexHarness({ root, scope = 'project' }) {
     writeFileSync(candidate, withoutBlock(existing, span));
     cleaned.push(candidate);
   }
+  // The Korean style block lives only in the global file; project scope never has one.
+  if (scope === 'global') {
+    for (const candidate of removeKoreanBlocks(scopeDir(root, scope))) if (!cleaned.includes(candidate)) cleaned.push(candidate);
+  }
   if (!cleaned.length) return { file, removed: false };
   return { file: cleaned.includes(file) ? file : cleaned[0], removed: true, ...(cleaned.length > 1 ? { files: cleaned } : {}) };
 }
 
+/**
+ * Backup next to the file. A fresh install writes two backups in one
+ * millisecond (harness block, then Korean block); `wx` and a counter keep the
+ * second from overwriting the first, which holds the user's original text.
+ */
+function backupFile(file, text) {
+  const base = `${file}.bak-${Date.now()}`;
+  for (let i = 0; ; i++) {
+    try { writeFileSync(i ? `${base}-${i}` : base, text, { flag: 'wx' }); return; }
+    catch (e) { if (e?.code !== 'EEXIST') throw e; }
+  }
+}
+
+/** Removes the Korean block from every instruction file of `dir` that holds one; returns those files. */
+function removeKoreanBlocks(dir) {
+  const cleaned = [];
+  for (const candidate of [join(dir, 'AGENTS.override.md'), join(dir, 'AGENTS.md')]) {
+    if (!existsSync(candidate)) continue;
+    const existing = readFileSync(candidate, 'utf8');
+    const span = koreanRange(existing);
+    if (!span) continue;
+    const next = withoutBlock(existing, span);
+    if (next.trim()) backupFile(candidate, existing);
+    writeFileSync(candidate, next);
+    cleaned.push(candidate);
+  }
+  return cleaned;
+}
+
+/**
+ * Keeps the Korean style guide in the global Codex instruction file. Codex
+ * keeps only about 2,000 tokens of one hook's context, which the guide never
+ * fits, but it loads the global AGENTS.md in full every session. The block is
+ * written while the style is enabled and removed when it is not.
+ * Returns { action: 'written' | 'unchanged' | 'removed' | 'absent' | 'skipped', file }.
+ * `skipped` means the Codex directory does not exist, so nothing was touched.
+ */
+export function syncCodexKoreanBlock({ cfg = loadConfig(), home } = {}) {
+  const dir = home ? resolve(home) : codexUserDir();
+  const file = activeInstructionFile(dir);
+  if (!existsSync(dir)) return { action: 'skipped', file };
+  const text = koreanStyleEnabled(cfg) ? koreanStyleInjection({ cfg }) : null;
+  if (!text) {
+    const cleaned = removeKoreanBlocks(dir);
+    return cleaned.length ? { action: 'removed', file: cleaned.includes(file) ? file : cleaned[0] } : { action: 'absent', file };
+  }
+  const block = `${CODEX_KOREAN_BEGIN}\n${text}\n${CODEX_KOREAN_END}`;
+  const existing = existsSync(file) ? readFileSync(file, 'utf8') : '';
+  const span = koreanRange(existing);
+  if (span && existing.slice(...span) === block) return { action: 'unchanged', file };
+  const body = existing.replace(/\n+$/, '');
+  const next = span ? existing.slice(0, span[0]) + block + existing.slice(span[1])
+    : body + (body ? '\n\n' : '') + block + '\n';
+  // Replacing our own block loses nothing; the first addition to a user file gets a copy.
+  if (!span && existing.trim()) backupFile(file, existing);
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, next);
+  return { action: 'written', file };
+}
+
 export function codexHarnessStatus({ root, scope = 'project' }) {
   const { file } = codexHarnessPaths(root, scope);
   const text = existsSync(file) ? readFileSync(file, 'utf8') : '';

package/src/codex-hooks.js

@@ -6,12 +6,12 @@ import { join, resolve } from 'node:path';
 import { loadConfig, userLanguage } from './config.js';
 import { koreanStyleInjection, koreanStyleEnabled } from './korean-style.js';
 import { cohesionInjection } from './cohesion.js';
-import { codexHarnessPaths } from './codex-harness.js';
+import { codexHarnessPaths, syncCodexKoreanBlock } from './codex-harness.js';
 import { writeViaTmp } from './state-file.js';
 import { findProjectRoot } from './harness.js';
 import { runCodexBrief } from './codex-brief.js';
 import { codexDocumentTool, codexDocumentNote, convertCodexDocument } from './codex-doc2md.js';
-import { codexDelegationTool, codexRouteHint } from './codex-delegation.js';
+import { codexDelegationTool, codexRouteHint, codexDelegateEnabled } from './codex-delegation.js';
 import { bindCodexSubagent, closeStaleCodexRoutes, unsettledCodexRoutes } from './codex-ledger.js';
 import { seedOfferBlock } from './seed-rules.js';
 import { readCodexRouteScan, openCodexCandidates, shouldRescanCodex } from './codex-route-scan.js';
@@ -165,7 +165,7 @@ export function lintCodexTool(payload, { scope = 'all' } = {}) {
 export async function codexHookOutput(event, payload, { cfg = loadConfig(), refreshLedger = defaultLedgerRefresh } = {}) {
   if (!payload || typeof payload !== 'object') return null;
   if (event === 'session-start' || event === 'subagent-start') {
-    if (event === 'subagent-start' && cfg?.codex?.delegate !== true) return null;
+    if (event === 'subagent-start' && !codexDelegateEnabled(cfg)) return null;
     if (event === 'subagent-start') {
       try { bindCodexSubagent(payload); } catch (e) { debug('codex:bind', e); }
     }
@@ -193,8 +193,13 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
     }
     if (event === 'subagent-start') parts.push({ priority: 0, text:
       '[Sprag Codex delegation]\nStay within the assigned task and any caller-provided budget. Return findings with file references and actual verification results; state unfinished work. Use only available Codex tools and configured roles. Do not infer a model tier or invent a tool-call budget.' });
-    parts.push({ priority: 2, spill: true, text: koreanStyleInjection({ cfg }) },
-      { priority: 3, spill: true, text: await cohesionInjection({ cfg }) });
+    // Codex reads the Korean guide from the global AGENTS.md, so the hook adds it
+    // only when that block was just written (this session may have loaded the old
+    // file) or could not be synced. Children read the same file.
+    let korean = null;
+    try { korean = syncCodexKoreanBlock({ cfg }); } catch (e) { debug('codex:korean-sync', e); }
+    if (korean?.action !== 'unchanged') parts.push({ priority: 2, spill: true, text: koreanStyleInjection({ cfg }) });
+    parts.push({ priority: 3, spill: true, text: await cohesionInjection({ cfg }) });
     if (process.env.CTS_NO_DOC2MD !== '1' && cfg?.codex?.doc2md !== false) parts.push({ priority: 4, spill: true, text: codexDocumentNote() });
     // Offers ask the user a question; a `codex exec` run has no one to answer it.
     if (event === 'session-start' && payload.source !== 'compact' && !isCodexExecSession(payload.transcript_path)) {
@@ -206,7 +211,7 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
   }
   if (event === 'prompt') {
     const parts = [];
-    if (cfg?.codex?.delegate === true) {
+    if (codexDelegateEnabled(cfg)) {
       // Before the hint for this prompt is recorded: a hint from an earlier turn
       // that no child claimed is closed, and children that did run get priced.
       try { closeStaleCodexRoutes(payload); } catch (e) { debug('codex:close-routes', e); }

package/src/codex-panel.js

@@ -18,7 +18,7 @@ import { codexDocumentTotals } from './codex-doc2md-ledger.js';
 import { codexHookStatus } from './codex-installer.js';
 import { koreanStyleEnabled } from './korean-style.js';
 import { codexRoutingSavedTotals, loadCodexLedger } from './codex-ledger.js';
-import { loadCodexModelRules } from './codex-delegation.js';
+import { loadCodexModelRules, codexDelegateEnabled } from './codex-delegation.js';
 import { codexRulesInReview } from './codex-rule-health.js';
 import { readCodexRouteScan, openCodexCandidates } from './codex-route-scan.js';
 import { codexBudgetProvider } from './codex-budget.js';
@@ -138,7 +138,7 @@ export function createPanelReader({ root = process.cwd(), home, sessionId: pinne
       lint: cfg?.koreanStyle?.lint || 'block',
       cohesion: cfg?.cohesion?.enabled === true,
       brief: cfg?.codex?.brief !== false,
-      delegate: cfg?.codex?.delegate === true,
+      delegate: codexDelegateEnabled(cfg),
       doc2md: cfg?.codex?.doc2md !== false && process.env.CTS_NO_DOC2MD !== '1',
       updatedAt: new Date() };
   };

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, codexDelegateEnabled } 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 Codex runs or lists)' : ''}`);
+  }
+  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') {
@@ -86,7 +100,7 @@ export function run({ args, getArg, hasFlag, root }) {
     }
     if (action !== 'status') saveConfig(cfg);
     printShared(cfg, { details: true });
-    console.log(`Codex delegation is ${cfg.codex?.delegate === true ? 'on' : 'off; enable with sprag delegate on --agent codex'}. Target availability and lower cost must be verified with your provider.`);
+    console.log(`Codex delegation is ${codexDelegateEnabled(cfg) ? 'on' : 'off; enable with sprag delegate on --agent codex'}. Target availability and lower cost must be verified with your provider.`);
     return;
   }
   if (sub === 'rules') {
@@ -131,7 +145,7 @@ export function run({ args, getArg, hasFlag, root }) {
     if (target !== undefined) cfg.codex.delegateTarget = target;
     saveConfig(cfg);
   }
-  console.log(`Codex delegate: ${cfg.codex?.delegate === true ? 'on' : 'off'} (model routing and guidance)`);
+  console.log(`Codex delegate: ${codexDelegateEnabled(cfg) ? 'on' : 'off'} (model routing and guidance)`);
   console.log(`Default target: ${cfg.codex?.delegateTarget?.model || 'inherit (no override)'}`);
   // Turning delegation off must work even when the rule file is damaged.
   let ruleCount;

package/src/commands/codex.js

@@ -1,6 +1,6 @@
 import { createArgs } from '../cli-args.js';
 import { configureCodexHooks } from '../codex-installer.js';
-import { initCodexHarness, uninitCodexHarness, codexHarnessStatus } from '../codex-harness.js';
+import { initCodexHarness, uninitCodexHarness, codexHarnessStatus, syncCodexKoreanBlock } from '../codex-harness.js';
 import { findProjectRoot, harnessPromote, harnessListRules, harnessRmRule, harnessPrune } from '../harness.js';
 import { loadConfig, saveConfig } from '../config.js';
 import { resolve } from 'node:path';
@@ -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
@@ -407,6 +408,10 @@ export async function run({ args, version }) {
     if (process.env.CTS_NO_HARNESS !== '1') {
       const h = initCodexHarness({ root, scope: 'global' });
       console.log(`Codex harness: ${h.file}`);
+      try {
+        const k = syncCodexKoreanBlock({ cfg });
+        console.log(`Codex korean-style: ${k.file} (${k.action})`);
+      } catch (e) { debug('codex:korean-sync', e); }
     }
     try {
       const { preparePresetRatchet } = await import('../preset-ratchet.js');
@@ -418,7 +423,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 Codex lists or has run a cheaper priced model, 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; delegation is on by default (turn off: sprag delegate off --agent codex). No Claude installation is required.');
     console.log('Korean guidance is opt-in: sprag korean on --agent codex');
     return;
   }
@@ -503,6 +517,7 @@ export async function run({ args, version }) {
     const { setKoreanStyleEnabled } = await import('../korean-style.js');
     if (args[1] === 'on') configureCodexHooks();
     setKoreanStyleEnabled(args[1] === 'on');
+    try { syncCodexKoreanBlock({ cfg: loadConfig() }); } catch (e) { debug('codex:korean-sync', e); }
     console.log(`Korean guidance: ${args[1]} (shared Sprag preference). Review/trust the Sprag hooks in Codex /hooks.`);
     return;
   }

package/src/commands/doc2md.js

@@ -104,6 +104,7 @@ export async function run({ args, hasFlag }) {
     console.log(res.action === 'skipped'
       ? `✗ ${res.reason}`
       : `✓ Read hook ${res.action} (${res.path})`);
+    if (res.modReason) console.log(`  mod: not registered — ${res.modReason}`);
     // A registered hook with no converter behind it does nothing at all, and
     // says nothing about it either, which reads as a broken feature. Offer the
     // one command that closes the gap right where the gap is visible.
@@ -160,6 +161,17 @@ export async function run({ args, hasFlag }) {
   console.log(`  converter: ${python ? `markitdown via ${python}` : `not installed — ${doc2md.INSTALL_HINT}`}`);
   console.log(`  cache:     ${dir} (${cached} file(s))`);
   console.log(`  hook:      ${hookRegistered() ? 'registered on Read' : 'not registered'}`);
+  // The mod has the same two halves as the hook: `doc2md on` can leave it out
+  // (a shell value of the variable, a /plugin copy) while the hook goes in.
+  // A path the user added to their own shell variable counts as registered.
+  {
+    const { modDirsState, modDir, DOC2MD_MOD } = await import('../installer.js');
+    const sep = process.platform === 'win32' ? ';' : ':';
+    const inShell = (process.env.CLAUDE_CODE_PLUGIN_DIRS || '').split(sep).includes(modDir(DOC2MD_MOD));
+    console.log(`  mod:       ${modDirsState()[DOC2MD_MOD] || inShell
+      ? 'registered (Claude Code 2.1.287+ reads the Markdown in the same Read)'
+      : 'not registered — `doc2md on` registers it or says why not'}`);
+  }
   console.log('');
   if (!python) console.log(`Install the converter: ${doc2md.INSTALL_HINT}`);
   console.log('Enable with: sprag doc2md on');

package/src/commands/install.js

@@ -85,6 +85,8 @@ export async function run({ hasFlag }) {
     print('skill', r.skill);
     print('SessionStart hook (route-scan)', r.sessionStartHook);
     print('PostToolUse hook (delegation rescan)', r.delegationHook);
+    print('mod (delegation meter, Claude Code 2.1.287+)', r.delegationMeterMod);
+    if (r.delegationMeterMod.reason) console.log(`    ${r.delegationMeterMod.reason}`);
     print('UserPromptSubmit hook (brief)', r.briefHook);
     {
       let s = r.statusline;
@@ -333,6 +335,7 @@ export async function run({ hasFlag }) {
         console.log(res.action === 'skipped'
           ? `  doc2md: ${res.reason}`
           : `  doc2md: Read/Write hook ${res.action} (${res.path})`);
+        if (res.modReason) console.log(`  doc2md: mod not registered — ${res.modReason}`);
         console.log(lang === 'ko'
           ? `           대상 형식: ${doc2md.TARGET_EXTENSIONS.join(' ')} — 모델이 읽기 전에 Markdown으로 변환합니다.`
           : `           formats: ${doc2md.TARGET_EXTENSIONS.join(' ')} — converted to Markdown before the model reads them.`);
@@ -449,6 +452,11 @@ export async function run({ hasFlag }) {
           if (process.env.CTS_NO_HARNESS !== '1') {
             const h = initCodexHarness({ scope: 'global' });
             console.log(`  codex: harness ${h.file}`);
+            try {
+              const { syncCodexKoreanBlock } = await import('../codex-harness.js');
+              const k = syncCodexKoreanBlock({ cfg: config });
+              console.log(`  codex: korean-style ${k.action} (${k.file})`);
+            } catch (e) { debug('install:codex-korean', e); }
           }
           try { (await import('../preset-ratchet.js')).preparePresetRatchet({ agent: 'codex' }); } catch (e) { debug('install:codex-preset', e); }
           if (!manual) {

package/src/commands/korean.js

@@ -53,6 +53,7 @@ export async function run({ args, hasFlag }) {
   const sub = args[1] || 'status';
   const ks = await import('../korean-style.js');
   const { userLanguage, loadConfig, saveConfig } = await import('../config.js');
+  const { debug } = await import('../debug.js');
   const lang = userLanguage();
 
   // PostToolUse hook. Claude Code feeds the tool-call payload on stdin; we
@@ -222,6 +223,8 @@ export async function run({ args, hasFlag }) {
   if (sub === 'on' || sub === 'off') {
     const enabled = sub === 'on';
     ks.setKoreanStyleEnabled(enabled);
+    // Codex reads the guide from its global AGENTS.md; keep that block in step.
+    try { (await import('../codex-harness.js')).syncCodexKoreanBlock({ cfg: loadConfig() }); } catch (e) { debug('korean:codex-sync', e); }
     const {
       installKoreanLintHook, removeKoreanLintHook,
       installReplyLanguageHook, removeReplyLanguageHook,

package/src/installer.js

@@ -16,7 +16,8 @@
 import { writeFileSync, mkdirSync, existsSync, unlinkSync, readFileSync, rmSync, copyFileSync, renameSync, realpathSync, statSync } from 'node:fs';
 import { loadConfig, saveConfig } from './config.js';
 import { CLI_NAME, LEGACY_CLI_NAME } from './cli-name.js';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { claudeUserDir, userDataDir } from './paths.js';
 
 /**
@@ -692,6 +693,122 @@ export function removeReplyLanguageHook() {
   return { path: file, action: 'removed' };
 }
 
+// Mods: plugin folders shipped in this package's mod/ directory, which Claude
+// Code (2.1.287 and later) runs inside its own process. They are loaded through
+// CLAUDE_CODE_PLUGIN_DIRS in the env block of ~/.claude/settings.json, the one
+// way to load a plugin folder that needs neither a marketplace nor the `claude`
+// CLI at install time, so `npm i -g` stays the whole setup. An older Claude
+// Code ignores the variable, and the settings hooks keep doing the work alone.
+//
+// The variable holds absolute paths, so an entry goes stale when the package
+// moves (a Node version switch under nvm puts it in another global root). An
+// entry counts as ours by its last two segments, `mod/<a name below>`, and
+// adding a mod first drops every older path to it, so a reinstall repairs the
+// list instead of growing it. Other folders in the variable are left alone.
+const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const PLUGIN_DIRS_ENV = 'CLAUDE_CODE_PLUGIN_DIRS';
+export const DOC2MD_MOD = 'sprag-doc2md';
+export const DELEGATION_METER_MOD = 'sprag-delegation-meter';
+export const MOD_NAMES = [DOC2MD_MOD, DELEGATION_METER_MOD];
+
+export function modDir(name) {
+  return join(PACKAGE_ROOT, 'mod', name);
+}
+
+const pluginDirsSeparator = () => (process.platform === 'win32' ? ';' : ':');
+
+function isOurModEntry(entry, names) {
+  const parts = String(entry).split(/[\\/]/).filter(Boolean);
+  return parts.length >= 2 && parts[parts.length - 2] === 'mod' && names.includes(parts[parts.length - 1]);
+}
+
+function pluginDirEntries(settings) {
+  const value = isPlainObject(settings.env) ? settings.env[PLUGIN_DIRS_ENV] : undefined;
+  return typeof value === 'string' ? value.split(pluginDirsSeparator()).filter(Boolean) : [];
+}
+
+/**
+ * Point CLAUDE_CODE_PLUGIN_DIRS at this package's copy of one mod, in place on
+ * a settings object read by the caller. Returns true when the object changed,
+ * false when it already held exactly that, or a reason string when the mod is
+ * better left out: `env` is not something this can safely extend, or the user
+ * already loads mods in a way a write here would break or duplicate.
+ *
+ * `inherited` is the variable as this process received it. When settings.json
+ * has no value of its own, that is the user's shell value. Claude Code's docs
+ * say a settings `env` entry replaces the inherited value in most sessions, so
+ * a value written here would stop the user's own mods from loading; were this
+ * variable one of the exceptions, ours would be ignored instead. Either way
+ * the write is wrong, so the case is refused with the path to add by hand.
+ */
+function addModDir(settings, name, inherited = process.env[PLUGIN_DIRS_ENV]) {
+  if (settings.env !== undefined && !isPlainObject(settings.env)) return 'env is not an object — fix settings.json manually';
+  const current = settings.env?.[PLUGIN_DIRS_ENV];
+  if (current !== undefined && typeof current !== 'string') return `env.${PLUGIN_DIRS_ENV} is not a string — fix settings.json manually`;
+  // A copy installed through /plugin would run beside this one, every hook twice.
+  const installed = isPlainObject(settings.enabledPlugins)
+    ? Object.keys(settings.enabledPlugins).find((id) => id.split('@')[0] === name && settings.enabledPlugins[id])
+    : undefined;
+  if (installed) return `${name} is already installed as the plugin ${installed} — that copy stays the one that runs`;
+  const target = modDir(name);
+  const sep = pluginDirsSeparator();
+  if (current === undefined && typeof inherited === 'string') {
+    const theirs = inherited.split(sep).filter((e) => e && !isOurModEntry(e, MOD_NAMES));
+    if (theirs.length) {
+      return `${PLUGIN_DIRS_ENV} is set in your shell (${theirs.join(sep)}), and a value in settings.json would replace it — add ${target} to that variable yourself`;
+    }
+  }
+  const before = pluginDirEntries(settings);
+  const stale = before.filter((e) => e !== target && isOurModEntry(e, [name]));
+  if (before.includes(target) && stale.length === 0) return false;
+  const entries = [...before.filter((e) => !isOurModEntry(e, [name])), target];
+  settings.env = { ...(settings.env || {}), [PLUGIN_DIRS_ENV]: entries.join(sep) };
+  return true;
+}
+
+/**
+ * Drop every entry of the named mods, wherever it points. The variable goes
+ * when nothing is left in it, and `env` when this emptied it. Returns whether
+ * the object changed.
+ */
+function dropModDirs(settings, names) {
+  const before = pluginDirEntries(settings);
+  const kept = before.filter((e) => !isOurModEntry(e, names));
+  if (kept.length === before.length) return false;
+  if (kept.length) settings.env[PLUGIN_DIRS_ENV] = kept.join(pluginDirsSeparator());
+  else delete settings.env[PLUGIN_DIRS_ENV];
+  if (Object.keys(settings.env).length === 0) delete settings.env;
+  return true;
+}
+
+/** Which mods settings.json currently loads from this package's own copy. */
+export function modDirsState() {
+  const read = readSettings(join(claudeUserDir(), 'settings.json'));
+  const entries = read.state === 'ok' ? pluginDirEntries(read.settings) : [];
+  return Object.fromEntries(MOD_NAMES.map((name) => [name, entries.includes(modDir(name))]));
+}
+
+// The delegation meter only observes (see mod/sprag-delegation-meter), so it
+// ships on with the rest of installAll(), beside the PostToolUse hook that
+// feeds the transcript-based ledger it is measured against. uninstallAll()
+// takes it out with every other mod.
+export function installDelegationMeterMod() {
+  const dir = claudeUserDir();
+  const file = join(dir, 'settings.json');
+  mkdirSync(dir, { recursive: true });
+  const read = readSettings(file);
+  if (read.state === 'unusable') return { path: file, action: 'skipped', reason: read.reason };
+  const settings = read.settings;
+  const changed = addModDir(settings, DELEGATION_METER_MOD);
+  if (typeof changed === 'string') return { path: file, action: 'skipped', reason: changed };
+  if (!changed) return { path: file, action: 'exists' };
+  const writeProblem = writeSettings(file, settings);
+  if (writeProblem) return { path: file, action: 'skipped', reason: writeProblem };
+  // The action names what happened to the file, as installDelegationGuardHook's
+  // does: one entry added to a settings.json already there is an update.
+  return { path: file, action: read.state === 'absent' ? 'created' : 'updated' };
+}
+
 // Registers the PreToolUse hook that converts attached documents to Markdown
 // before the model reads them. PreToolUse rather than PostToolUse because the
 // point is to intervene before a pptx lands in the context window; afterwards
@@ -775,14 +892,22 @@ export function installDoc2mdHook() {
     }
   }
 
-  if (!hasReadHook || addedPrompt || addedWriteGuard) {
+  // The mod answers a document Read with the converted Markdown in the same
+  // call, where the hook above can only refuse it (mod/sprag-doc2md). It rides
+  // this hook's on and off so the two never disagree about doc2md being on. An
+  // `env` this cannot extend costs only the mod: the hooks still go in.
+  const modChange = addModDir(settings, DOC2MD_MOD);
+  const addedMod = modChange === true;
+  const modNote = typeof modChange === 'string' ? { modReason: modChange } : {};
+
+  if (!hasReadHook || addedPrompt || addedWriteGuard || addedMod) {
     {
       const writeProblem = writeSettings(file, settings);
       if (writeProblem) return { path: file, action: 'skipped', reason: writeProblem };
     }
-    return { path: file, action: hasReadHook ? 'updated' : 'created' };
+    return { path: file, action: hasReadHook ? 'updated' : 'created', ...modNote };
   }
-  return { path: file, action: 'exists' };
+  return { path: file, action: 'exists', ...modNote };
 }
 
 export function removeDoc2mdHook() {
@@ -805,6 +930,7 @@ export function removeDoc2mdHook() {
     if (kept.length === 0) delete settings.hooks[event];
     else settings.hooks[event] = kept;
   }
+  if (dropModDirs(settings, [DOC2MD_MOD])) touched = true;
   if (!touched) return { path: file, action: 'absent' };
   {
     const writeProblem = writeSettings(file, settings);
@@ -1022,6 +1148,10 @@ export function uninstallAll({ purge = false } = {}) {
     }
     if (isPlainObject(settings.hooks) && Object.keys(settings.hooks).length === 0) delete settings.hooks;
 
+    // Mods are found by their folder name, so a path left by an older install
+    // location goes with the current one.
+    if (dropModDirs(settings, MOD_NAMES)) result.removed.push(`env.${PLUGIN_DIRS_ENV} (mods)`);
+
     // Nothing of ours in the file means nothing to rewrite (and no backup to churn).
     if (result.removed.length > 0) {
       const writeProblem = writeSettings(file, settings);
@@ -1116,6 +1246,7 @@ export function installAll({ force = false } = {}) {
     statusline: installStatusline({ force }),
     sessionStartHook: installSessionStartHook(),
     delegationHook: installDelegationHook(),
+    delegationMeterMod: installDelegationMeterMod(),
     briefHook: installBriefHook(),
     cacheMonitorMigration: migrateLegacyCacheMonitorHook(),
     legacy: removeLegacyCommand(),

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');
   }