sprag-cli 3.62.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,7 +164,6 @@ Claude를 설치하지 않은 Codex 첫 사용자도 기록을 쌓기 전에 프
 sprag seed --agent codex
 sprag seed accept all --global --agent codex
 sprag delegate shared status --agent codex
-sprag delegate on --agent codex
 # 자동으로 정해진 난도별 모델을 바꾸고 싶을 때만:
 sprag delegate shared map T2 --from PARENT_MODEL --model SMALL_MODEL --effort high --agent codex
 sprag delegate shared map T1 --from PARENT_MODEL --model MEDIUM_MODEL --effort medium --agent codex
@@ -169,10 +174,10 @@ sprag delegate shared map T1 --from PARENT_MODEL --model MEDIUM_MODEL --effort m
 
 `map` 줄은 선택 사항입니다. 매핑하지 않은 난도는 Claude Code가 `haiku`와 `sonnet`을 실제 모델로
 풀듯이 자동으로 정해집니다. 부모 모델의 공급자에서 가격이 매겨져 있고(게이트웨이 `/model/info` 가격,
-OpenAI 직접 호출이면 공개 가격), 부모보다 싸며, 이 사용자의 Codex 세션에서 이미 실행된 모델 가운데
-가장 싼 모델이 T2, 그다음 모델이 T1이 됩니다. 그런 모델이 하나뿐이면 T1은 메인 모델이 처리하고, 하나도
-없으면 두 난도 모두 메인 모델이 처리합니다. 자동 결정은 `delegate on` 상태에서만 동작하고, route-scan이
-기록한 실행 모델을 쓰며, 아무것도 저장하지 않으므로 가격이나 실행 이력이 바뀌면 그대로 따라갑니다.
+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`를 실행하십시오.
 

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,7 +231,6 @@ A Codex-first user needs no Claude installation or transcript history:
 sprag seed --agent codex
 sprag seed accept all --global --agent codex  # or --project, after choosing scope
 sprag delegate shared status --agent codex
-sprag delegate on --agent codex
 # optional, to override the automatic tier models:
 sprag delegate shared map T2 --from PARENT_MODEL --model SMALL_MODEL --effort high --agent codex
 sprag delegate shared map T1 --from PARENT_MODEL --model MEDIUM_MODEL --effort medium --agent codex
@@ -232,11 +239,13 @@ sprag delegate shared map T1 --from PARENT_MODEL --model MEDIUM_MODEL --effort m
 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
+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.
 
@@ -352,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
@@ -364,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.62.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

@@ -19,6 +19,13 @@ 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)) {
@@ -56,13 +63,30 @@ function observedCodexModels(dir, provider) {
   } 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`. 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 }.
+ * 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' };
@@ -71,10 +95,15 @@ export function autoCodexSharedTargets({ dir = userDataDir(), home = codexUserDi
   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))]
+  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: `no cheaper priced model has run in your Codex sessions on ${provider}` };
+  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 };
 }
@@ -86,7 +115,7 @@ export function autoCodexSharedTargets({ dir = userDataDir(), home = codexUserDi
  */
 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;
+  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];
@@ -307,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;

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

@@ -2,7 +2,7 @@ import { loadConfig, saveConfig } from '../config.js';
 import { configureCodexHooks } from '../codex-installer.js';
 import { validateCodexTarget, loadCodexModelRules, addCodexModelRule, removeCodexModelRule,
   validateCodexSharedTarget, codexSharedTargets, codexDelegateMinContext, DEFAULT_DELEGATE_MIN_CONTEXT,
-  autoCodexSharedTargets } from '../codex-delegation.js';
+  autoCodexSharedTargets, codexDelegateEnabled } 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';
@@ -32,7 +32,7 @@ function printShared(cfg, { details = false } = {}) {
   const tiers = [...new Set(policies.map((r) => r.tier))];
   for (const tier of tiers) {
     const t = own(tier) || auto.targets.find((a) => a.tier === tier);
-    if (t) console.log(`${tier} -> ${t.model}${t.effort ? ` (${t.effort})` : ''}${t.auto ? ' (auto: cheaper priced model already run in Codex)' : ''}`);
+    if (t) console.log(`${tier} -> ${t.model}${t.effort ? ` (${t.effort})` : ''}${t.auto ? ' (auto: cheaper priced model Codex runs or lists)' : ''}`);
   }
   const missing = tiers.filter((tier) => !own(tier) && !auto.targets.some((a) => a.tier === tier));
   if (missing.length) {
@@ -100,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') {
@@ -145,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';
@@ -408,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');
@@ -426,9 +430,9 @@ export async function run({ args, version }) {
       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`);
+        : `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, then sprag delegate on --agent codex. No Claude installation is required.');
+    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;
   }
@@ -513,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(),