sprag-cli 3.55.0 → 3.57.0

package/src/ctx-window-cache.js

@@ -0,0 +1,61 @@
+/**
+ * The context window Claude Code reports for each session.
+ *
+ * Only the statusline payload carries it (`context_window.context_window_size`).
+ * The UserPromptSubmit hook gets a session id and a transcript path, so the
+ * briefing used to guess the window from the configured model id, and a model
+ * that is 1M without a `[1m]` suffix was judged against 200k: the 80% warning
+ * fired at 160k while the statusline of the same session said "Ctx 1M". The
+ * statusline records the size it was given here, and the briefing reads it back
+ * by session id before it falls back to guessing.
+ *
+ * State: <stateDir>/ctx-window.json
+ *   { sessions: { [session_id]: { size, ts } } }
+ * Entries untouched for 7 days are pruned on write.
+ */
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { userDataDir } from './paths.js';
+import { writeStateFile } from './state-file.js';
+
+const PRUNE_MS = 7 * 24 * 60 * 60 * 1000;
+// The statusline renders every few seconds. An unchanged size is rewritten only
+// this often, which is enough to keep a long session's entry from being pruned.
+const REFRESH_MS = 24 * 60 * 60 * 1000;
+
+export function ctxWindowCachePath() {
+  return join(userDataDir(), 'ctx-window.json');
+}
+
+function load() {
+  try {
+    const s = JSON.parse(readFileSync(ctxWindowCachePath(), 'utf8'));
+    return s && s.sessions && typeof s.sessions === 'object' && !Array.isArray(s.sessions) ? s : { sessions: {} };
+  } catch {
+    return { sessions: {} };
+  }
+}
+
+const validSize = (size) => Number.isFinite(size) && size > 0;
+
+/** Record the window the statusline payload reported. Returns true when the file was written. */
+export function recordLiveWindow(sessionId, size, now = Date.now()) {
+  if (typeof sessionId !== 'string' || sessionId === '' || !validSize(size)) return false;
+  const state = load();
+  const prev = state.sessions[sessionId];
+  if (prev && prev.size === size && now - prev.ts < REFRESH_MS) return false;
+  state.sessions[sessionId] = { size, ts: now };
+  for (const [id, s] of Object.entries(state.sessions)) {
+    if (!s || !Number.isFinite(s.ts) || now - s.ts > PRUNE_MS) delete state.sessions[id];
+  }
+  writeStateFile(ctxWindowCachePath(), JSON.stringify(state) + '\n');
+  return true;
+}
+
+/** The recorded window for a session, or null when the statusline never reported one. */
+export function liveWindowFor(sessionId) {
+  if (typeof sessionId !== 'string' || sessionId === '') return null;
+  const s = load().sessions[sessionId];
+  return s && validSize(s.size) ? s.size : null;
+}

package/src/delegation-guard.js

@@ -26,6 +26,7 @@ import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 import { loadConfig, saveConfig } from './config.js';
 import { recentToolPaths } from './session-paths.js';
+import { routeCapsFor } from './route-caps.js';
 
 const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
 
