sprag-cli 3.54.0 → 3.56.0

package/src/commands/install.js

@@ -5,8 +5,12 @@
  * a legacy command file is removed automatically. Cross-platform.
  *   sprag install              # install/update the skill
  *   sprag install --force      # overwrite existing skill file
- *   sprag install --yes        # take the defaults instead of asking
- *   sprag install --no-input   # same as --yes; also implied by CTS_NO_INPUT=1
+ *   sprag install --manual     # ask before each optional step instead
+ *
+ * The default is automatic: nothing is asked, the bundled presets are
+ * registered globally, and Codex is set up too when ~/.codex exists. `--manual`
+ * restores the step-by-step questions (they still need a terminal attached).
+ * `--yes` and `--no-input` are accepted as the explicit spelling of the default.
  */
 
 import { debug } from '../debug.js';
@@ -19,12 +23,13 @@ export async function run({ hasFlag }) {
     const { userLanguage, languageDecided, setUserLanguage } = await import('../config.js');
     const { canPrompt, confirm } = await import('../prompt.js');
     const force = hasFlag('--force');
-    // Two features below write to ~/.claude and cost tokens in every session,
-    // so the install shows what they contain and asks before turning them on.
-    // Asking is only possible with a human attached: postinstall, CI and pipes
-    // fall through to the previous automatic defaults so an unattended upgrade
-    // behaves exactly as it did before.
-    const interactive = canPrompt() && !hasFlag('--yes') && !hasFlag('--no-input');
+    // Automatic unless asked otherwise. A question per step turned the install
+    // into a dozen answers before any work, and every answer has a sensible
+    // default: the harness and presets are what make the first session save
+    // tokens. `--manual` brings the questions back, and only with a terminal
+    // attached, so postinstall, CI and pipes never wait on input.
+    const manual = hasFlag('--manual') && !hasFlag('--yes') && !hasFlag('--no-input');
+    const interactive = manual && canPrompt();
 
     // Output language, decided first because every line below it — and every
     // briefing the hooks inject from here on — is written in it. Until now it
@@ -342,10 +347,37 @@ export async function run({ hasFlag }) {
     // postinstall cannot hold a conversation, and a prompt here would be
     // answered by whoever happens to be at the terminal for a set of rules
     // they have not read. All the install does is say what is waiting.
+    // Presets now live in ratchet-preset.md. Moving the ones older versions
+    // appended to ratchet.md comes first, so they are not offered again below.
     try {
-      const { pendingSeeds } = await import('../seed-rules.js');
+      const { preparePresetRatchet } = await import('../preset-ratchet.js');
+      const p = preparePresetRatchet();
+      if (p.moved) {
+        console.log('');
+        console.log(lang === 'ko'
+          ? `  preset: ratchet.md 에 있던 추천 룰 ${p.moved}건을 ${p.file} 로 옮겼습니다 (원본은 ratchet.md.bak-preset-migration).`
+          : `  preset: moved ${p.moved} bundled rule(s) from ratchet.md to ${p.file} (original kept as ratchet.md.bak-preset-migration).`);
+      }
+    } catch (e) {
+      debug('install:preset-ratchet', e); // the next session start retries
+    }
+
+    try {
+      const { pendingSeeds, acceptSeed } = await import('../seed-rules.js');
       const pending = pendingSeeds();
-      if (pending.length > 0) {
+      if (pending.length > 0 && !manual) {
+        // Automatic install registers every preset globally. Global because a
+        // preset is a tool-wide rule, not a project's; `sprag seed` lists them
+        // and `sprag harness rm` removes any one afterwards.
+        let n = 0;
+        for (const p of pending) {
+          try { if (await acceptSeed(p.id, { scope: 'global' })) n += 1; } catch (e) { debug('install:seed-accept', e); }
+        }
+        console.log('');
+        console.log(lang === 'ko'
+          ? `  seed: 추천 룰 ${n}건을 전체 프로젝트에 등록했습니다 (모델 피팅 + 래칫 프리셋). 목록: sprag seed`
+          : `  seed: registered ${n} recommended rule(s) for all projects (model-fitting + ratchet presets). List: sprag seed`);
+      } else if (pending.length > 0) {
         console.log('');
         console.log(lang === 'ko'
           ? `  seed: 추천 룰 ${pending.length}건이 대기 중입니다 (모델 피팅 + 래칫 프리셋).`
@@ -358,6 +390,70 @@ export async function run({ hasFlag }) {
       debug('install:seed-offer', e); // optional feature; never fail install
     }
 
+    // Codex, when it is installed on this machine. Without this a Codex user
+    // had to know to run `sprag install --agent codex` after the package
+    // install. Registration is all we can do: Codex still asks the user to
+    // trust the hooks in /hooks before they run, and that step stays theirs.
+    try {
+      const { codexUserDir } = await import('../agent.js');
+      const { existsSync } = await import('node:fs');
+      if (process.env.CTS_NO_CODEX !== '1' && existsSync(codexUserDir())) {
+        let proceed = true;
+        if (interactive) {
+          console.log('');
+          proceed = await confirm(lang === 'ko'
+            ? '  codex: Codex 가 설치되어 있습니다. Codex 훅과 하네스도 함께 설정할까요?'
+            : '  codex: Codex is installed here. Set up its hooks and harness too?', { defaultValue: true });
+        }
+        if (proceed) {
+          const { configureCodexHooks } = await import('../codex-installer.js');
+          const { initCodexHarness } = await import('../codex-harness.js');
+          const { loadConfig } = await import('../config.js');
+          const { setupCodexPanel, describePanelSetup } = await import('../codex-panel-setup.js');
+          const config = loadConfig() || {};
+          // A manual install asks before touching the system package manager.
+          let env = process.env;
+          if (interactive && process.platform === 'darwin') {
+            const { tmuxAvailable } = await import('../codex-panel-setup.js');
+            if (!tmuxAvailable() && !await confirm(lang === 'ko'
+              ? '  codex: tmux 가 없습니다. Homebrew 로 설치해 같은 창에 패널을 붙일까요?'
+              : '  codex: tmux is missing. Install it with Homebrew so the panel shares the Codex window?', { defaultValue: true })) {
+              env = { ...process.env, CTS_NO_TMUX: '1' };
+            }
+          }
+          let panel;
+          try { panel = setupCodexPanel({ config, env }); }
+          catch (e) {
+            debug('install:codex-panel', e);
+            const auto = process.platform === 'darwin' && config.codex?.panelAuto !== false;
+            panel = { panelAuto: auto, mode: auto ? 'window' : 'off' };
+          }
+          const hook = configureCodexHooks({ panelAuto: panel.panelAuto });
+          console.log('');
+          console.log(`  codex: hooks ${hook.action} (${hook.file})`);
+          for (const line of describePanelSetup(panel, lang)) console.log(`  codex: ${line}`);
+          if (process.env.CTS_NO_HARNESS !== '1') {
+            const h = initCodexHarness({ scope: 'global' });
+            console.log(`  codex: harness ${h.file}`);
+          }
+          try { (await import('../preset-ratchet.js')).preparePresetRatchet({ agent: 'codex' }); } catch (e) { debug('install:codex-preset', e); }
+          if (!manual) {
+            const { pendingSeeds, acceptSeed } = await import('../seed-rules.js');
+            let n = 0;
+            for (const p of pendingSeeds({ agent: 'codex' })) {
+              try { if (await acceptSeed(p.id, { scope: 'global', agent: 'codex' })) n += 1; } catch (e) { debug('install:codex-seed', e); }
+            }
+            if (n) console.log(lang === 'ko' ? `  codex: 추천 룰 ${n}건 등록` : `  codex: registered ${n} recommended rule(s)`);
+          }
+          console.log(lang === 'ko'
+            ? '  codex: Codex 에서 /hooks 를 열어 Sprag 훅을 신뢰해야 실행됩니다 (Codex 보안 정책이라 자동화할 수 없습니다).'
+            : "  codex: open /hooks in Codex and trust the Sprag hooks; Codex requires that step and it cannot be automated.");
+        }
+      }
+    } catch (e) {
+      debug('install:codex', e); // optional; `sprag install --agent codex` still works
+    }
+
     console.log('');
     console.log('Open Claude Code in any directory and just mention:');
     console.log('  "cache hit rate" / "1M context" / "5H cap" — the skill auto-activates.');

package/src/commands/route-scan.js

@@ -10,6 +10,7 @@ import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 import { readStdinJson } from '../stdin-payload.js';
 import { debug } from '../debug.js';
+import { signedUsd } from '../money.js';
 
 /**
  * Whether the user turned doc2md on.
@@ -65,7 +66,7 @@ export async function run({ args, hasFlag, numArg }) {
         return;
       }
       const t = delegationSavedTotals();
-      const money = (v) => `$${v.toFixed(2)}`;
+      const money = (v) => (v < 0 ? `-$${(-v).toFixed(2)}` : `$${v.toFixed(2)}`); // sign before the symbol
       // Lifetime leads (it is what the breakdown below adds up to); the
       // rolling windows follow as context rather than as competing headlines.
       console.log(lang === 'ko'
@@ -154,8 +155,8 @@ export async function run({ args, hasFlag, numArg }) {
         // two mean opposite things (no data vs. data showing no value).
         const measured = r.delegatedRuns
           ? (lang === 'ko'
-            ? `실제 위임 ${r.delegatedRuns}건 · 에러율 ${Math.round((r.delegatedErrRate || 0) * 100)}% · 절감 ~$${(r.savedUsd || 0).toFixed(2)}`
-            : `measured ×${r.delegatedRuns} · err ${Math.round((r.delegatedErrRate || 0) * 100)}% · saved ~$${(r.savedUsd || 0).toFixed(2)}`)
+            ? `실제 위임 ${r.delegatedRuns}건 · 에러율 ${Math.round((r.delegatedErrRate || 0) * 100)}% · 절감 ~${signedUsd(r.savedUsd || 0)}`
+            : `measured ×${r.delegatedRuns} · err ${Math.round((r.delegatedErrRate || 0) * 100)}% · saved ~${signedUsd(r.savedUsd || 0)}`)
           : (sessionRank !== null && !rs.worthDelegating(r.tier, sessionRank)
             ? (lang === 'ko'
               ? `이 규칙은 현재 기본 모델(${sessionModel}) 기준으로는 적용되지 않습니다. 세션 모델이 이미 위임 목표와 같은 급이어서 절감이 발생하지 않습니다.`
@@ -277,6 +278,10 @@ export async function run({ args, hasFlag, numArg }) {
       // when the rendering differs, so the common case is a read and a string
       // compare.
       try { mrHook.syncAllFiles(); } catch (e) { debug('route-scan:sync-ratchet', e); }
+      // Same reason for the preset ratchet: an upgrade that rewords or drops a
+      // bundled rule reaches ratchet-preset.md here, without a reinstall. It
+      // also moves presets older versions appended to ratchet.md.
+      try { (await import('../preset-ratchet.js')).preparePresetRatchet(); } catch (e) { debug('route-scan:sync-preset', e); }
       // Registered rules whose delegated-category error rate crossed the
       // health threshold since promotion — the user approved these, so a
       // status change must be briefed, not just written into the md file.

package/src/commands/seed.js

@@ -5,7 +5,8 @@
  *   sprag seed accept <id> --global     # register one rule
  *   sprag seed accept <id> --project    # ... into this project only
  *   sprag seed accept all --global      # when the user says "all of them"
- *   sprag seed skip <id> | skip all     # never offer it again
+ *   sprag seed skip <id> | skip all     # never offer it again; for an
+ *                                       # accepted preset, drop it from ratchet-preset.md
  *   sprag seed reset                    # make every preset pending again
  *
  * Scope is explicit on purpose, exactly as `harness promote` requires it: the
@@ -26,7 +27,7 @@ export async function run({ args, hasFlag, agent = 'claude', root: rootArg }) {
   const scopeFlag = () => (hasFlag('--global') ? 'global' : hasFlag('--project') ? 'project' : null);
 
   if (sub === 'reset') {
-    const n = seed.resetSeeds({ agent });
+    const n = await seed.resetSeeds({ agent });
     console.log(ko
       ? `기록된 응답 ${n}건을 지웠습니다 — 프리셋 전체가 다시 제안 대상이 됩니다.`
       : `Cleared ${n} recorded answer(s) — every preset is pending again.`);
@@ -46,9 +47,11 @@ export async function run({ args, hasFlag, agent = 'claude', root: rootArg }) {
 
     if (sub === 'skip') {
       for (const id of targets) {
-        const r = seed.skipSeed(id, { lang, root, agent });
+        const r = await seed.skipSeed(id, { lang, root, agent });
         console.log(r
-          ? (ko ? `건너뜀: ${id}` : `skipped: ${id}`)
+          ? (r.removed
+            ? (ko ? `프리셋 파일에서 뺐습니다: ${id}` : `removed from the preset file: ${id}`)
+            : (ko ? `건너뜀: ${id}` : `skipped: ${id}`))
           : (ko ? `대기 중인 프리셋이 아닙니다: ${id}` : `not a pending preset: ${id}`));
       }
       return;

package/src/commands/uninstall.js

@@ -35,6 +35,29 @@ export async function run({ hasFlag, args = [] }) {
   for (const item of r.kept) {
     console.log(lang === 'ko' ? `  유지: ${item}` : `  kept: ${item}`);
   }
+  // The install now registers Codex too when it finds it, so removal has to
+  // undo that as well; otherwise Codex keeps calling a command that may no
+  // longer exist. Only our own entries go, exactly as `uninstall --agent codex`.
+  try {
+    const { codexHookStatus, configureCodexHooks } = await import('../codex-installer.js');
+    const { codexHarnessStatus, uninitCodexHarness } = await import('../codex-harness.js');
+    const hooked = codexHookStatus().some((h) => h.registered);
+    let harness = false;
+    try { harness = codexHarnessStatus({ scope: 'global' }).configured > 0; } catch { /* no AGENTS.md */ }
+    if (hooked || harness) {
+      const hook = configureCodexHooks({ remove: true });
+      const h = uninitCodexHarness({ scope: 'global' });
+      console.log(lang === 'ko'
+        ? `  Codex: 훅 ${hook.action} (${hook.file}), 하네스 ${h.removed ? '제거' : '없음'}`
+        : `  Codex: hooks ${hook.action} (${hook.file}), harness ${h.removed ? 'removed' : 'absent'}`);
+      if (process.platform === 'darwin') {
+        try {
+          const { installPanelShell } = await import('../codex-panel-shell.js');
+          installPanelShell({ remove: true });
+        } catch (e) { /* a malformed or foreign block stays for the user to repair */ }
+      }
+    }
+  } catch { /* Codex state is optional; the Claude removal above already succeeded */ }
   if (!purge) {
     console.log(lang === 'ko'
       ? `  기록된 절감액과 설정까지 지우려면 \`${CLI_NAME} uninstall --purge\` 를 실행하십시오.`

package/src/commands/upgrade.js

@@ -31,6 +31,17 @@ export async function run({ hasFlag, version }) {
   const lang = userLanguage();
   const cmd = upgradeCommand();
 
+  // pnpm and bun skip lifecycle scripts by default, and npm skips them under
+  // ignore-scripts, so the new copy's setup (Codex hooks, tmux panel) runs here.
+  // The install is idempotent, so npm running it twice changes nothing.
+  async function runSetup() {
+    console.log('$ sprag install');
+    const installCode = await runCommand('sprag install');
+    if (installCode !== 0) console.error(lang === 'ko'
+      ? '설치 후 설정(sprag install)이 실패했습니다. 새 셸에서 sprag install 을 직접 실행하십시오.'
+      : 'Post-upgrade setup (sprag install) failed. Run sprag install in a fresh shell.');
+  }
+
   if (hasFlag('--print')) {
     console.log(cmd);
     return;
@@ -55,6 +66,7 @@ export async function run({ hasFlag, version }) {
         : `Migration command failed with exit code ${migrateCode}. Check the output above.`);
       process.exit(migrateCode);
     }
+    await runSetup();
     console.log(lang === 'ko'
       ? '이전이 끝났습니다. 새 셸에서 sprag --version 으로 확인하십시오.'
       : 'Migration done. Confirm with sprag --version in a fresh shell.');
@@ -86,6 +98,7 @@ export async function run({ hasFlag, version }) {
   // still reports the old version. Refresh the cache against the new latest so
   // the statusline chip clears on the next render instead of lingering.
   await refreshUpdateState(s.latest);
+  await runSetup();
   console.log(lang === 'ko'
     ? `설치가 끝났습니다. 새 셸에서 sprag --version 으로 ${s.latest} 인지 확인하십시오.`
     : `Done. In a fresh shell, run sprag --version to confirm ${s.latest}.`);

package/src/cost.js

@@ -197,7 +197,8 @@ function tokensToMillions(n) {
  *   ephemeral1h      — portion of cacheCreation billed at 1h rate (2x input)
  *   output           — output tokens
  */
-export function estimateCost(totals, model) {
+export function estimateCost(totals, model, { price } = {}) {
+  if (price) return estimateCostAtPrice(totals, price);
   const tier = detectPricingTier(model);
   const p = PRICING[tier];
 
@@ -248,20 +249,73 @@ export function estimateCost(totals, model) {
   };
 }
 
+/**
+ * Same shape as the list-price estimate, but priced at a gateway's per-token
+ * rates (LiteLLM /model/info). A token class the gateway does not price makes
+ * the whole estimate unknown (null) rather than free or list-priced.
+ */
+function estimateCostAtPrice(totals, price) {
+  const write5m = totals.ephemeral5m ?? 0;
+  const write1h = totals.ephemeral1h ?? 0;
+  const untracked = Math.max(0, (totals.cacheCreation ?? 0) - write5m - write1h);
+  const read = totals.cacheRead ?? 0;
+  if (read > 0 && price.cacheRead == null) return null;
+  if (write5m + untracked > 0 && price.cacheWrite == null) return null;
+  if (write1h > 0 && price.cacheWrite1h == null) return null;
+  if (price.input == null || price.output == null) return null;
+  const perM = (rate) => (rate ?? 0) * 1e6;
+  const input = perM(price.input), output = perM(price.output), cacheRead = perM(price.cacheRead);
+  const cacheWrite5m = perM(price.cacheWrite), cacheWrite1h = perM(price.cacheWrite1h);
+
+  const actual =
+    tokensToMillions(totals.input) * input +
+    tokensToMillions(write5m + untracked) * cacheWrite5m +
+    tokensToMillions(write1h) * cacheWrite1h +
+    tokensToMillions(read) * cacheRead +
+    tokensToMillions(totals.output) * output;
+  const totalInput = totals.input + (totals.cacheCreation ?? 0) + read;
+  const noCacheCost = tokensToMillions(totalInput) * input + tokensToMillions(totals.output) * output;
+
+  // The 5m scenario needs a 5m write rate; without one it is not computable, so
+  // it collapses to the actual cost and the "extra cost" row stays hidden.
+  let scenario5mCost = actual;
+  if (price.cacheWrite != null) {
+    const extra5mCreation = write1h * 2;
+    scenario5mCost =
+      tokensToMillions(totals.input) * input +
+      tokensToMillions(write5m + write1h + untracked + extra5mCreation) * cacheWrite5m +
+      tokensToMillions(Math.max(0, read - extra5mCreation)) * cacheRead +
+      tokensToMillions(totals.output) * output;
+  }
+
+  return {
+    tier: 'gateway',
+    actual: round(actual),
+    noCacheCost: round(noCacheCost),
+    savings: round(noCacheCost - actual),
+    savingsRate: noCacheCost > 0 ? (noCacheCost - actual) / noCacheCost : 0,
+    scenario5mCost: round(scenario5mCost),
+    extraCostIf5m: round(scenario5mCost - actual),
+    extraCostIf5mApplicable: price.cacheWrite != null && write1h > 0,
+  };
+}
+
 /**
  * Price a set of sessions each at its own model and sum. One estimateCost over
  * the summed totals priced every token at whichever session came first in the
  * list — sorted by mtime, so a haiku scratch session touched earliest set the
  * rate for a day of Fable work and understated the saving about tenfold.
  * Sessions whose model has no known rate are skipped, as month-spend does.
+ * `estimate` lets a caller price by path (see claude-price.js); null skips a session.
  */
-export function estimateCostAcross(sessions) {
+export function estimateCostAcross(sessions, estimate = estimateCost) {
   const acc = { actual: 0, noCacheCost: 0, scenario5mCost: 0, extraCostIf5mApplicable: false };
   const tiers = new Map();
   for (const s of sessions || []) {
     if (!s?.totals) continue;
     let c;
-    try { c = estimateCost(s.totals, s.model); } catch { continue; }
+    try { c = estimate(s.totals, s.model); } catch { continue; }
+    if (!c) continue;
     acc.actual += c.actual;
     acc.noCacheCost += c.noCacheCost;
     acc.scenario5mCost += c.scenario5mCost;

package/src/formatters/statusline.js

@@ -54,6 +54,12 @@ const GRAY = fg(100, 116, 139, '\x1b[90m');
 const BOLD = '\x1b[1m';
 
 export function formatMoney(usd) {
+  // The sign leads the currency symbol ("-$0.12"); a loss that rounds to zero
+  // prints as plain "$0.00" rather than "-$0.00".
+  if (usd < 0) {
+    const abs = formatMoney(-usd);
+    return abs === '$0.00' ? abs : `-${abs}`;
+  }
   // Boundaries sit at 999.5/999500 so a value that would round up into the
   // next band's width ($999.9 → "$1000") jumps to that band's unit instead —
   // otherwise "$1000" renders visually larger than "$1.0K".
@@ -512,8 +518,8 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // Tied to MIN_VOTES rather than a literal so the two cannot drift: the chip
   // appears exactly when learning has had its chance and still came up short.
   const unresolvedRuns = Number(data.unresolvedRuns) || 0;
-  const delegateSeg = delegationSaved > 0
-    ? `${c(GREEN)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}`
+  const delegateSeg = delegationSaved !== 0
+    ? `${c(delegationSaved < 0 ? RED : GREEN)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}`
     : (unresolvedRuns >= MIN_VOTES
       ? `${c(YELLOW)}${g.routing} ${unresolvedRuns} unresolved${c(RESET)}`
       : null);
@@ -552,8 +558,12 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   //   verbose: "Sep spend $42.1 (since Sep 1)"
   const month = data.monthSpend;
   let monthSeg = null;
-  if (month && Number(month.usd) > 0) {
-    const amt = formatMoney(Number(month.usd));
+  // Gateway sessions whose model the gateway does not price are left out of the
+  // sum and counted, so a partial total says so and an all-unpriced month is n/a.
+  const monthUnpriced = Number(month?.unpriced) || 0;
+  if (month && (Number(month.usd) > 0 || monthUnpriced > 0)) {
+    const amt = (Number(month.usd) > 0 ? formatMoney(Number(month.usd)) : 'n/a') +
+      (monthUnpriced > 0 ? ` +${monthUnpriced} unpriced` : '');
     if (isIcon) {
       monthSeg = `${c(GRAY)}${g.month} ${month.label} ${amt}${c(RESET)}`;
     } else if (verbose) {
@@ -576,7 +586,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   //   text:  "Routing saved $9.8 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
   const totals = data.delegationTotals;
   let totalsLine = null;
-  if (!singleLine && totals && Number(totals.total) > 0) {
+  if (!singleLine && totals && Number(totals.total) !== 0 && Number.isFinite(Number(totals.total))) {
     const head = isIcon ? `${g.routing} Routing saved` : 'Routing saved';
     // Model changes behind the total, family-level and version-free: `opus →
     // haiku 2× $0.6`. Versions bump constantly and add nothing here — the
@@ -595,9 +605,10 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     const pairText = pairs
       .map((p) => `${c(GRAY)}${p.from}→${p.to} ${p.runs}× ${formatMoney(p.usd)}${c(RESET)}`)
       .join(` ${c(GRAY)}·${c(RESET)} `);
+    const tone = Number(totals.total) < 0 ? RED : GREEN; // a net loss must not read as a win
     totalsLine =
-      `${c(GREEN)}${c(BOLD)}${head}${c(RESET)} ` +
-      `${c(GREEN)}${formatMoney(Number(totals.total) || 0)}${c(RESET)}` +
+      `${c(tone)}${c(BOLD)}${head}${c(RESET)} ` +
+      `${c(tone)}${formatMoney(Number(totals.total) || 0)}${c(RESET)}` +
       (pairText ? `  ${c(GRAY)}|${c(RESET)}  ${pairText}` : '');
   }
 

package/src/formatters/table.js

@@ -253,6 +253,7 @@ export function formatReport({ summary: sum, trend, ttl, anomalies, cost, option
     lines.push('  ' + tableRow(['Extra cost if 5m-only', `+$${cost.extraCostIf5m}`], costW, costA));
   }
   lines.push('  ' + tableBot(costW));
+  if (cost.unpriced > 0) lines.push(`  ${cost.unpriced} session(s) not priced by the gateway are left out.`);
   lines.push('');
 
   // Daily trend

package/src/gateway-prices.js

@@ -0,0 +1,39 @@
+// LiteLLM /model/info prices, shared by the Codex and Claude sides. Per-token USD; both sides
+// price a call by the path it took, so these are only ever the gateway's own numbers.
+export const PRICE_MAX_AGE_MS = 7 * 86400000;
+export const rate = (value) => Number.isFinite(value) && value >= 0 && value < 1 ? value : null;
+
+export function deploymentPrice(row) {
+  const info = row?.model_info || {};
+  const mode = typeof info.mode === 'string' ? info.mode : null;
+  if (mode && !['chat', 'responses', 'completion'].includes(mode)) return null;
+  const input = rate(info.input_cost_per_token), output = rate(info.output_cost_per_token);
+  if (input === null || output === null) return null;
+  return { input, output, cacheRead: rate(info.cache_read_input_token_cost), cacheWrite: rate(info.cache_creation_input_token_cost),
+    cacheWrite1h: rate(info.cache_creation_input_token_cost_above_1hr) };
+}
+
+/** Per-token prices by alias. Load-balanced deployments must agree, like cache policy. */
+export function gatewayPrices(payload) {
+  if (!Array.isArray(payload?.data)) throw new Error('LiteLLM model/info returned no model list');
+  const groups = new Map();
+  for (const row of payload.data) {
+    if (typeof row?.model_name !== 'string' || row.model_name.length > 256) continue;
+    groups.set(row.model_name, [...(groups.get(row.model_name) || []), deploymentPrice(row)]);
+  }
+  return Object.fromEntries([...groups].map(([name, prices]) => [name,
+    prices[0] && prices.every((p) => JSON.stringify(p) === JSON.stringify(prices[0])) ? prices[0] : null]));
+}
+
+/**
+ * USD for a token mix at one model's prices, or null when a needed rate is
+ * missing. Cached input without a cache-read rate is unknown, not free.
+ */
+export function codexRunCost({ input = 0, cached = 0, cacheWrite = 0, output = 0 }, price) {
+  if (!price || price.input === null || price.output === null) return null;
+  if (cached > 0 && price.cacheRead === null) return null;
+  // cache_write_input_tokens is billed at the creation rate when one is published, else as input.
+  const uncached = Math.max(0, input - cached - cacheWrite);
+  return uncached * price.input + cached * (price.cacheRead ?? 0) + cacheWrite * (price.cacheWrite ?? price.input) + output * price.output;
+}
+

package/src/harness-templates.js

@@ -40,6 +40,38 @@ export function modelRatchetImportLine(scope = 'project') {
   return scope === 'global' ? '@~/.claude/ratchet-model.md' : '@.claude/ratchet-model.md';
 }
 
+/**
+ * The preset ratchet: the bundled rules the user accepted globally. It is a
+ * tool-owned file like ratchet-model.md, regenerated whole from the recorded
+ * answers, so an upgrade can reword, add or drop presets without touching the
+ * rules the user wrote into ratchet.md. Presets are global-only, so only the
+ * global block imports it.
+ */
+export function presetRatchetImportLine() {
+  return '@~/.claude/ratchet-preset.md';
+}
+export const PRESET_RATCHET_IMPORT_RE = /^@~\/\.claude\/ratchet-preset\.md\s*$/m;
+
+/**
+ * Render ratchet-preset.md. `rules` is [{ id, text }] in display order. The
+ * file is loaded into every session, so the header stays short.
+ */
+export function renderPresetRatchet(rules, { lang = 'en', agent = 'claude' } = {}) {
+  const ko = lang === 'ko' && agent !== 'codex';
+  const suffix = agent === 'codex' ? ' --agent codex' : '';
+  const head = ko
+    ? `# Preset Ratchet Rules (sprag 관리)
+
+sprag 에 동봉된 추천 룰 가운데 전역으로 등록한 것입니다. sprag 가 이 파일을 통째로 다시 쓰므로
+직접 고치지 마십시오. 하나를 빼려면 \`sprag seed skip <id>${suffix}\`, 직접 쓰는 룰은 ratchet.md 에 둡니다.`
+    : `# Preset Ratchet Rules (managed by sprag)
+
+Bundled rules you registered globally. Sprag rewrites this file whole, so do not
+edit it. Drop one with \`sprag seed skip <id>${suffix}\`; your own rules belong in ratchet.md.`;
+  const body = rules.map((r) => `- [${r.id}] ${r.text}`).join('\n');
+  return `${head}\n\n## Rules\n\n${body}${body ? '\n' : ''}`;
+}
+
 // Matches either scope's import line, so completeness checks don't need to know
 // which scope wrote the block. `(?!-)` keeps the ratchet-model import from
 // counting as the ratchet.md one.
@@ -118,7 +150,7 @@ ${HARNESS_SECTIONS[4].heading}
 📥 ratchet 룰 로드 (이 줄들을 지우면 룰이 적용되지 않습니다):
 
 ${ratchetImportLine(scope)}
-${modelRatchetImportLine(scope)}
+${modelRatchetImportLine(scope)}${scope === 'global' ? `\n${presetRatchetImportLine()}` : ''}
 ${HARNESS_BLOCK_END}
 `;
 }

package/src/harness.js

@@ -21,6 +21,7 @@ import {
   appendRatchetRule,
   RATCHET_IMPORT_RE,
   MODEL_RATCHET_IMPORT_RE,
+  renderPresetRatchet,
 } from './harness-templates.js';
 import { routeWarningForStatusline } from './route-scan.js';
 import { ruleHealthWarningForStatusline, modelRatchetPathFor, renderModelRatchet } from './model-rules.js';
@@ -265,6 +266,18 @@ export function harnessInit({ root = findProjectRoot(), force = false, scope = '
     result.skipped.push(mrPath + ' (already exists)');
   }
 
+  // ratchet-preset.md — tool-owned and imported by the global block only, so
+  // it is seeded here for the same reason as ratchet-model.md above.
+  if (scope === 'global') {
+    const prPath = join(homedir(), '.claude', 'ratchet-preset.md');
+    if (!existsSync(prPath)) {
+      try {
+        writeFileSync(prPath, renderPresetRatchet([], { lang: userLanguage() }));
+        result.wrote.push(prPath);
+      } catch { /* unwritable — the next session start renders it */ }
+    }
+  }
+
   return result;
 }
 
@@ -347,7 +360,19 @@ export function harnessPromote(ruleText, { root = findProjectRoot(), scope = 'pr
  * Deduped by rule text (ignoring the YYYY-MM-DD stamp) — idempotent.
  * Returns { path, scope, added, skippedRules, presets }.
  */
-export function harnessPull({ root = findProjectRoot(), scope = 'global', agent = 'claude' } = {}) {
+export async function harnessPull({ root = findProjectRoot(), scope = 'global', agent = 'claude' } = {}) {
+  // Global presets live in ratchet-preset.md now, rendered from recorded
+  // answers, so pulling them globally is accepting every one of them.
+  if (scope === 'global') {
+    const { acceptedGlobalPresets, presetRatchetPath } = await import('./preset-ratchet.js');
+    const { pendingSeeds, acceptSeed } = await import('./seed-rules.js');
+    const added = [];
+    for (const s of pendingSeeds({ root, agent }).filter((x) => x.kind === 'ratchet')) {
+      if (await acceptSeed(s.id, { scope: 'global', root, agent })) added.push(s.ruleText);
+    }
+    const all = acceptedGlobalPresets({ agent }).length;
+    return { path: presetRatchetPath({ agent }), scope, added, skippedRules: all - added.length, presets: presetRuleEntries().length };
+  }
   const presets = presetRules();
   const rmPath = resolveRatchetPath(scope, root, agent);
   const result = { path: rmPath, scope, added: [], skippedRules: 0, presets: presets.length };