sprag-cli 3.54.0 → 3.56.0

package/src/litellm-models.js

@@ -27,6 +27,7 @@
 import { gatewayBase } from './gateway-auth.js';
 import { loadProfileMap, updateProfileMap, resetModelAliasCache, profileIdFrom, isGatewayModelId } from './model-alias.js';
 import { isRecognizedModelId } from './cost.js';
+import { deploymentPrice, PRICE_MAX_AGE_MS } from './gateway-prices.js';
 import { debug } from './debug.js';
 
 /** 게이트웨이 모델 맵의 신선도 기준. 배포 구성은 하루에 여러 번 바뀌지 않습니다. */
@@ -70,6 +71,23 @@ function normalizeCandidate(id) {
   return s.replace(/\[[^\]]*\]$/, '');
 }
 
+/**
+ * 배포 항목 하나의 별칭을 고릅니다. model_name → model_info.base_model →
+ * litellm_params.model 순으로 정규화해 isRecognizedModelId()를 통과하는 첫
+ * 후보이며, 없으면 null입니다. 별칭 추출과 가격 키 등록이 같은 판정을 쓰도록
+ * 한 곳에 둡니다.
+ */
+function pickAlias(item) {
+  const modelName = typeof item.model_name === 'string' ? item.model_name : '';
+  const baseModel = typeof item.model_info?.base_model === 'string' ? item.model_info.base_model : '';
+  const rawModel = typeof item.litellm_params?.model === 'string' ? item.litellm_params.model : '';
+  for (const candidate of [modelName, baseModel, rawModel]) {
+    const normalized = normalizeCandidate(candidate);
+    if (normalized && isRecognizedModelId(normalized)) return normalized;
+  }
+  return null;
+}
+
 /**
  * `/model/info` 응답에서 프로파일 ID(또는 계열명 없는 사내 별칭) → 모델 계열
  * 매핑을 뽑아냅니다. 순수 함수입니다: 네트워크·파일 I/O가 없고, 잘못된 입력에도
@@ -99,17 +117,8 @@ export function deriveAliasesFromModelInfo(payload) {
   for (const item of data) {
     if (!item || typeof item !== 'object') continue;
     const modelName = typeof item.model_name === 'string' ? item.model_name : '';
-    const baseModel = typeof item.model_info?.base_model === 'string' ? item.model_info.base_model : '';
     const rawModel = typeof item.litellm_params?.model === 'string' ? item.litellm_params.model : '';
-
-    let alias = null;
-    for (const candidate of [modelName, baseModel, rawModel]) {
-      const normalized = normalizeCandidate(candidate);
-      if (normalized && isRecognizedModelId(normalized)) {
-        alias = normalized;
-        break;
-      }
-    }
+    const alias = pickAlias(item);
 
     if (!alias) {
       if (modelName) skipped.push(modelName);
@@ -134,6 +143,58 @@ export function deriveAliasesFromModelInfo(payload) {
   return { aliases, skipped, count: data.length };
 }
 
+/**
+ * `/model/info` 응답에서 모델 키 → 토큰당 가격 표를 만듭니다. 순수 함수입니다.
+ *
+ * 한 배포 항목의 가격을 model_name, 정규화한 model_name·base_model·
+ * litellm_params.model, 그리고 별칭 추출이 고른 별칭 아래에 모두 등록합니다.
+ * 트랜스크립트의 모델 문자열이 어느 모양으로 오든 찾을 수 있게 하려는 것입니다.
+ * 같은 키에 서로 다른 가격이 들어오면 어느 쪽이 맞는지 알 수 없으므로 null로
+ * 둡니다. 값은 숫자뿐이고, 키는 normalizeCandidate를 거쳐 ARN이 리소스 부분으로
+ * 줄어 있으므로 AWS 계정 ID가 파일에 남지 않습니다.
+ *
+ * @returns {Record<string, object|null>}
+ */
+export function deriveGatewayPrices(payload) {
+  const data = Array.isArray(payload?.data) ? payload.data : [];
+  const prices = new Map();
+  for (const item of data) {
+    if (!item || typeof item !== 'object') continue;
+    const price = deploymentPrice(item);
+    const keys = new Set([
+      // 원문 model_name이 ARN이면 계정 ID가 있으므로 원문 키는 쓰지 않습니다.
+      typeof item.model_name === 'string' && !isGatewayModelId(item.model_name) ? item.model_name : '',
+      normalizeCandidate(item.model_name),
+      normalizeCandidate(item.model_info?.base_model),
+      normalizeCandidate(item.litellm_params?.model),
+      pickAlias(item) || '',
+    ]);
+    for (const key of keys) {
+      if (!key) continue;
+      if (!prices.has(key)) prices.set(key, price);
+      else if (JSON.stringify(prices.get(key)) !== JSON.stringify(price)) prices.set(key, null);
+    }
+  }
+  return Object.fromEntries(prices);
+}
+
+/**
+ * LiteLLM 경로로 나간 호출의 모델 가격(토큰당 USD). 게이트웨이 표에 없거나,
+ * 표가 PRICE_MAX_AGE_MS보다 오래됐거나, 키가 모호하면 null입니다. 정가표로
+ * 대신 채우지 않습니다. 호출이 실제로 지난 경로의 가격만 씁니다.
+ */
+export function gatewayPriceFor(model, env = process.env, now = Date.now()) {
+  const gateway = readGatewayModelMap(env);
+  if (!gateway?.prices || typeof gateway.prices !== 'object') return null;
+  const fetchedAt = Date.parse(gateway.fetchedAt);
+  if (!Number.isFinite(fetchedAt) || fetchedAt > now || now - fetchedAt > PRICE_MAX_AGE_MS) return null;
+  if (typeof model !== 'string' || !model) return null;
+  for (const key of [model, normalizeCandidate(model)]) {
+    if (key && Object.hasOwn(gateway.prices, key)) return gateway.prices[key] || null;
+  }
+  return null;
+}
+
 /**
  * profile-map.json의 gateway 절을 읽습니다. base가 현재 gatewayBase(env)와
  * 다르면 다른 게이트웨이의 캐시이므로 null을 돌려줍니다. 예산 캐시(budgetWindow)
@@ -240,6 +301,7 @@ export async function refreshGatewayModelMap({ base, key, fetchImpl = fetch } =
         base,
         fetchedAt: new Date().toISOString(),
         aliases: result.aliases,
+        prices: deriveGatewayPrices(payload),
         skipped: result.skipped,
         count: result.count,
       },

package/src/model-rules.js

@@ -34,6 +34,7 @@ import { homedir } from 'node:os';
 import { userDataDir } from './paths.js';
 import { userLanguage } from './config.js';
 import { agentPhrase, agentPhraseEn } from './agents.js';
+import { signedUsd } from './money.js';
 
 // Post-promotion delegated-category error rate above this flags the rule
 // for review (rule-health). Calibrated against local T0 avg error incidence.
@@ -356,7 +357,7 @@ export function renderModelRatchet(rules, lang = userLanguage()) {
       ? `preset (curated), registered ${r.promotedAt}`
       : `×${r.count || 0}, err ${pct(r.errRate)}%, seen ${r.lastSeen || r.promotedAt}`;
     if (!r.delegatedRuns) return base;
-    const saved = r.savedUsd ? `, saved ~$${r.savedUsd.toFixed(2)}` : '';
+    const saved = r.savedUsd ? `, saved ~${signedUsd(r.savedUsd)}` : '';
     return `${base}, delegated ×${r.delegatedRuns} err ${pct(r.delegatedErrRate)}%${saved}`;
   };
   // Merged T2+T1 rules carry two caps, so they state both once rather than

package/src/money.js

@@ -0,0 +1,9 @@
+/**
+ * A signed dollar amount for text output: "-$0.12" for a loss, "$0.12" for a
+ * saving. Routing savings are recorded signed, and "~$-0.12" misreads as a
+ * formatting glitch rather than a loss.
+ */
+export function signedUsd(usd, digits = 2) {
+  const fixed = Math.abs(usd).toFixed(digits);
+  return usd < 0 && Number(fixed) !== 0 ? `-$${fixed}` : `$${fixed}`;
+}