@@ -114,7 +115,7 @@ function ratchetImportMissing(home = homedir()) {
  * English-only prompt, an already-imported ratchet.md, or a session with
  * nothing read yet each drop their own section without blocking the others.
  */
-export async function buildAppendix(payload, { cfg = loadConfig(), home = homedir() } = {}) {
+export async function buildAppendix(payload, { cfg = loadConfig(), home = homedir(), routeCaps = routeCapsFor(payload?.session_id) } = {}) {
   const sections = [];
 
   // Read from `model` first — it is the more specific field when both are set
@@ -125,12 +126,17 @@ export async function buildAppendix(payload, { cfg = loadConfig(), home = homedi
 
   const bounds = boundsText();
   if (bounds) {
-    // Hardcoded per the user's model-fitting ratchet rule
-    // (~/.claude/ratchet-model.md): haiku delegations get a tighter leash
-    // (8 tool calls / 1,500 output tokens) than everything else (20 / 8,000).
-    const capLine = isHaiku
-      ? 'Cap for this delegation: 8 tool calls, 1,500 output tokens.'
-      : 'Cap for this delegation: 20 tool calls, 8,000 output tokens.';
+    // Haiku delegations get a tighter leash (8 tool calls / 1,500 output
+    // tokens) than everything else (20 / 8,000). Those are the defaults of the
+    // model-fitting rules. When this turn's prompt matched a rule, the rule's
+    // own calibrated budget for the tier replaces them, so the subagent is told
+    // the same limit the main model was (see route-caps.js). A T1 rule sets no
+    // call count, and the default one stays in that case.
+    const fallback = isHaiku ? { calls: 8, out: 1500 } : { calls: 20, out: 8000 };
+    const matched = routeCaps?.[isHaiku ? 'T2' : 'T1'];
+    const calls = Number.isFinite(matched?.calls) && matched.calls > 0 ? matched.calls : fallback.calls;
+    const out = Number.isFinite(matched?.out) && matched.out > 0 ? matched.out : fallback.out;
+    const capLine = `Cap for this delegation: ${calls} tool calls, ${out.toLocaleString('en-US')} output tokens.`;
     sections.push(['## Bounds and output shape', bounds, capLine].join('\n\n'));
   }
 
@@ -234,7 +240,7 @@ export async function buildAppendix(payload, { cfg = loadConfig(), home = homedi
  * call, so the caller's contract stays "print nothing, let the tool run
  * exactly as given" for every one of them.
  */
-export async function decideForDelegation(payload, { cfg = loadConfig(), home = homedir() } = {}) {
+export async function decideForDelegation(payload, { cfg = loadConfig(), home = homedir(), routeCaps = routeCapsFor(payload?.session_id) } = {}) {
   if (!delegateEnabled(cfg)) return null;
   if (payload?.tool_name !== 'Task' && payload?.tool_name !== 'Agent') return null;
 
@@ -246,7 +252,7 @@ export async function decideForDelegation(payload, { cfg = loadConfig(), home =
   // same tool_name, must not stack the appendix onto itself.
   if (prompt.includes(DELEGATION_MARKER)) return null;
 
-  const appendix = await buildAppendix(payload, { cfg, home });
+  const appendix = await buildAppendix(payload, { cfg, home, routeCaps });
   if (!appendix) return null;
 
   return { updatedInput: { ...toolInput, prompt: `${prompt}\n\n${appendix}` } };

package/src/doc2md.cjs

@@ -307,13 +307,19 @@ function managedPython() {
     : path.join(dir, 'bin', 'python');
 }
 
-const MARKITDOWN_SPEC = 'markitdown[pptx,pdf,xlsx,docx]';
+// Each spec carries an upper bound at the next major line. An open spec takes
+// whatever is newest on the day someone first opens a document, so a breaking
+// release (or a bad one) would reach every new machine with nothing in this
+// repository having changed. The bounds are the lines verified here:
+// markitdown 0.1.7, python-pptx 1.0.2, python-docx 1.2.0, openpyxl 3.1.5.
+// pip gets them as plain argv, with no shell in between, so `<` is safe.
+const MARKITDOWN_SPEC = 'markitdown[pptx,pdf,xlsx,docx]>=0.1,<0.2';
 
 // Editing libraries, installed alongside the converter. Reading is doc2md's
 // own job; editing is the agent's, done per-request with a short script
 // against a COPY of the document. These are the libraries those scripts need,
 // pre-installed so "swap the chart on slide 23" does not stall on pip.
-const EDIT_LIBS = ['python-pptx', 'python-docx', 'openpyxl'];
+const EDIT_LIBS = ['python-pptx>=1.0,<2', 'python-docx>=1.1,<2', 'openpyxl>=3.1,<4'];
 
 /**
  * Build the managed venv and install markitdown into it.
@@ -999,15 +1005,22 @@ function decideForWrite(context, opts = {}) {
   return null;
 }
 
-/** The decision rendered as the JSON Claude Code expects on stdout. */
+/**
+ * The decision rendered as the JSON Claude Code expects on stdout.
+ *
+ * Only a refusal answers the permission question. A note about a document
+ * that could not be converted says nothing about whether the read should be
+ * allowed, and answering `allow` for it approved the call without the prompt
+ * the user would otherwise have seen, sensitive-pattern files included. The
+ * note goes out as context instead, which is also the only form that reaches
+ * the model: an `allow` reason is shown to the user alone.
+ */
 function formatHookOutput(decision) {
   if (!decision) return null;
   return JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: 'PreToolUse',
-      permissionDecision: decision.deny ? 'deny' : 'allow',
-      permissionDecisionReason: decision.reason,
-    },
+    hookSpecificOutput: decision.deny
+      ? { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: decision.reason }
+      : { hookEventName: 'PreToolUse', additionalContext: decision.reason },
   });
 }
 
@@ -1016,6 +1029,7 @@ module.exports = {
   MAX_SOURCE_BYTES,
   INSTALL_HINT,
   MARKITDOWN_SPEC,
+  EDIT_LIBS,
   managedPython,
   installConverter,
   ensureConverterInstalled,

package/src/fig2md.cjs

@@ -32,6 +32,11 @@ const { spawnSync } = require('node:child_process');
 // cmd.exe, where `^` is the escape character and would be eaten before npm
 // ever saw it. The range is the same one caret means for a 0.x package.
 const FIG_PARSER_SPEC = 'openfig-core@0.4.x';
+// `--ignore-scripts`: the parser and its three dependencies are plain
+// JavaScript and ship no install script, so nothing is lost, and a release of
+// any of them that adds one cannot run code on the machine of someone who only
+// opened a .fig file.
+const FIG_INSTALL_ARGS = ['install', '--no-audit', '--no-fund', '--silent', '--ignore-scripts', FIG_PARSER_SPEC];
 
 /** Where the on-demand parser install lives, under the tool's state dir. */
 function managedFigDir(userDataDir) {
@@ -63,7 +68,7 @@ function installFigParser(userDataDir, { onProgress = () => {} } = {}) {
   // needs the shell. Elsewhere the shell is avoided, since the package spec
   // would then go through shell quoting for no benefit.
   const isWindows = process.platform === 'win32';
-  const r = spawnSync(isWindows ? 'npm.cmd' : 'npm', ['install', '--no-audit', '--no-fund', '--silent', FIG_PARSER_SPEC], {
+  const r = spawnSync(isWindows ? 'npm.cmd' : 'npm', FIG_INSTALL_ARGS, {
     cwd: dir,
     encoding: 'utf8',
     timeout: 300_000,
@@ -184,6 +189,7 @@ async function convertFig(filePath, userDataDir) {
 
 module.exports = {
   FIG_PARSER_SPEC,
+  FIG_INSTALL_ARGS,
   managedFigDir,
   installFigParser,
   convertFig,

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".
@@ -298,9 +304,9 @@ function buildVersionSeg(version, update, c, isIcon, verbose, g) {
  * fallback line. Best-effort: never throws into the statusline (corrupted
  * CLAUDE.md, permission issue, etc. → null).
  */
-function buildHarnessSeg(c, isIcon, g) {
+function buildHarnessSeg(c, isIcon, g, liveWindow = null) {
   try {
-    const harnessInfo = harnessStatusForStatusline(loadConfig());
+    const harnessInfo = harnessStatusForStatusline(loadConfig(), { liveWindow });
     if (!harnessInfo) return null;
     const icon = isIcon ? g.harness : 'H';
     if (harnessInfo.warning) {
@@ -485,7 +491,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
 
   // Delegation savings — a DIFFERENT number from "Cache saved" above, which
   // covers the prompt cache only. This one is what running work on a cheaper
-  // tier saved, summed from the rule registry route-scan maintains. Hidden
+  // tier saved, the lifetime total of the delegation ledger. Hidden
   // when zero or absent: a permanent "$0" is noise for direct-API users and
   // for anyone who has not delegated yet.
   // "Routing saved" says what earned the money — work that ran on a cheaper
@@ -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}` : '');
   }
 
@@ -749,7 +760,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // Silent when the project hasn't opted in (no CLAUDE.md and no .claude/);
   // otherwise renders 🅷 5/5 (green) / 🅷 N/5 (yellow) so the user can spot
   // a missing section at a glance and know to run `harness init`.
-  const harnessSeg = buildHarnessSeg(c, isIcon, g);
+  const harnessSeg = buildHarnessSeg(c, isIcon, g, ctxLive?.size ?? null);
 
   // Version / upgrade chip. Read from a cache written by a detached background
   // check — this render path never touches the network.

package/src/formatters/table.js

@@ -14,8 +14,10 @@ const C = {
   yellow: '\x1b[33m',
   cyan:   '\x1b[36m',
 };
-// Wrap text with ANSI codes — gracefully strips to plain when NO_COLOR set.
-const colorOk = !process.env.NO_COLOR;
+// Wrap text with ANSI codes. Set per report by formatReport: the caller knows
+// about `--no-color` and whether stdout is a terminal, which this module cannot
+// see. NO_COLOR alone is the answer for a caller that passes nothing.
+let colorOk = !process.env.NO_COLOR;
 const r  = (s) => colorOk ? `${C.red}${s}${C.reset}` : s;
 const rb = (s) => colorOk ? `${C.bold}${C.red}${s}${C.reset}` : s;
 const rbl = (s) => colorOk ? `${C.blink}${C.bold}${C.red}${s}${C.reset}` : s;
@@ -28,6 +30,11 @@ function pad(str, len, align = 'left') {
   return s.padEnd(len);
 }
 
+// A loss reads as "-$3", not "$-3". The digits are left as cost.js rounded them.
+function usd(n) {
+  return n < 0 ? `-$${Math.abs(n)}` : `$${n}`;
+}
+
 function pct(n) {
   return (n * 100).toFixed(1) + '%';
 }
@@ -93,7 +100,7 @@ function renderSpikeSection(spikes, contextWindow) {
   }
   for (const spike of spikes) {
     const m = spike.metrics;
-    const ratioLabel = spike.ratio ? `${spike.ratio.toFixed(1)}× p95` : 'single-request > 250k';
+    const ratioLabel = spike.ratio && spike.byRatio !== false ? `${spike.ratio.toFixed(1)}× p95` : 'single-request > 250k';
     lines.push(
       r(`  • ${shortSessionId(m.sessionId)} [${m.projectDir || 'unknown'}]  `) +
         rb(`total input ${formatContextSize(m.totalInput)}`) +
@@ -140,7 +147,7 @@ function renderSpikeSection(spikes, contextWindow) {
       lines.push('');
     }
   }
-  lines.push(rbl('  ▶ 상세 처치법: ') + rb(`${CLI_NAME} last`));
+  lines.push(rbl('  ▶ How to handle it: ') + rb(`${CLI_NAME} last`));
   lines.push('');
   return lines;
 }
@@ -169,12 +176,13 @@ function renderCapWarnSection(caps) {
   lines.push(rb(`    ${CLI_NAME} handoff`));
   lines.push(r('  (writes a HANDOFF-*.md so a fresh session can pick up.)'));
   lines.push('');
-  lines.push(rbl('  ▶ 상세 처치법: ') + rb(`${CLI_NAME} last`));
+  lines.push(rbl('  ▶ How to handle it: ') + rb(`${CLI_NAME} last`));
   lines.push('');
   return lines;
 }
 
-export function formatReport({ summary: sum, trend, ttl, anomalies, cost, options, spikeReport, contextWindow, caps }) {
+export function formatReport({ summary: sum, trend, ttl, anomalies, cost, options, spikeReport, contextWindow, caps }, { color } = {}) {
+  colorOk = color ?? !process.env.NO_COLOR;
   const lines = [];
 
   // Header
@@ -240,19 +248,20 @@ export function formatReport({ summary: sum, trend, ttl, anomalies, cost, option
   const costW = [24, 12];
   const costA = ['left', 'right'];
   lines.push('  ' + tableTop(costW));
-  lines.push('  ' + tableRow(['Actual cost', `$${cost.actual}`], costW, costA));
-  lines.push('  ' + tableRow(['Without cache', `$${cost.noCacheCost}`], costW, costA));
+  lines.push('  ' + tableRow(['Actual cost', usd(cost.actual)], costW, costA));
+  lines.push('  ' + tableRow(['Without cache', usd(cost.noCacheCost)], costW, costA));
   lines.push('  ' + tableSep(costW));
-  lines.push('  ' + tableRow(['Savings', `$${cost.savings} (${pct(cost.savingsRate)})`], costW, costA));
+  lines.push('  ' + tableRow(['Savings', `${usd(cost.savings)} (${pct(cost.savingsRate)})`], costW, costA));
   // Only worth asking of someone who has 1h writes to lose. Everyone else got
   // a `+$0` that read as an endorsement of the 5m bucket they were already
   // stuck in.
   if (cost.extraCostIf5mApplicable === false) {
     lines.push('  ' + tableRow(['Already 5m-only', ttl.gatewayObserved ? 'gateway' : 'yes'], costW, costA));
   } else {
-    lines.push('  ' + tableRow(['Extra cost if 5m-only', `+$${cost.extraCostIf5m}`], costW, costA));
+    lines.push('  ' + tableRow(['Extra cost if 5m-only', cost.extraCostIf5m < 0 ? usd(cost.extraCostIf5m) : `+${usd(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-auth.js

@@ -21,7 +21,7 @@
 
 import { readFileSync } from 'node:fs';
 import { execSync } from 'node:child_process';
-import { join } from 'node:path';
+import { join, resolve, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { debug } from './debug.js';
 
@@ -40,6 +40,29 @@ export function gatewayBase(env = process.env) {
   return base;
 }
 
+/**
+ * Claude Code 가 신뢰 확인을 받아 둔 폴더인지 판정합니다. 기록은
+ * ~/.claude.json 의 projects[<절대 경로>].hasTrustDialogAccepted 에 있고, 상위
+ * 폴더를 신뢰했으면 하위 폴더에도 적용됩니다. 기록을 읽지 못하면 신뢰하지 않은
+ * 것으로 봅니다.
+ */
+export function isTrustedProject(cwd = process.cwd(), { home = homedir() } = {}) {
+  let projects;
+  try {
+    projects = JSON.parse(readFileSync(join(home, '.claude.json'), 'utf8'))?.projects;
+  } catch {
+    return false;
+  }
+  if (!projects || typeof projects !== 'object') return false;
+  let dir = resolve(cwd);
+  for (;;) {
+    if (projects[dir]?.hasTrustDialogAccepted === true) return true;
+    const parent = dirname(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
+
 /**
  * Claude Code 와 같은 방식으로 apiKeyHelper 를 실행해 토큰을 얻습니다.
  * 환경변수에 토큰을 두지 않고 헬퍼 스크립트로 매번 발급받는 구성이 공식 인증
@@ -50,9 +73,14 @@ export function gatewayBase(env = process.env) {
  * 부릅니다. 수 초 간격으로 도는 렌더 경로에서 부르면 통계선이 그만큼 느려집니다.
  */
 export function keyFromApiKeyHelper(cwd = process.cwd()) {
+  // 프로젝트 설정의 헬퍼는 그 저장소가 넣어 둔 셸 명령입니다. Claude Code 는 신뢰
+  // 확인을 거친 폴더에서만 그것을 실행하므로, 같은 기록을 보고 같은 조건으로만
+  // 실행합니다. 그러지 않으면 내려받은 저장소 안에서 이 CLI 를 돌리는 것만으로
+  // 그 저장소의 명령이 실행됩니다.
   const candidates = [
-    join(cwd, '.claude', 'settings.local.json'),
-    join(cwd, '.claude', 'settings.json'),
+    ...(isTrustedProject(cwd)
+      ? [join(cwd, '.claude', 'settings.local.json'), join(cwd, '.claude', 'settings.json')]
+      : []),
     join(homedir(), '.claude', 'settings.json'),
   ];
   for (const p of candidates) {

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

@@ -214,16 +214,38 @@ export function harnessInit({ root = findProjectRoot(), force = false, scope = '
   const block = harnessClaudeMdBlock(scope);
   if (existsSync(cmPath)) {
     const existing = readFileSync(cmPath, 'utf8');
-    if (existing.includes(HARNESS_BLOCK_BEGIN) && !force) {
+    const hasBegin = existing.includes(HARNESS_BLOCK_BEGIN);
+    const blockRe = new RegExp(
+      `${escapeRe(HARNESS_BLOCK_BEGIN)}[\\s\\S]*?${escapeRe(HARNESS_BLOCK_END)}\\n?`,
+      'm',
+    );
+    const hasCompleteBlock = blockRe.test(existing);
+    if (hasBegin && !hasCompleteBlock) {
+      // A begin marker with no end marker after it: the extent of our block is
+      // unknowable, so replacing or appending would either eat the user's text
+      // or leave a second block beside the broken one. Touch nothing.
+      result.skipped.push(`${cmPath} (harness block has a begin marker but no end marker — fix it manually)`);
+      result.brokenBlock = true;
+    } else if (hasCompleteBlock) {
       // Already has a harness block — replace it in-place, preserving the
-      // user's other content above/below.
-      const re = new RegExp(
-        `${escapeRe(HARNESS_BLOCK_BEGIN)}[\\s\\S]*?${escapeRe(HARNESS_BLOCK_END)}\\n?`,
-        'm',
-      );
-      const next = existing.replace(re, block);
-      writeFileSync(cmPath, next);
-      result.wrote.push(cmPath + ' (block updated in place)');
+      // user's other content above/below. This holds with or without --force:
+      // --force used to fall through to the append branch, which added a second
+      // block on every run.
+      // A replacer function, not the string: `$&` or `$1` in a block would be
+      // read as a replacement pattern.
+      const next = existing.replace(blockRe, () => block);
+      if (next === existing) {
+        result.skipped.push(`${cmPath} (harness block already up to date)`);
+      } else {
+        if (force) {
+          const stamp = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
+          const bak = `${cmPath}.bak-${stamp}`;
+          writeFileSync(bak, existing);
+          result.backedUp.push(bak);
+        }
+        writeFileSync(cmPath, next);
+        result.wrote.push(cmPath + ' (block updated in place)');
+      }
     } else {
       // Backup as safety net, then APPEND the harness block to existing
       // content (do not clobber). Users keep all their prior CLAUDE.md content;
@@ -295,7 +317,16 @@ export function harnessUninit({ root = findProjectRoot(), purgeRatchet = false,
 
   if (existsSync(cmPath)) {
     const existing = readFileSync(cmPath, 'utf8');
-    if (existing.includes(HARNESS_BLOCK_BEGIN)) {
+    const beginIdx = existing.indexOf(HARNESS_BLOCK_BEGIN);
+    const uninitRe = new RegExp(
+      `\\n*${escapeRe(HARNESS_BLOCK_BEGIN)}[\\s\\S]*?${escapeRe(HARNESS_BLOCK_END)}\\n?`,
+      'm',
+    );
+    if (beginIdx !== -1 && !uninitRe.test(existing)) {
+      // Begin marker without an end marker: nothing to cut safely, and writing
+      // the file back unchanged would still report a removal.
+      result.skipped.push(`${cmPath} (harness block has a begin marker but no end marker — fix it manually)`);
+    } else if (beginIdx !== -1) {
       const stamp = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
       const bak = `${cmPath}.bak-${stamp}`;
       writeFileSync(bak, existing);
@@ -575,7 +606,7 @@ export function harnessRmRule(n, { root = findProjectRoot(), scope = 'project',
  * has explicitly disabled harness display, or when there's no CLAUDE.md and
  * no .claude/ at all (silent in non-init'd projects so we don't nag).
  */
-export function harnessStatusForStatusline(cfg, { root } = {}) {
+export function harnessStatusForStatusline(cfg, { root, liveWindow = null } = {}) {
   if (cfg && cfg.harness && cfg.harness.enabled === false) return null;
   const projectRoot = root || findProjectRoot();
   const status = harnessStatus(projectRoot);
@@ -620,7 +651,7 @@ export function harnessStatusForStatusline(cfg, { root } = {}) {
   // exempt — the setting cannot change anything for them.
   if (!warning) {
     try {
-      warning = compactWindowWarningForStatusline(projectRoot, cfg);
+      warning = compactWindowWarningForStatusline(projectRoot, cfg, { liveWindow });
     } catch { /* settings unreadable — stay silent */ }
   }
   // Below session-quality warnings: a promoted delegation rule whose

package/src/history.js

@@ -50,7 +50,8 @@ function hms(d = new Date()) {
 
 function loadState() {
   try {
-    return JSON.parse(readFileSync(STATE_PATH, 'utf8'));
+    const s = JSON.parse(readFileSync(STATE_PATH, 'utf8'));
+    return s && typeof s === 'object' && !Array.isArray(s) ? s : { chip: null, ts: null };
   } catch {
     return { chip: null, ts: null };
   }
@@ -218,7 +219,10 @@ export function recordChip(chip, contextHints = {}) {
     ko = `✓ 해소됨 (이전: ${chipKo(last)})`;
   }
   appendDayLine(en, ko, now, tips);
-  saveState({ chip: current, ts: now.toISOString() });
+  // The state file also holds one `cap_<window>` slot per rate-limit window
+  // (recordCapTransition). Saving the chip alone wiped them, so the next render
+  // saw a window at 90% as newly crossed and logged the cap warning again.
+  saveState({ ...state, chip: current, ts: now.toISOString() });
   return true;
 }