claude-token-saver 3.25.0 → 3.26.0

package/src/doc2md.cjs

@@ -0,0 +1,378 @@
+/**
+ * doc2md — hand the model a Markdown rendering of an attached document
+ * instead of the binary.
+ *
+ * A pptx or xlsx read straight into the context window is close to the worst
+ * thing a token-saving tool can allow: the bytes are unreadable to the model,
+ * so it either gets nothing useful or spends a fortune finding that out. This
+ * intercepts the Read, converts the file once, caches the result, and points
+ * the model at the .md.
+ *
+ * CommonJS on purpose. It runs from ~/.claude/ through the copied hook script,
+ * where there is no package.json to declare `"type": "module"`, which is the
+ * same reason korean-lint.cjs is written this way.
+ *
+ * Conversion is markitdown, a Python package. It cannot be an npm dependency,
+ * so a missing install is an ordinary state rather than an error: say so once,
+ * then get out of the way and let the Read proceed untouched. Failing loudly
+ * on every Read would be worse than the problem being solved, and failing
+ * silently is how graphify's `except ImportError: return ""` hid a broken
+ * converter for months.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+
+// Formats where the original is of no use to the model. Images are absent
+// deliberately: markitdown returns nothing for them, and OCR misread resource
+// names in testing (`c5.xlarge` as `c.xlarge`), which is worse than no text at
+// all in a document where those names are the content. The model reads images
+// natively anyway.
+const TARGET_EXTENSIONS = ['.pptx', '.xlsx', '.xls', '.pdf', '.docx'];
+
+// Big enough for real decks and reports, small enough that a hostile file
+// cannot make the converter the expensive part of the turn.
+const MAX_SOURCE_BYTES = 50 * 1024 * 1024;
+// A conversion larger than this costs more to read than it saves.
+const MAX_MARKDOWN_BYTES = 2 * 1024 * 1024;
+// Cold `import markitdown` measured at ~12s; conversions after that are under
+// two seconds except for very large workbooks, which the row cap handles.
+const CONVERT_TIMEOUT_MS = 120_000;
+
+// Names that suggest the file should not be left lying around as plain text.
+// Deliberately blunt: the cost of skipping a payroll deck is one extra manual
+// step, and the cost of caching it is not recoverable.
+const SENSITIVE_PATTERNS = [
+  /secret/i, /password/i, /credential/i, /salary/i, /payroll/i, /confidential/i,
+  /개인정보/, /급여/, /계약/, /대외비/,
+];
+
+// Mirrors src/paths.js userDataDir(). Duplicated rather than imported because
+// this file is CommonJS and paths.js is ESM; the precedence order has to match
+// it exactly, or conversions would land somewhere the rest of the tool does
+// not look.
+function userDataDir() {
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, 'claude-token-saver');
+  }
+  if (process.platform === 'win32' && process.env.APPDATA) {
+    return path.join(process.env.APPDATA, 'claude-token-saver');
+  }
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'claude-token-saver');
+  }
+  return path.join(os.homedir(), '.config', 'claude-token-saver');
+}
+
+/**
+ * Where conversions live.
+ *
+ * Not next to the original, and not in the project's own `.claude/`: either
+ * one drops a plain-text copy of a possibly confidential attachment into a
+ * directory people commit. Keeping it in the tool's own state directory means
+ * there is nothing for the user to remember to gitignore.
+ */
+function cacheDir() {
+  return path.join(userDataDir(), 'doc2md-cache');
+}
+
+function ensureCacheDir() {
+  const dir = cacheDir();
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  // mkdir honours the mode only on creation, so an older directory made with
+  // the default mask is tightened here.
+  try { fs.chmodSync(dir, 0o700); } catch { /* best effort */ }
+  return dir;
+}
+
+function isTargetPath(filePath) {
+  if (typeof filePath !== 'string' || !filePath) return false;
+  return TARGET_EXTENSIONS.includes(path.extname(filePath).toLowerCase());
+}
+
+function isSensitivePath(filePath) {
+  const base = path.basename(filePath || '');
+  return SENSITIVE_PATTERNS.some((re) => re.test(base));
+}
+
+/**
+ * Cache path for a source file. The hash covers the absolute path, so two
+ * `report.pptx` files in different projects do not overwrite each other.
+ */
+function cachePathFor(filePath) {
+  const abs = path.resolve(filePath);
+  const hash = crypto.createHash('sha256').update(abs).digest('hex').slice(0, 12);
+  const base = path.basename(abs).replace(/[^\w.\-]/g, '_');
+  return path.join(cacheDir(), `${base}.${hash}.md`);
+}
+
+function metaPathFor(cacheFile) {
+  return cacheFile.replace(/\.md$/, '.meta.json');
+}
+
+/** A cached conversion still matching the source's mtime and size, or null. */
+function readCache(filePath) {
+  const cacheFile = cachePathFor(filePath);
+  try {
+    const src = fs.statSync(filePath);
+    const meta = JSON.parse(fs.readFileSync(metaPathFor(cacheFile), 'utf8'));
+    if (meta.size !== src.size || meta.mtimeMs !== src.mtimeMs) return null;
+    fs.statSync(cacheFile);
+    return { cacheFile, meta };
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(filePath, markdown, extra) {
+  ensureCacheDir();
+  const cacheFile = cachePathFor(filePath);
+  const src = fs.statSync(filePath);
+  fs.writeFileSync(cacheFile, markdown, { encoding: 'utf8', mode: 0o600 });
+  const meta = Object.assign({
+    source: path.resolve(filePath),
+    size: src.size,
+    mtimeMs: src.mtimeMs,
+    convertedAt: new Date().toISOString(),
+  }, extra || {});
+  fs.writeFileSync(metaPathFor(cacheFile), JSON.stringify(meta, null, 2), { encoding: 'utf8', mode: 0o600 });
+  return { cacheFile, meta };
+}
+
+/**
+ * A Python that can import markitdown, or null.
+ *
+ * Order matters: an explicit override first, then a `uv tool` install, then
+ * whatever is on PATH. Probing costs a process spawn each, so the answer is
+ * memoized for the life of this process, and the caller memoizes across
+ * processes through the notice file.
+ */
+let interpreterCache;
+function findInterpreter() {
+  if (interpreterCache !== undefined) return interpreterCache;
+  const candidates = [];
+  if (process.env.CTS_DOC2MD_PYTHON) candidates.push(process.env.CTS_DOC2MD_PYTHON);
+  candidates.push(
+    path.join(os.homedir(), '.local', 'share', 'uv', 'tools', 'markitdown', 'bin', 'python'),
+    path.join(os.homedir(), '.local', 'bin', 'markitdown-python'),
+    'python3',
+    'python',
+  );
+  for (const bin of candidates) {
+    try {
+      const probe = spawnSync(bin, ['-c', 'import markitdown'], { timeout: 20_000, stdio: 'ignore' });
+      if (probe.status === 0) {
+        interpreterCache = bin;
+        return bin;
+      }
+    } catch { /* candidate unusable, try the next */ }
+  }
+  interpreterCache = null;
+  return null;
+}
+
+const CONVERTER = path.join(__dirname, '..', 'presets', 'doc2md', 'convert.py');
+
+/**
+ * Convert one file. Returns `{ ok: true, cacheFile, meta }`, or
+ * `{ ok: false, reason, detail }` where reason is one of:
+ *   no-markitdown | too-large | sensitive | unsafe-archive | no-text |
+ *   convert-failed | timeout
+ *
+ * Every failure is a reason to leave the original Read alone, never to break
+ * it. That is the whole contract with the hook.
+ */
+function convert(filePath, { converter = CONVERTER, python: pythonOverride = null } = {}) {
+  if (!isTargetPath(filePath)) return { ok: false, reason: 'not-target' };
+  if (isSensitivePath(filePath)) return { ok: false, reason: 'sensitive' };
+
+  let stat;
+  try {
+    stat = fs.statSync(filePath);
+  } catch (e) {
+    return { ok: false, reason: 'missing', detail: String(e.message || e) };
+  }
+  if (stat.size > MAX_SOURCE_BYTES) {
+    return { ok: false, reason: 'too-large', detail: `${stat.size} bytes` };
+  }
+
+  const cached = readCache(filePath);
+  if (cached) return { ok: true, cached: true, cacheFile: cached.cacheFile, meta: cached.meta };
+
+  // The override exists so tests can drive a stub converter with any Python at
+  // all: the normal search insists the interpreter can import markitdown,
+  // which would make the whole path untestable without the real package.
+  const python = pythonOverride || findInterpreter();
+  if (!python) return { ok: false, reason: 'no-markitdown' };
+
+  const run = spawnSync(python, [converter, filePath], {
+    encoding: 'utf8',
+    timeout: CONVERT_TIMEOUT_MS,
+    maxBuffer: MAX_MARKDOWN_BYTES * 4,
+  });
+  if (run.error && run.error.code === 'ETIMEDOUT') return { ok: false, reason: 'timeout' };
+  if (run.status !== 0) {
+    return { ok: false, reason: 'convert-failed', detail: (run.stderr || '').slice(0, 300) };
+  }
+
+  let payload;
+  try {
+    payload = JSON.parse(run.stdout);
+  } catch {
+    return { ok: false, reason: 'convert-failed', detail: 'converter produced no JSON' };
+  }
+  if (!payload.ok) return { ok: false, reason: payload.reason, detail: payload.detail };
+
+  let markdown = payload.markdown || '';
+  let clipped = false;
+  if (Buffer.byteLength(markdown, 'utf8') > MAX_MARKDOWN_BYTES) {
+    // Reading a 20MB markdown file is the same waste in a different format.
+    markdown = markdown.slice(0, MAX_MARKDOWN_BYTES);
+    clipped = true;
+  }
+
+  const written = writeCache(filePath, markdown, {
+    note: payload.note || null,
+    truncated: !!payload.truncated || clipped,
+    rows: payload.rows || 0,
+    clipped,
+  });
+  return { ok: true, cached: false, cacheFile: written.cacheFile, meta: written.meta };
+}
+
+/** Where the "markitdown is not installed" notice records that it was shown. */
+function noticePath() {
+  return path.join(userDataDir(), 'doc2md-notice.json');
+}
+
+function noticeAlreadyShown() {
+  try {
+    return JSON.parse(fs.readFileSync(noticePath(), 'utf8')).shown === true;
+  } catch {
+    return false;
+  }
+}
+
+function markNoticeShown() {
+  try {
+    fs.mkdirSync(userDataDir(), { recursive: true });
+    fs.writeFileSync(noticePath(), JSON.stringify({ shown: true, at: new Date().toISOString() }));
+  } catch { /* an unwritable state dir just means the notice repeats */ }
+}
+
+const INSTALL_HINT = 'pip install "markitdown[pptx,pdf,xlsx,docx]"';
+
+/**
+ * Decide what to tell Claude Code about one PreToolUse(Read) payload.
+ *
+ * Returns null when the hook should stay out of the way, or a PreToolUse hook
+ * output object. Blocking is the right call for a successful conversion:
+ * allowing the Read and merely mentioning the .md would put the binary in the
+ * context window anyway, which is the cost this exists to avoid.
+ */
+function decideForRead(context, opts = {}) {
+  if (!context || context.tool_name !== 'Read') return null;
+  const toolInput = context.tool_input;
+  const filePath = toolInput && typeof toolInput.file_path === 'string' ? toolInput.file_path : '';
+  if (!isTargetPath(filePath)) return null;
+
+  const result = convert(filePath, opts);
+  const name = path.basename(filePath);
+
+  if (result.ok) {
+    const bits = [`[doc2md] ${name} 는 Markdown 으로 변환했습니다.`];
+    bits.push(`  변환본: ${result.cacheFile}`);
+    if (result.meta && result.meta.note) bits.push(`  ${result.meta.note}`);
+    if (result.meta && result.meta.clipped) {
+      bits.push('  변환 결과가 너무 커서 뒷부분을 잘랐습니다. 전체가 필요하면 원본을 직접 다루십시오.');
+    }
+    bits.push('  원본 대신 이 파일을 Read 하십시오. 원본을 직접 확인해야 한다면 그 이유를 밝히십시오.');
+    return { deny: true, reason: bits.join('\n') };
+  }
+
+  // From here down the Read is allowed through untouched. The only question is
+  // whether the model is told why nothing was converted.
+  if (result.reason === 'no-markitdown') {
+    if (noticeAlreadyShown()) return null;
+    markNoticeShown();
+    return {
+      deny: false,
+      reason: `[doc2md] ${name} 를 변환하려 했으나 markitdown 이 설치되어 있지 않습니다.\n`
+        + `  설치: ${INSTALL_HINT}\n`
+        + '  설치 전까지는 원본을 그대로 읽습니다. 이 안내는 한 번만 표시됩니다.',
+    };
+  }
+  if (result.reason === 'no-text') {
+    return {
+      deny: false,
+      reason: `[doc2md] ${name} 에서 본문 텍스트를 추출하지 못했습니다(스캔 PDF 로 보입니다). 원본을 직접 확인하십시오.`,
+    };
+  }
+  // The one case that blocks without converting. A file that expands to fill
+  // the disk is not something to hand on to the next reader with a shrug.
+  if (result.reason === 'unsafe-archive') {
+    return {
+      deny: true,
+      reason: `[doc2md] ${name} 는 압축 폭탄으로 보여 변환하지 않았습니다 (${result.detail}). 신뢰할 수 있는 파일인지 먼저 확인하십시오.`,
+    };
+  }
+  if (result.reason === 'bad-archive') {
+    return {
+      deny: false,
+      reason: `[doc2md] ${name} 는 압축 파일로 열리지 않습니다 (${result.detail}). 내려받다 끊겼을 수 있습니다.`,
+    };
+  }
+  if (result.reason === 'too-large') {
+    return {
+      deny: false,
+      reason: `[doc2md] ${name} 는 크기 상한(50MB)을 넘어 변환하지 않았습니다 (${result.detail}).`,
+    };
+  }
+  if (result.reason === 'sensitive') {
+    return {
+      deny: false,
+      reason: `[doc2md] ${name} 는 파일명이 민감 문서 패턴에 걸려 변환하지 않았습니다. 평문 사본을 남기지 않기 위한 조치입니다.`,
+    };
+  }
+  if (result.reason === 'timeout' || result.reason === 'convert-failed') {
+    return {
+      deny: false,
+      reason: `[doc2md] ${name} 변환에 실패했습니다(${result.reason}). 원본을 그대로 읽습니다.`,
+    };
+  }
+  return null;
+}
+
+/** The decision rendered as the JSON Claude Code expects on stdout. */
+function formatHookOutput(decision) {
+  if (!decision) return null;
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: decision.deny ? 'deny' : 'allow',
+      permissionDecisionReason: decision.reason,
+    },
+  });
+}
+
+module.exports = {
+  TARGET_EXTENSIONS,
+  MAX_SOURCE_BYTES,
+  INSTALL_HINT,
+  cacheDir,
+  cachePathFor,
+  metaPathFor,
+  isTargetPath,
+  isSensitivePath,
+  findInterpreter,
+  readCache,
+  writeCache,
+  convert,
+  decideForRead,
+  formatHookOutput,
+};