package/src/month-spend.js

@@ -4,10 +4,12 @@
  * LiteLLM·Bedrock처럼 5h/7d cap 이 아예 없는 게이트웨이 사용자도
  * "이번 달에 얼마나 썼는지"는 늘 궁금하므로, 세션 로그를 기반으로
  * 달력 월 단위 지출을 통계선에 상시 노출합니다. 모델 단가는 세션마다
- * 다르므로 세션별로 estimateCost 를 적용해 합산합니다.
+ * 다르므로 세션별로 호출 경로에 맞는 가격(sessionCost)을 적용해 합산합니다.
+ * LiteLLM 게이트웨이 세션은 게이트웨이 가격표로만 계산하고, 표에 없는 모델은
+ * 합계에서 빼고 unpriced 로 셉니다. 정가표로 대신 채우지 않습니다.
  */
 
-import { estimateCost } from './cost.js';
+import { sessionCost } from './claude-price.js';
 
 /** 이번 달 1일 00:00(로컬)의 epoch ms. */
 export function monthStartMs(now = new Date()) {
@@ -27,21 +29,24 @@ export function monthLabel(now = new Date()) {
  *
  * @param {Array} sessions parseAllSessions 결과
  * @param {Date} [now]
- * @returns {{usd:number, sessions:number, sinceMs:number, label:string}}
+ * @returns {{usd:number, sessions:number, unpriced:number, sinceMs:number, label:string}}
  */
 export function monthSpend(sessions, now = new Date()) {
   const since = monthStartMs(now);
   let usd = 0;
   let count = 0;
+  let unpriced = 0;
   for (const s of sessions || []) {
     if (!s || !s.endTime || s.endTime.getTime() < since) continue;
     if (!s.totals) continue;
     try {
-      usd += estimateCost(s.totals, s.model).actual;
+      const c = sessionCost(s.totals, s.model);
+      if (!c) { unpriced += 1; continue; }
+      usd += c.actual;
       count += 1;
     } catch {
       // 단가를 모르는 모델은 합계에서 빠집니다. 통계선에서는 침묵이 낫습니다.
     }
   }
-  return { usd, sessions: count, sinceMs: since, label: monthLabel(now) };
+  return { usd, sessions: count, unpriced, sinceMs: since, label: monthLabel(now) };
 }

package/src/openai-prices.js

@@ -0,0 +1,33 @@
+// OpenAI list prices for Codex calls that go straight to OpenAI (ChatGPT/OpenAI login).
+// Source: https://developers.openai.com/api/docs/pricing , "Standard" tier, short-context
+// rates, checked 2026-10-01. Long-context surcharges are not modeled, so requests past the
+// long-context threshold are under-priced. Calls through a LiteLLM gateway never use this table.
+export const OPENAI_PRICES_CHECKED_AT = Date.parse('2026-10-01T00:00:00Z');
+
+// Per-1M-token numbers as listed on the page; null where the page shows "-".
+const PER_MILLION = {
+  'gpt-6-astra': [10, 1, 12.5, 50],
+  'gpt-6.1-sol': [2, 0.1, 2.5, 10],
+  'gpt-6-luna': [0.1, 0.01, 0.125, 0.5],
+  'gpt-6-sol': [2, 0.2, 2.5, 10],
+  'gpt-5.6-sol': [4, 0.4, 5, 20],
+  'gpt-5.6-terra': [2, 0.2, 2.5, 12],
+  'gpt-5.6-luna': [0.2, 0.02, 0.25, 1.2],
+  'gpt-5.5': [5, 0.5, null, 30],
+  'gpt-5.5-pro': [30, null, null, 180],
+  'gpt-5.4': [2.5, 0.25, null, 15],
+  'gpt-5.4-pro': [30, null, null, 180],
+  'gpt-5.4-mini': [0.75, 0.075, null, 4.5],
+  'gpt-5.4-nano': [0.2, 0.02, null, 1.25],
+  'gpt-5.2': [1.75, 0.175, null, 14],
+  'gpt-5.2-pro': [21, null, null, 168],
+  'gpt-5.1': [1.25, 0.125, null, 10],
+  'gpt-5': [1.25, 0.125, null, 10],
+};
+
+// Parse "<n>e-6" instead of dividing so 0.1 per 1M is exactly 1e-7, without float noise.
+const perToken = (n) => (n === null ? null : Number(`${n}e-6`));
+
+/** model -> per-token USD `{ input, cacheRead, cacheWrite, output }`. */
+export const OPENAI_LIST_PRICES = Object.fromEntries(Object.entries(PER_MILLION).map(([model, [input, cacheRead, cacheWrite, output]]) =>
+  [model, { input: perToken(input), cacheRead: perToken(cacheRead), cacheWrite: perToken(cacheWrite), output: perToken(output) }]));

package/src/preset-ratchet.js

@@ -0,0 +1,133 @@
+/**
+ * preset-ratchet — the bundled ratchet presets the user accepted globally,
+ * kept in a file of their own.
+ *
+ * Presets used to be appended to ratchet.md next to the user's own rules. Once
+ * there, an upgrade could not reword a preset, drop one that turned out wrong,
+ * or tell which lines were ours: every line looked like the user's. This file
+ * holds only presets and is regenerated whole from the recorded answers in
+ * seed-state, the same way ratchet-model.md is regenerated from the rule
+ * registry. So an upgrade updates it by itself, `seed skip` removes one, and
+ * ratchet.md stays the user's.
+ *
+ *   Claude Code  ~/.claude/ratchet-preset.md   (imported by the global harness block)
+ *   Codex        <CODEX_HOME>/ratchet-preset.md (injected by the SessionStart hook)
+ *
+ * Presets accepted into a project scope still go to that project's ratchet.md:
+ * a project rule is the user's placement decision, not a tool-wide default.
+ */
+
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { codexUserDir } from './agent.js';
+import { userLanguage } from './config.js';
+import {
+  HARNESS_BLOCK_BEGIN,
+  HARNESS_BLOCK_END,
+  PRESET_RATCHET_IMPORT_RE,
+  presetRatchetImportLine,
+  renderPresetRatchet,
+} from './harness-templates.js';
+import { loadSeedState, ratchetPresets, saveSeedState } from './seed-rules.js';
+
+export function presetRatchetPath({ agent = 'claude' } = {}) {
+  return agent === 'codex'
+    ? join(codexUserDir(), 'ratchet-preset.md')
+    : join(homedir(), '.claude', 'ratchet-preset.md');
+}
+
+function globalRatchetPath(agent) {
+  return agent === 'codex' ? join(codexUserDir(), 'ratchet.md') : join(homedir(), '.claude', 'ratchet.md');
+}
+
+function writeIfChanged(file, text) {
+  let before = null;
+  try { before = readFileSync(file, 'utf8'); } catch { /* first write */ }
+  if (before === text) return false;
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  writeFileSync(tmp, text);
+  renameSync(tmp, file);
+  return true;
+}
+
+/** The accepted-global presets, in the bundled order, with this version's wording. */
+export function acceptedGlobalPresets({ agent = 'claude', lang = userLanguage() } = {}) {
+  const { decided } = loadSeedState({ agent });
+  return ratchetPresets(lang, { agent })
+    .filter((p) => decided[p.id]?.action === 'accepted' && decided[p.id]?.scope === 'global')
+    .map((p) => ({ id: p.id, text: p.text }));
+}
+
+/**
+ * Rewrite the preset file from the recorded answers. A preset that a newer
+ * release removed simply stops being rendered; its answer stays in seed-state
+ * so it is not offered again if it comes back under the same text.
+ */
+export function syncPresetRatchet({ agent = 'claude', lang = userLanguage() } = {}) {
+  const file = presetRatchetPath({ agent });
+  const rules = acceptedGlobalPresets({ agent, lang });
+  const changed = writeIfChanged(file, renderPresetRatchet(rules, { lang, agent }));
+  return { file, rules: rules.length, changed };
+}
+
+/**
+ * Move presets that earlier versions appended to the global ratchet.md into
+ * the preset file. A line counts as a preset only when its text, without the
+ * date stamp, equals a bundled rule in either language, so nothing the user
+ * wrote themselves is touched. The original is backed up once before the
+ * first change.
+ */
+export function migrateLegacyPresetRules({ agent = 'claude' } = {}) {
+  const file = globalRatchetPath(agent);
+  if (!existsSync(file)) return { file, moved: 0 };
+  const byText = new Map();
+  for (const lang of ['ko', 'en']) {
+    for (const p of ratchetPresets(lang, { agent })) byText.set(p.text.trim(), p.id);
+  }
+  const stamp = /^\d{4}-\d{2}-\d{2}(\s*\([^)]*\))?:\s*/;
+  const original = readFileSync(file, 'utf8');
+  const moved = [];
+  const kept = original.split('\n').filter((line) => {
+    const m = line.match(/^\s*-\s+(.*)$/);
+    if (!m) return true;
+    const id = byText.get(m[1].replace(stamp, '').trim());
+    if (!id) return true;
+    moved.push(id);
+    return false;
+  });
+  if (!moved.length) return { file, moved: 0 };
+  writeFileSync(`${file}.bak-preset-migration`, original);
+  writeIfChanged(file, kept.join('\n'));
+  const state = loadSeedState({ agent });
+  const today = new Date().toISOString().slice(0, 10);
+  for (const id of moved) state.decided[id] = { action: 'accepted', at: today, scope: 'global', migrated: true };
+  saveSeedState(state, { agent });
+  return { file, moved: moved.length };
+}
+
+/**
+ * Add the preset import to a global harness block written before the file
+ * existed. Only the tool's own marked block is edited; a CLAUDE.md without the
+ * block is left alone, since the user chose not to install the harness there.
+ */
+export function ensurePresetImport() {
+  const file = join(homedir(), '.claude', 'CLAUDE.md');
+  let text;
+  try { text = readFileSync(file, 'utf8'); } catch { return { file, added: false }; }
+  const begin = text.indexOf(HARNESS_BLOCK_BEGIN);
+  const end = text.indexOf(HARNESS_BLOCK_END);
+  if (begin < 0 || end < begin) return { file, added: false };
+  if (PRESET_RATCHET_IMPORT_RE.test(text.slice(begin, end))) return { file, added: false };
+  writeFileSync(file, `${text.slice(0, end)}${presetRatchetImportLine()}\n${text.slice(end)}`);
+  return { file, added: true };
+}
+
+/** Everything a session start or an install does: migrate, render, and wire the import. */
+export function preparePresetRatchet({ agent = 'claude', lang = userLanguage() } = {}) {
+  const migrated = migrateLegacyPresetRules({ agent });
+  const synced = syncPresetRatchet({ agent, lang });
+  const imported = agent === 'codex' ? { added: false } : ensurePresetImport();
+  return { ...synced, moved: migrated.moved, importAdded: imported.added };
+}

package/src/route-scan.js

@@ -25,7 +25,8 @@ import { collectSessionRecords } from './session-records.js';
 import {
   collectSubagentRuns, indexRuns, exactRunsForEpisode, fallbackRunsForEpisode,
 } from './subagent-records.js';
-import { estimateCost, modelRank, isRecognizedModelId, TIER_TARGET_RANK, tierForRank } from './cost.js';
+import { modelRank, isRecognizedModelId, TIER_TARGET_RANK, tierForRank } from './cost.js';
+import { sessionCost } from './claude-price.js';
 import { learnProfileMapping, resetModelAliasCache } from './model-alias.js';
 import { modelRuleBaseText } from './model-rules.js';
 
@@ -115,7 +116,8 @@ const CATEGORIES = [
     label: '탐색·조회 (파일/값 찾기)',
     labelEn: 'lookup (finding files/values)',
     agent: 'haiku-explore',
-    kw: [[/grep|검색|search|find/i, 2], [/찾아|어디|위치|목록|살펴/i, 1]],
+    kw: [[/grep|검색|search|find/i, 2], [/찾아|어디|위치|목록|살펴/i, 1],
+      [/정의(?:돼|되어)\s*있|어느\s*파일|어떤\s*파일에|\bwhich\s+file\b|\bwhere\s+(?:is|are)\b[^?\n]*\bdefined\b/i, 1]],
   },
   {
     id: 'read',
@@ -333,9 +335,13 @@ export function worthDelegating(tier, rank) {
  * Approximation, deliberately stated as one: it holds token counts constant,
  * which a cheaper model would not reproduce exactly. Directionally right and
  * enough to rank rules by value, so it is rendered as "~$X".
+ *
+ * Signed: a run that moved to a pricier model is a loss and comes back
+ * negative. null means a side has no price (a gateway session whose /model/info
+ * table lacks the model), which is unpriced, not zero.
  */
 export function runSaving(run, mainModel) {
-  if (!run.model || !mainModel) return 0;
+  if (!run.model || !mainModel) return null;
   const totals = {
     input: run.input,
     cacheCreation: run.cacheCreation,
@@ -344,9 +350,10 @@ export function runSaving(run, mainModel) {
     ephemeral1h: run.ephemeral1h,
     output: run.out,
   };
-  const actual = estimateCost(totals, run.model).actual;
-  const counterfactual = estimateCost(totals, mainModel).actual;
-  return Math.max(0, counterfactual - actual);
+  const actual = sessionCost(totals, run.model);
+  const counterfactual = sessionCost(totals, mainModel);
+  if (!actual || !counterfactual) return null;
+  return counterfactual.actual - actual.actual;
 }
 
 const clamp = (v, [lo, hi]) => Math.min(hi, Math.max(lo, v));
@@ -549,7 +556,7 @@ export async function runRouteScan({ days = 14 } = {}) {
     d.runs += 1;
     if (isFailedRun(run)) d.errRuns += 1;
     d.outTokens += run.out || 0;
-    d.savedUsd += saved;
+    if (Number.isFinite(saved)) d.savedUsd += saved; // unpriced runs add nothing
     delegatedStats.set(key, d);
   };
   // Ledger events feed the statusline's weekly/monthly "Routing saved"
@@ -759,7 +766,8 @@ export async function runRouteScan({ days = 14 } = {}) {
       // profile-map.json's `modelAliases` to bring these runs back in.
       if (!baseline || !isRecognizedModelId(baseline)) continue;
       const usd = runSaving(e.run, baseline);
-      if (usd <= 0) continue;
+      // A loss is recorded too; only an unpriced run (null) has nothing to record.
+      if (!Number.isFinite(usd)) continue;
       priced.push({
         key: e.run.path,
         ts: e.run.endedAt ?? e.run.startedAt ?? Date.now(),

package/src/savings-ledger.js

@@ -29,6 +29,9 @@ import { userDataDir } from './paths.js';
 const WEEK_MS = 7 * 24 * 3600 * 1000;
 const MONTH_MS = 30 * 24 * 3600 * 1000;
 
+/** Stored USD is kept to 4 decimals so re-scans compare equal and files stay small. */
+export const roundUsd = (usd) => Math.round(Number(usd) * 10000) / 10000;
+
 export function ledgerPath() {
   return join(userDataDir(), 'delegation-ledger.json');
 }
@@ -55,8 +58,9 @@ export function loadLedger() {
  * Upsert saving events. `events` is an array of
  * { key, ts, usd, rule, from, to } where `key` is the run's transcript path
  * (unique per subagent run) and `from`/`to` name the models the routing
- * decision moved between. Zero-saving runs are skipped — they carry no
- * information the totals care about.
+ * decision moved between. `usd` is signed: a run on a pricier model is a loss
+ * and is recorded as a negative amount so it reduces the totals. Only
+ * non-finite amounts (unpriced runs) are skipped.
  */
 export function recordDelegationEvents(events) {
   if (!Array.isArray(events) || events.length === 0) return;
@@ -64,9 +68,9 @@ export function recordDelegationEvents(events) {
   data.version = LEDGER_VERSION;
   let changed = false;
   for (const e of events) {
-    if (!e || !e.key || !(Number(e.usd) > 0) || !Number.isFinite(e.ts)) continue;
+    if (!e || !e.key || typeof e.usd !== 'number' || !Number.isFinite(e.usd) || !Number.isFinite(e.ts)) continue;
     const prev = data.events[e.key];
-    const usd = Math.round(Number(e.usd) * 10000) / 10000;
+    const usd = roundUsd(e.usd);
     if (prev && prev.ts === e.ts && prev.usd === usd) continue;
     data.events[e.key] = {
       ts: e.ts,
@@ -115,8 +119,8 @@ export function delegationSavedTotals(now = Date.now()) {
   const byPair = new Map();
   try {
     for (const e of Object.values(loadLedger().events)) {
-      const usd = Number(e.usd) || 0;
-      if (usd <= 0) continue;
+      const usd = Number(e.usd);
+      if (!Number.isFinite(usd)) continue;
       totals.total += usd;
       if (Number.isFinite(e.ts)) {
         if (now - e.ts <= WEEK_MS) totals.week += usd;

package/src/seed-rules.js

@@ -177,6 +177,15 @@ export async function acceptSeed(id, { scope, root = findProjectRoot(), lang = u
   if (!seed) return null;
 
   if (seed.kind === 'ratchet') {
+    // A global preset goes to the tool-owned preset file, which is rendered
+    // from the recorded answer; a project one is the user's placement and is
+    // appended to that project's ratchet.md as before.
+    if (scope === 'global') {
+      recordDecision(id, 'accepted', { scope }, { agent });
+      const { syncPresetRatchet } = await import('./preset-ratchet.js');
+      const res = syncPresetRatchet({ agent, lang });
+      return { id, kind: 'ratchet', scope, path: res.file, rule: seed.ruleText };
+    }
     const res = harnessPromote(seed.ruleText, { root, scope, agent });
     recordDecision(id, 'accepted', { scope }, { agent });
     return { id, kind: 'ratchet', scope, path: res.path, rule: seed.ruleText };
@@ -218,23 +227,39 @@ export async function acceptSeed(id, { scope, root = findProjectRoot(), lang = u
     lastSeen: today,
   });
   const written = syncAllFiles();
-  recordDecision(id, 'accepted', { scope });
+  recordDecision(id, 'accepted', { scope }, { agent });
   return { id, kind: 'model', scope, paths: written, rule: composeRuleText(entry.rule, entry, lang) };
 }
 
-/** Record a "no" so the rule is never offered again (until `seed reset`). */
-export function skipSeed(id, opts = {}) {
+/**
+ * Record a "no" so the rule is never offered again (until `seed reset`).
+ *
+ * A preset already accepted globally can be skipped too: that is how one comes
+ * out of the preset file, which is rendered from these answers.
+ */
+export async function skipSeed(id, opts = {}) {
   const seed = findSeed(id, opts);
-  if (!seed) return null;
-  recordDecision(id, 'skipped', {}, { agent: opts.agent });
-  return { id, kind: seed.kind, rule: seed.ruleText };
+  if (seed) {
+    recordDecision(id, 'skipped', {}, { agent: opts.agent });
+    return { id, kind: seed.kind, rule: seed.ruleText };
+  }
+  const { decided } = loadSeedState({ agent: opts.agent });
+  const preset = ratchetPresets(opts.lang, { agent: opts.agent }).find((p) => p.id === id);
+  if (!preset || decided[id]?.action !== 'accepted' || decided[id]?.scope !== 'global') return null;
+  recordDecision(id, 'skipped', { was: 'accepted' }, { agent: opts.agent });
+  const { syncPresetRatchet } = await import('./preset-ratchet.js');
+  syncPresetRatchet({ agent: opts.agent, lang: opts.lang });
+  return { id, kind: 'ratchet', rule: preset.text, removed: true };
 }
 
 /** Forget every recorded answer — the full set becomes pending again. */
-export function resetSeeds({ agent = 'claude' } = {}) {
+export async function resetSeeds({ agent = 'claude' } = {}) {
   const state = loadSeedState({ agent });
   const count = Object.keys(state.decided).length;
   saveSeedState({ decided: {} }, { agent });
+  // The preset file mirrors the answers, so forgetting them empties it.
+  const { syncPresetRatchet } = await import('./preset-ratchet.js');
+  syncPresetRatchet({ agent });
   return count;
 }