package/src/formatters/statusline.js

@@ -280,10 +280,27 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // infer the bucket. Default to 1h-sized countdown rather than 5m so Max
   // users on idle don't see a misleading "Cache expires 5:00". The bucket
   // label is shown as "?" so the uncertainty is visible.
+  //
+  // That default is exactly backwards behind a gateway. Bedrock and Vertex
+  // never report the per-bucket split, so ttl.total stays 0 there forever, and
+  // they offer only the 5m bucket: the countdown opened at 59:59 for a window
+  // that was really 5:00, overstating it twelvefold. So the fallback now
+  // follows the evidence — gateway seen, assume 5m; otherwise keep 1h. An
+  // explicit `ttlBucket` setting outranks both, so a gateway that starts
+  // reporting the split correctly does not need a release to be believed.
   const hasTtlData = ttl.total > 0;
-  const is1h = hasTtlData ? ttl.pct1h >= 0.5 : true;
-  const bucketLabel = hasTtlData ? (is1h ? '1h' : '5m') : '?';
-  const bucketColor = hasTtlData ? (is1h ? GREEN : YELLOW) : GRAY;
+  const override = data.ttlBucket === '5m' || data.ttlBucket === '1h' ? data.ttlBucket : null;
+  const is1h = override ? override === '1h' : (hasTtlData ? ttl.pct1h >= 0.5 : !ttl.gatewayObserved);
+  // Three grades of certainty, three labels: measured (`1h`/`5m`), inferred
+  // from a gateway model id (`5m?`), and unknown (`?`). Folding the middle
+  // case into `?` would hide a judgement the user could otherwise check.
+  const bucketKnown = hasTtlData || !!override;
+  const bucketLabel = bucketKnown
+    ? (is1h ? '1h' : '5m')
+    : (ttl.gatewayObserved ? '5m?' : '?');
+  const bucketColor = bucketKnown
+    ? (is1h ? GREEN : YELLOW)
+    : (ttl.gatewayObserved ? YELLOW : GRAY);
   const ttlSeconds = is1h ? 3600 : 300;
 
   const savings = cost?.savings ?? 0;
@@ -320,9 +337,18 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   const delegateLabel = isIcon
     ? (verbose ? '🔀 Routing saved' : '🔀')
     : 'Routing saved';
+  // Zero savings has two very different causes and, until now, one appearance:
+  // nothing at all. "Never delegated" and "delegated plenty, but every run was
+  // dropped because the gateway model id could not be resolved" looked
+  // identical, so users in the second case had no reason to suspect anything
+  // was wrong. The count gets a chip; the explanation stays in `route-scan
+  // rules`, where there is room for it.
+  const unresolvedRuns = Number(data.unresolvedRuns) || 0;
   const delegateSeg = delegationSaved > 0
     ? `${c(GREEN)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}`
-    : null;
+    : (unresolvedRuns > 0
+      ? `${c(YELLOW)}🔀 ${unresolvedRuns} unresolved${c(RESET)}`
+      : null);
 
   // Routing-savings headline line (multi-line layout). The lifetime sum from
   // the delegation ledger — the number the whole tool exists to grow, so it
@@ -397,11 +423,15 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     const remaining = Math.min(ttlSeconds, ttlSeconds - elapsed);
     const text = formatTimer(remaining);
     const pct = remaining / ttlSeconds;
+    // Percentages are the wrong unit in a 5-minute bucket: 30% of it is 90
+    // seconds, and green there reads as comfort the user does not have. Below
+    // an hour the thresholds are absolute, so the color tracks whether there
+    // is time to finish a thought rather than a share of a short window.
     const timerColor =
       remaining <= 0 ? RED :
-      pct > 0.30 ? GREEN :
-      pct > 0.10 ? YELLOW :
-      RED;
+      is1h
+        ? (pct > 0.30 ? GREEN : pct > 0.10 ? YELLOW : RED)
+        : (remaining > 60 ? GREEN : remaining > 30 ? YELLOW : RED);
 
     if (isIcon && verbose) {
       // Drop bucket here too — `⏳ Expires 1h 57:20` reads as "1h 57m 20s left"

package/src/formatters/table.js

@@ -241,7 +241,14 @@ export function formatReport({ summary: sum, trend, ttl, anomalies, cost, option
   lines.push('  ' + tableRow(['Without cache', `$${cost.noCacheCost}`], costW, costA));
   lines.push('  ' + tableSep(costW));
   lines.push('  ' + tableRow(['Savings', `$${cost.savings} (${pct(cost.savingsRate)})`], costW, costA));
-  lines.push('  ' + tableRow(['Extra cost if 5m-only', `+$${cost.extraCostIf5m}`], 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('  ' + tableBot(costW));
   lines.push('');
 

package/src/installer.js

@@ -346,6 +346,75 @@ export function removeKoreanLintHook() {
   return { path: file, action: 'removed' };
 }
 
+// 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
+// the tokens are already spent.
+//
+// No `timeout` is set, on purpose. Claude Code defaults command hooks to ten
+// minutes, so naming a number here could only lower that ceiling, and a cold
+// `import markitdown` measured at twelve seconds by itself, with a very large
+// workbook adding a minute on top. The row cap inside the converter is what
+// actually bounds the work; the timeout is only a backstop.
+// Installed by `doc2md on`, removed by `doc2md off`. Idempotent.
+const DOC2MD_HOOK_COMMAND = 'claude-token-saver doc2md --hook';
+
+export function installDoc2mdHook() {
+  const dir = claudeUserDir();
+  const file = join(dir, 'settings.json');
+  mkdirSync(dir, { recursive: true });
+
+  let settings = {};
+  if (existsSync(file)) {
+    try {
+      settings = JSON.parse(readFileSync(file, 'utf8'));
+    } catch (e) {
+      return { path: file, action: 'skipped', reason: `unreadable JSON (${e.message})` };
+    }
+  }
+
+  settings.hooks = settings.hooks || {};
+  if (settings.hooks.PreToolUse !== undefined && !Array.isArray(settings.hooks.PreToolUse)) {
+    return { path: file, action: 'skipped', reason: 'hooks.PreToolUse is not an array — fix settings.json manually' };
+  }
+  const list = Array.isArray(settings.hooks.PreToolUse) ? settings.hooks.PreToolUse : [];
+  const already = list.some((m) =>
+    Array.isArray(m?.hooks) && m.hooks.some((h) => typeof h?.command === 'string' && h.command.includes('doc2md --hook')),
+  );
+  if (already) return { path: file, action: 'exists' };
+
+  list.push({
+    matcher: 'Read',
+    hooks: [{ type: 'command', command: DOC2MD_HOOK_COMMAND }],
+  });
+  settings.hooks.PreToolUse = list;
+  writeFileSync(file, JSON.stringify(settings, null, 2) + '\n');
+  return { path: file, action: 'created' };
+}
+
+export function removeDoc2mdHook() {
+  const file = join(claudeUserDir(), 'settings.json');
+  if (!existsSync(file)) return { path: file, action: 'absent' };
+  let settings;
+  try {
+    settings = JSON.parse(readFileSync(file, 'utf8'));
+  } catch (e) {
+    return { path: file, action: 'skipped', reason: `unreadable JSON (${e.message})` };
+  }
+  const list = settings?.hooks?.PreToolUse;
+  if (!Array.isArray(list)) return { path: file, action: 'absent' };
+  // Only this tool's own entry goes; anything else registered under
+  // PreToolUse stays exactly where the user put it.
+  const kept = list.filter((m) =>
+    !(Array.isArray(m?.hooks) && m.hooks.some((h) => typeof h?.command === 'string' && h.command.includes('doc2md --hook'))),
+  );
+  if (kept.length === list.length) return { path: file, action: 'absent' };
+  if (kept.length === 0) delete settings.hooks.PreToolUse;
+  else settings.hooks.PreToolUse = kept;
+  writeFileSync(file, JSON.stringify(settings, null, 2) + '\n');
+  return { path: file, action: 'removed' };
+}
+
 export function installAll({ force = false } = {}) {
   return {
     skill: installSkill({ force }),

package/src/korean-style.js

@@ -35,7 +35,10 @@ const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
 
 export const KOREAN_STYLE_PATH = join(packageRoot, 'presets', 'korean-style', 'fluent-korean.md');
 export const KOREAN_STYLE_LICENSE_PATH = join(packageRoot, 'presets', 'korean-style', 'LICENSE-fluent-korean');
-export const KOREAN_STYLE_SOURCE = 'fluent-korean by snflkd (MIT) — https://github.com/snflkd/fluent-korean';
+// The separator here is a colon, not an em dash. The guidance this line cites
+// bans em dashes in Korean prose, and shipping one inside its own attribution
+// is the kind of contradiction that teaches the model the rule is negotiable.
+export const KOREAN_STYLE_SOURCE = 'fluent-korean by snflkd (MIT): https://github.com/snflkd/fluent-korean';
 
 /** Whether session-start injection is enabled. Off unless the user asked. */
 export function koreanStyleEnabled(cfg = loadConfig()) {
@@ -134,6 +137,13 @@ export function koreanScopeLines(cfg = loadConfig()) {
   return [
     '적용 대상: 대화 답변, 그리고 세션이 쓰거나 고치는 모든 파일의 한국어를 포함합니다. 문서와 보고서는 물론이고 코드 주석, 화면에 나가는 문자열, 자막과 템플릿, 스크립트가 읽어 산출물을 만드는 데이터 파일까지 모두 해당합니다.',
     '적용 예외: 원문을 그대로 옮기는 인용과, 프로젝트의 기존 표기 관례를 따라야 하는 커밋 메시지와 로그 문자열입니다.',
+    // The vendored text says the opposite of the line above, and it says so
+    // twice. Left unaddressed the model has no way to decide which sentence
+    // governs a code comment, and in September 2026 that ambiguity shipped em
+    // dashes into comments and log strings while the guidance was active. The
+    // vendored wording stays untouched, so the conflict is resolved by naming
+    // which side wins rather than by editing the source.
+    '아래에 이어지는 fluent-korean 본문은 "인용, 코드, 코드 주석에는 이 지침들을 적용하지 않습니다"라고 적고 있으며 동작 범위 2번 조항에서 한 번 더 강조합니다. 그러나 이 세션에서는 바로 위의 적용 대상과 적용 예외가 그 문장보다 우선합니다. 즉 코드 주석에도 지침을 적용하십시오.',
     '쓰기 시점에 기계 검사가 함께 돌아갑니다. 위반을 알리면 그 파일을 고친 뒤에 다음 작업으로 넘어가십시오.',
   ];
 }

package/src/model-alias.js

@@ -69,8 +69,14 @@ const ROLES = ['main', 'opus', 'sonnet', 'haiku', 'fable'];
 
 /**
  * Alias for a role, taken from the environment Claude Code itself uses to
- * pick subagent models. Returns null when the variable is absent or is itself
- * an ARN (resolving an ARN to another ARN would loop).
+ * pick subagent models. Returns null when the variable is absent, or when it
+ * is an opaque ARN that names no model (resolving one of those to another ARN
+ * would loop).
+ *
+ * A `foundation-model` ARN is not opaque: it spells the model out in its
+ * resource part, so it is unwrapped rather than rejected. Users who point
+ * these variables straight at an ARN — a normal way to configure a private
+ * gateway — used to get no delegation stats at all, and no hint as to why.
  */
 export function aliasForRole(role, env = process.env) {
   const candidates = {
@@ -81,7 +87,13 @@ export function aliasForRole(role, env = process.env) {
     fable: [env.ANTHROPIC_DEFAULT_FABLE_MODEL],
   }[role] || [];
   for (const v of candidates) {
-    if (typeof v === 'string' && v && !isGatewayModelId(v)) return v;
+    if (typeof v !== 'string' || !v) continue;
+    if (!isGatewayModelId(v)) return v;
+    // `arn:…:foundation-model/anthropic.claude-haiku-4-5-…` → the model id.
+    // An `application-inference-profile` id is a random string and stays
+    // rejected: guessing at it is how wrong prices get into the ledger.
+    const inner = profileIdFrom(v);
+    if (inner && /claude/i.test(inner)) return inner;
   }
   return null;
 }

package/src/parser.js

@@ -4,10 +4,23 @@ import { createInterface } from 'node:readline';
 import { join, isAbsolute } from 'node:path';
 import { homedir } from 'node:os';
 import { loadCache, getCached, putCached, saveCache } from './session-cache.js';
-import { resolveModelAlias } from './model-alias.js';
+import { resolveModelAlias, isGatewayModelId } from './model-alias.js';
 
 const CLAUDE_DIR = join(homedir(), '.claude', 'projects');
 
+/**
+ * Keys LiteLLM adds when it rewrites a Bedrock response into Anthropic shape.
+ * A stock Anthropic `usage` object carries none of them, so their presence is
+ * evidence of a gateway even when the model id looks ordinary. It is weak
+ * evidence — another gateway may not add them — so it is only consulted after
+ * the model id has already failed to answer the question.
+ */
+const GATEWAY_USAGE_KEYS = ['inference_geo', 'iterations', 'speed'];
+
+function usageLooksGatewayShaped(usage) {
+  return GATEWAY_USAGE_KEYS.some((k) => Object.prototype.hasOwnProperty.call(usage, k));
+}
+
 /**
  * Parse a single session JSONL file.
  * Deduplicates by requestId (last-write-wins for streaming chunks).
@@ -17,6 +30,7 @@ export async function parseSessionFile(filePath) {
   let sessionId = null;
   let firstTimestamp = null;
   let lastTimestamp = null;
+  let gatewayObserved = false;
 
   const rl = createInterface({
     input: createReadStream(filePath, { encoding: 'utf8' }),
@@ -48,6 +62,14 @@ export async function parseSessionFile(filePath) {
     const cc = usage.cache_creation || {};
     const reqId = entry.requestId || msg.id;
 
+    // Recorded from the RAW id, before resolveModelAlias() turns the ARN into
+    // a plain model name. Downstream this is the only thing that distinguishes
+    // "no cache writes yet" from "a gateway that never reports the TTL split",
+    // and those two states want opposite countdown defaults.
+    if (!gatewayObserved && (isGatewayModelId(msg.model) || usageLooksGatewayShaped(usage))) {
+      gatewayObserved = true;
+    }
+
     requests.set(reqId, {
       requestId: reqId,
       model: resolveModelAlias(msg.model),
@@ -87,6 +109,7 @@ export async function parseSessionFile(filePath) {
     totals,
     maxContextPerRequest,
     model: reqs[0]?.model || 'unknown',
+    gatewayObserved,
   };
 }
 

package/src/session-cache.js

@@ -26,7 +26,10 @@ import { debug } from './debug.js';
 const CACHE_PATH = join(userDataDir(), 'session-cache.json');
 // Bump when the cached summary's shape changes — old entries are dropped
 // wholesale rather than migrated.
-const CACHE_VERSION = 1;
+// 2: sessions carry `gatewayObserved`. Entries written by version 1 lack it,
+// and a missing flag reads as "not a gateway" — the wrong default for exactly
+// the users the flag exists for.
+const CACHE_VERSION = 2;
 // Entries for transcripts this old are pruned on write. Keeps the file
 // bounded without an existence check per entry (which would cost the syscalls
 // the cache exists to avoid).