claude-token-saver 3.23.3 → 3.25.0

package/src/commands/upgrade.js

@@ -0,0 +1,68 @@
+/**
+ * Subcommand: upgrade — install the latest release with the package manager
+ * that put this copy on disk.
+ *
+ *   claude-token-saver upgrade          # refresh the check, then install
+ *   claude-token-saver upgrade --print  # show the command, run nothing
+ *
+ * This is the command the model runs after the user says yes to the
+ * session-start offer, so it prints the exact command it is about to execute
+ * before executing it: an install that writes outside the project should never
+ * be a black box.
+ */
+
+import { spawn } from 'node:child_process';
+
+function runCommand(cmd) {
+  return new Promise((resolve) => {
+    // Shell form: the upgrade command is a fixed string we composed ourselves
+    // (no user input reaches it), and `npm install -g` needs the user's PATH
+    // resolution to find the same npm that installed us.
+    const child = spawn(cmd, { shell: true, stdio: 'inherit' });
+    child.on('close', (code) => resolve(code === null ? 1 : code));
+    child.on('error', () => resolve(1));
+  });
+}
+
+export async function run({ hasFlag, version }) {
+  const { updateStatus, refreshUpdateState, upgradeCommand } = await import('../update-check.js');
+  const { userLanguage } = await import('../config.js');
+  const lang = userLanguage();
+  const cmd = upgradeCommand();
+
+  if (hasFlag('--print')) {
+    console.log(cmd);
+    return;
+  }
+
+  // Refresh first so the "already latest" answer is trustworthy rather than up
+  // to 24h stale — an upgrade is a deliberate, interactive action, so one
+  // network round trip is fine here.
+  await refreshUpdateState(version);
+  const s = updateStatus(version);
+  if (!s.available) {
+    console.log(lang === 'ko'
+      ? `이미 최신 버전입니다 (v${version}). 설치할 것이 없습니다.`
+      : `Already on the latest version (v${version}). Nothing to install.`);
+    return;
+  }
+
+  console.log(lang === 'ko'
+    ? `v${version} → ${s.latest} 로 업그레이드합니다.`
+    : `Upgrading v${version} → ${s.latest}.`);
+  console.log(`$ ${cmd}`);
+  const code = await runCommand(cmd);
+  if (code !== 0) {
+    console.error(lang === 'ko'
+      ? `업그레이드 명령이 종료 코드 ${code}로 실패했습니다. 위 출력을 확인하고, 권한 문제라면 sudo 없이 설치되는 전역 경로인지 점검하십시오.`
+      : `Upgrade command failed with exit code ${code}. Check the output above; if it is a permissions error, verify your global install prefix.`);
+    process.exit(code);
+  }
+  // The freshly installed copy is a different file on disk, so this process
+  // 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);
+  console.log(lang === 'ko'
+    ? `설치가 끝났습니다. 새 셸에서 claude-token-saver --version 으로 ${s.latest} 인지 확인하십시오.`
+    : `Done. In a fresh shell, run claude-token-saver --version to confirm ${s.latest}.`);
+}

package/src/formatters/statusline.js

@@ -157,6 +157,33 @@ function buildKoreanSeg(c, isIcon, verbose) {
   }
 }
 
+/**
+ * Version segment builder — "which copy of this tool am I looking at", plus
+ * the upgrade nudge when a newer one has been published.
+ *
+ * Two states, deliberately different in weight:
+ *   - up to date  → `v3.24.0` in gray. Identity context, not news.
+ *   - update available → `⬆ v3.24.0 → 3.25.0` in yellow. Same tone as the
+ *     other "you should do something eventually" chips, never red: nothing is
+ *     broken, and a permanently-red statusline trains the eye to ignore red.
+ *
+ * A statusline cannot open a dialog, so the *asking* happens at session start
+ * (see route-scan --hook, which briefs the model to offer the upgrade). This
+ * chip is the persistent reminder between those offers, which is why it keeps
+ * rendering after the user declines — declining hides the session-start
+ * question, not the fact that a new version exists.
+ */
+function buildVersionSeg(version, update, c, isIcon, verbose) {
+  if (!version) return null;
+  if (update && update.available && update.latest) {
+    const body = verbose
+      ? `Update v${version} → ${update.latest}`
+      : `v${version} → ${update.latest}`;
+    return `${c(YELLOW)}${isIcon ? '⬆ ' : ''}${body}${c(RESET)}`;
+  }
+  return `${c(GRAY)}v${version}${c(RESET)}`;
+}
+
 /**
  * Harness 🅷 segment builder — shared by the full report and the no-session
  * fallback line. Best-effort: never throws into the statusline (corrupted
@@ -209,18 +236,21 @@ function buildCapWarnSeg(capWarn, c, isIcon) {
  * just because the user has been idle past the window — so cap-warn,
  * harness, and model chips still render around the "no session data" note.
  */
-export function formatNoSession({ caps = null, model = null, windowLabel = '' } = {}, { color = true, mode = 'icon' } = {}) {
+export function formatNoSession({ caps = null, model = null, windowLabel = '', version = '', update = null } = {}, { color = true, mode = 'icon' } = {}) {
   const c = (v) => (color ? v : '');
   const isIcon = mode === 'icon';
   const segs = [];
   const capSeg = buildCapWarnSeg(pickCapWarn(caps), c, isIcon);
   if (capSeg) segs.push(capSeg);
+  const versionSeg = buildVersionSeg(version, update, c, isIcon, false);
+  if (versionSeg && update && update.available) segs.push(versionSeg);
   const harnessSeg = buildHarnessSeg(c, isIcon);
   if (harnessSeg) segs.push(harnessSeg);
   if (typeof model === 'string' && model.length > 0) {
     segs.push(isIcon ? `${c(MAGENTA)}🤖 ${model}${c(RESET)}` : `${c(MAGENTA)}${model}${c(RESET)}`);
   }
   segs.push(`${c(GRAY)}🧠 no session data${windowLabel ? ` · ${windowLabel}` : ''}${c(RESET)}`);
+  if (versionSeg && !(update && update.available)) segs.push(versionSeg);
   return segs.join(' · ') + (color ? '\x1b[K' : '');
 }
 
@@ -231,7 +261,7 @@ export function formatNoSession({ caps = null, model = null, windowLabel = '' }
  * @param {boolean} [opts.verbose=false] - longer layout with labels
  * @param {boolean} [opts.timer=true] - show TTL countdown segment
  * @param {'text'|'icon'} [opts.mode='text'] - label style. 'icon' uses 🧠 ⏳ 💰 instead of word labels.
- * @param {string[]|null} [opts.segments] - whitelist of segments to render. Names: cap-warn, spike, harness, korean, model, hit, ttl, saved, delegated, ctx, period, plus per-window keys (`five_hour`, `seven_day`, …). `5h`/`7d` are kept as aliases for back-compat. Null/undefined = all.
+ * @param {string[]|null} [opts.segments] - whitelist of segments to render. Names: cap-warn, spike, version, harness, korean, model, hit, ttl, saved, delegated, ctx, period, plus per-window keys (`five_hour`, `seven_day`, …). `5h`/`7d` are kept as aliases for back-compat. Null/undefined = all.
  * @param {boolean} [opts.singleLine=false] - force the legacy one-line layout. By default, when the delegation ledger has lifetime savings, the routing totals lead on their own first line and everything else moves to line 2 (Claude Code renders multi-line statuslines; `--single-line` is the escape hatch for terminals that only show the first line).
  */
 export function formatReport(data, { color = true, verbose = false, timer = true, mode = 'text', segments = null, singleLine = false } = {}) {
@@ -446,6 +476,11 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // a missing section at a glance and know to run `harness init`.
   const harnessSeg = buildHarnessSeg(c, isIcon);
 
+  // Version / upgrade chip. Read from a cache written by a detached background
+  // check — this render path never touches the network.
+  const versionSeg = buildVersionSeg(options.version, data.update, c, isIcon, verbose);
+  const updateAvailable = !!(data.update && data.update.available);
+
   // Korean-style chip — rendered only when the session-start injection is on.
   const koreanSeg = buildKoreanSeg(c, isIcon, verbose);
 
@@ -550,6 +585,10 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   const segs = [];
   if (capWarnSeg && want('cap-warn')) segs.push(capWarnSeg);
   if (spikeSeg && want('spike')) segs.push(spikeSeg);
+  // An available upgrade rides up front with the other "act on this" chips.
+  // When there is nothing to upgrade to, the same segment is pure identity and
+  // sits at the tail instead (pushed after `saved`, below).
+  if (versionSeg && updateAvailable && want('version')) segs.push(versionSeg);
   if (harnessSeg && want('harness')) segs.push(harnessSeg);
   if (koreanSeg && want('korean')) segs.push(koreanSeg);
   if (modelSeg && want('model')) segs.push(modelSeg);
@@ -569,6 +608,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // it sits near the tail. The period label closes the line as a quiet
   // timeframe footer.
   if (want('saved')) segs.push(saveSeg);
+  if (versionSeg && !updateAvailable && want('version')) segs.push(versionSeg);
   if (want('period')) segs.push(periodSeg);
   // Trailing erase-to-end-of-line so any leftover characters from a previous
   // (longer) statusline render don't bleed into ours. \x1b[K is the standard

package/src/installer.js

@@ -284,6 +284,68 @@ export function installBriefHook() {
   return { path: file, action: 'created' };
 }
 
+// Registers the PostToolUse hook that checks Korean prose the session just
+// wrote. Session-start guidance teaches the model but is never re-read, so
+// files written later drift back to the patterns the guidance forbids and the
+// drift surfaces only when a human reads the artifact. This hook closes that
+// gap: it runs on the file the model just wrote, while it can still fix it.
+// Installed by `korean on`, removed by `korean off`. Idempotent.
+const KOREAN_LINT_HOOK_COMMAND = 'claude-token-saver korean --hook';
+
+export function installKoreanLintHook() {
+  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.PostToolUse !== undefined && !Array.isArray(settings.hooks.PostToolUse)) {
+    return { path: file, action: 'skipped', reason: 'hooks.PostToolUse is not an array — fix settings.json manually' };
+  }
+  const list = Array.isArray(settings.hooks.PostToolUse) ? settings.hooks.PostToolUse : [];
+  const already = list.some((m) =>
+    Array.isArray(m?.hooks) && m.hooks.some((h) => typeof h?.command === 'string' && h.command.includes('korean --hook')),
+  );
+  if (already) return { path: file, action: 'exists' };
+
+  list.push({
+    matcher: 'Write|Edit|MultiEdit',
+    hooks: [{ type: 'command', command: KOREAN_LINT_HOOK_COMMAND, timeout: 10 }],
+  });
+  settings.hooks.PostToolUse = list;
+  writeFileSync(file, JSON.stringify(settings, null, 2) + '\n');
+  return { path: file, action: 'created' };
+}
+
+export function removeKoreanLintHook() {
+  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?.PostToolUse;
+  if (!Array.isArray(list)) return { path: file, action: 'absent' };
+  const kept = list.filter((m) =>
+    !(Array.isArray(m?.hooks) && m.hooks.some((h) => typeof h?.command === 'string' && h.command.includes('korean --hook'))),
+  );
+  if (kept.length === list.length) return { path: file, action: 'absent' };
+  if (kept.length === 0) delete settings.hooks.PostToolUse;
+  else settings.hooks.PostToolUse = 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-lint.cjs

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * korean-lint — machine-checkable half of the fluent-korean guidance.
+ *
+ * Why this exists next to korean-style.js:
+ *
+ * korean-style.js hands the model ~1.3k tokens of prose at session start. That
+ * is the right way to teach judgement, but prose has no enforcement point. The
+ * model reads it once, writes forty files over the next two hours, and nothing
+ * ever re-checks the output. Users reported exactly that hole: the guidance was
+ * loaded, the session still shipped `~는 자리` and `~의 흐름` into documents,
+ * and it surfaced only when a human read the finished artifact.
+ *
+ * So the clauses a machine can decide are checked at write time instead. The
+ * PostToolUse hook already runs on Write/Edit, so every file the session
+ * produces passes through here and findings are handed back to the model while
+ * it can still fix them.
+ *
+ * Scope: every text file the session writes, documents and source alike. The
+ * vendored guidance exempts code comments, but a comment is read by a person
+ * and generated artifacts are assembled from the strings sitting in source, so
+ * exempting them reopens the gap for exactly the outputs that were reported.
+ * `isLintTarget(path, 'prose')` restores the narrow reading. Only dependencies,
+ * VCS internals, lockfiles, and binary or image files are skipped; build output
+ * is checked like anything else, and fenced code blocks are dropped from
+ * documents. Findings are requests to confirm, not
+ * verdicts — a settled idiom or a verbatim quotation is allowed to stay.
+ *
+ * Zero dependencies, CommonJS, so ~/.claude/cache-monitor-hook.cjs can require
+ * it standalone.
+ */
+
+'use strict';
+
+// Documents. Under the `prose` scope these are the only files checked.
+const PROSE_EXTENSIONS = new Set(['.md', '.mdx', '.markdown', '.txt', '.rst', '.adoc']);
+
+// Only two kinds of path are skipped: installed dependencies and VCS
+// internals, neither of which anyone in this session wrote. Build output is
+// deliberately NOT on this list. Generated artifacts are the files a reader
+// actually receives, so exempting `dist/` or `build/` would exempt the very
+// documents the check exists for.
+const SKIP_PATH = /(^|[\\/])(node_modules|\.git|.*\.min\.[a-z]+|.*-lock\.json|.*\.lock)([\\/]|$)/i;
+const BINARY_EXTENSIONS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.ico', '.pdf', '.zip', '.gz', '.tar',
+  '.mp3', '.mp4', '.wav', '.mov', '.woff', '.woff2', '.ttf', '.otf', '.map', '.bin',
+]);
+
+/**
+ * Figurative vocabulary (guidance 3.4). This is the clause human review misses
+ * most often, because each individual phrase reads fine in isolation — it is
+ * only against the rule that it is standing where a plain noun or verb should.
+ * Add a line here when a new one shows up; that is the whole maintenance story.
+ */
+const METAPHOR_LEXICON = [
+  // `자리` is the single most common substitution for a plain noun. Physical
+  // seating is the rare literal use, so those modifiers are excluded and
+  // everything else is raised for confirmation.
+  { re: /(?<!빈 |좌석 |앞 |뒤 |옆 )(?:^|(?<=\s))자리(?:에서|에서는|에|로|가|는|다|입니다|였습니다)?(?=\s|$|[.,·)])/, fix: "'지점'·'상황'·'부분'처럼 뜻을 그대로 담은 명사로 바꿉니다" },
+  { re: /[가-힣]+의\s*흐름/, fix: "'방향'·'순서'·'경과'로 바꿉니다" },
+  { re: /닿(?:는다|습니다|아|는 지점)/, fix: "'겨냥하다'·'해당하다'처럼 동작을 그대로 서술합니다" },
+  { re: /박(?:아 두|혀 있|아 넣)/, fix: "'명시하다'·'기록하다'로 바꿉니다" },
+  { re: /걷어내/, fix: "'없애다'·'제거하다'로 바꿉니다" },
+  { re: /손대(?:는|지|어)/, fix: "'수정하다'·'변경하다'로 바꿉니다" },
+  { re: /발목을 잡/, fix: '무엇이 어떻게 막는지 그대로 서술합니다' },
+  { re: /민낯|속살/, fix: "'실제 상태'·'내부 구조'로 바꿉니다" },
+  { re: /열쇠(?:다|입니다|가 된다)/, fix: "'핵심 조건'·'결정 요인'으로 바꿉니다" },
+  { re: /물꼬|신호탄|분수령|기폭제/, fix: '무엇이 시작되고 무엇이 바뀌는지 그대로 적습니다' },
+  { re: /판(?:을|도가|이)\s*(?:흔들|바뀌|뒤집)/, fix: '무엇이 어떻게 달라지는지 그대로 적습니다' },
+  { re: /몸집|심장부|두뇌 역할/, fix: "'규모'·'중심 구성 요소'로 바꿉니다" },
+  { re: /벽에 부딪|길을 열|문을 열/, fix: '무엇이 막히고 무엇이 가능해지는지 그대로 적습니다' },
+  { re: /갈림길|갈리는 지점/, fix: "'결정이 나뉘는 조건'으로 바꿉니다" },
+  { re: /깨어나|잠들어 있/, fix: "'동작을 시작하다'·'실행되지 않고 있다'로 바꿉니다" },
+];
+
+// Guidance 3.2/3.3: literal renderings of English noun phrases.
+const TRANSLATIONESE = [
+  { re: /에 대한/, fix: '서술어로 풀어 씁니다' },
+  { re: /[을를] 위한/, fix: '서술어로 풀어 씁니다' },
+  { re: /되어지/, fix: '이중 피동을 없애고 능동이나 단일 피동으로 씁니다' },
+  { re: /하는 것을 통해/, fix: "'~해서'·'~함으로써'로 줄입니다" },
+  { re: /라고 할 수 있다/, fix: '단정하거나 근거를 붙여 서술합니다' },
+];
+
+// Guidance 3.7: a period belongs after a 종결어미, not after a nominal ending.
+const NOMINAL_ENDING = /(?:음|함|됨|임|점|론|양|성|화)\.$/;
+
+/**
+ * Which files the checker opens.
+ *
+ * `prose` follows the guidance's own exemption list: documents only, because
+ * code and comments are excluded there. `all` is the scope users asked for
+ * once they saw what the narrow reading costs — Korean written into a comment,
+ * a UI string, or a template ends up in front of a reader exactly like a
+ * document does, and a generated PDF is assembled from those strings. Under
+ * `all` the only things skipped are installed dependencies, lockfiles, and
+ * files that are not text.
+ *
+ * When the scope is `all` the injected guidance says so too (see
+ * korean-style.js), so the model is told the same rule the checker enforces.
+ */
+function isLintTarget(filePath, scope = 'all') {
+  if (!filePath) return false;
+  if (SKIP_PATH.test(filePath)) return false;
+  const dot = filePath.lastIndexOf('.');
+  const ext = dot === -1 ? '' : filePath.slice(dot).toLowerCase();
+  if (PROSE_EXTENSIONS.has(ext)) return true;
+  if (scope !== 'all') return false;
+  if (!ext) return false;
+  return !BINARY_EXTENSIONS.has(ext);
+}
+
+// Kept for callers that only ever meant documents.
+function isProseFile(filePath) {
+  return isLintTarget(filePath, 'prose');
+}
+
+/** Drop fenced code blocks and inline code so snippets never trip the rules. */
+function stripCode(text) {
+  const out = [];
+  let fenced = false;
+  for (const line of String(text).split('\n')) {
+    if (/^\s*(```|~~~)/.test(line)) {
+      fenced = !fenced;
+      out.push('');
+      continue;
+    }
+    out.push(fenced ? '' : line.replace(/`[^`]*`/g, ' '));
+  }
+  return out;
+}
+
+function hasKorean(s) {
+  return /[가-힣]/.test(s);
+}
+
+/**
+ * Lint one document. Returns `[{ line, rule, hit, fix }]`, empty when clean.
+ * `lines` are 1-indexed against the original text so the model can jump
+ * straight to the offending line.
+ */
+function lintKoreanText(text, { maxFindings = 20, code = false } = {}) {
+  const findings = [];
+  const lines = stripCode(text);
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!hasKorean(line)) continue;
+    // Reference lists and link lines are citations, not authored prose.
+    if (/^\s*\[\d+\]:/.test(line)) continue;
+    // A document that teaches the rules has to spell the banned form out. Its
+    // headings and its ✗/○ example pairs are quotations of the rule, not
+    // breaches of it, so they are left alone.
+    if (/^\s*#/.test(line)) continue;
+    if (/[✗○✘❌⭕]/.test(line)) continue;
+
+    const at = i + 1;
+    const push = (rule, hit, fix) => {
+      if (findings.length < maxFindings) findings.push({ line: at, rule, hit, fix });
+    };
+
+    // In a source file `|` is an operator, so only the dashes are checked
+    // there; in a document a leading `|` is a table row rather than a sentence.
+    const sep = line.match(code ? /[—ㅡ]/ : /[—ㅡ|]/);
+    if (sep && !(sep[0] === '|' && /^\s*\|/.test(line))) {
+      push('구분자', sep[0], '접속사나 쉼표, 가운뎃점(·)으로 바꿉니다');
+    }
+
+    for (const { re, fix } of TRANSLATIONESE) {
+      const m = line.match(re);
+      if (m) push('번역체', m[0], fix);
+    }
+
+    for (const { re, fix } of METAPHOR_LEXICON) {
+      const m = line.match(re);
+      if (m) push('비유 어휘', m[0], fix);
+    }
+
+    for (const chunk of line.split(/[.,·\n]/)) {
+      const count = (chunk.match(/[가-힣]의(?=\s|[가-힣])/g) || []).length;
+      if (count >= 3) {
+        push("'의' 반복", chunk.trim().slice(0, 30), '생략된 문장 성분이 없는지 확인합니다');
+        break;
+      }
+    }
+
+    const trimmed = line.trim();
+    if (NOMINAL_ENDING.test(trimmed) && !/^[#>\-*\d]/.test(trimmed)) {
+      push('명사형 종결', trimmed.slice(-8), "마침표를 빼거나 '~습니다'로 끝맺습니다");
+    }
+  }
+
+  return findings;
+}
+
+/** Pull the text a Write/Edit/MultiEdit call just put on disk. */
+function writtenTextOf(toolName, toolInput) {
+  if (!toolInput || typeof toolInput !== 'object') return null;
+  if (toolName === 'Write') return typeof toolInput.content === 'string' ? toolInput.content : null;
+  if (toolName === 'Edit') return typeof toolInput.new_string === 'string' ? toolInput.new_string : null;
+  if (toolName === 'MultiEdit' || toolName === 'NotebookEdit') {
+    const edits = Array.isArray(toolInput.edits) ? toolInput.edits : [];
+    const joined = edits.map((e) => (e && typeof e.new_string === 'string' ? e.new_string : '')).join('\n');
+    return joined || null;
+  }
+  return null;
+}
+
+/**
+ * Full check for one PostToolUse payload. Returns null when there is nothing to
+ * say, which is the common case and must stay cheap.
+ */
+function lintToolUse(context, { scope = 'all' } = {}) {
+  if (!context) return null;
+  const toolName = context.tool_name;
+  const toolInput = context.tool_input;
+  const filePath = toolInput && typeof toolInput.file_path === 'string' ? toolInput.file_path : '';
+  if (!isLintTarget(filePath, scope)) return null;
+
+  const text = writtenTextOf(toolName, toolInput);
+  if (!text || !hasKorean(text)) return null;
+
+  const findings = lintKoreanText(text, { code: !isProseFile(filePath) });
+  if (findings.length === 0) return null;
+  return { filePath, findings };
+}
+
+/** Render findings as the message handed back to the model. */
+function formatFindings(filePath, findings) {
+  const head = `[korean-style] ${filePath} 에 문체 규약 위반 ${findings.length}건이 있습니다. 파일을 고친 뒤 계속하십시오.`;
+  const body = findings.map((f) => `  ${f.line}행 ${f.rule}: "${f.hit}" 이 걸렸습니다. ${f.fix}`);
+  const tail = '  (원문 인용이거나 이미 굳은 표현이면 그대로 두고, 그 이유를 한 줄로 밝히십시오.)';
+  return [head, ...body, tail].join('\n');
+}
+
+module.exports = {
+  METAPHOR_LEXICON,
+  isLintTarget,
+  isProseFile,
+  lintKoreanText,
+  writtenTextOf,
+  lintToolUse,
+  formatFindings,
+};

package/src/korean-style.js

@@ -117,6 +117,27 @@ export function koreanStyleText() {
  * "the user is asking about Korean writing rules" instead of "these rules
  * govern how I write from now on".
  */
+// The injected scope sentence and the write-time checker have to agree. When
+// they disagree the model is told one thing and corrected for another, which
+// is how the August 2026 report started: the scope line read as excluding
+// documents, so a session shipped 18 em dashes into a markdown deliverable
+// while the guidance was active. These lines are therefore derived from the
+// same `lintScope` setting the checker reads.
+export function koreanScopeLines(cfg = loadConfig()) {
+  const scope = cfg?.koreanStyle?.lintScope === 'prose' ? 'prose' : 'all';
+  if (scope === 'prose') {
+    return [
+      '적용 대상: 대화 답변, 그리고 새로 작성하거나 수정하는 마크다운·문서·보고서의 한국어 산문을 모두 포함합니다.',
+      '적용 예외: 원문을 그대로 옮기는 인용, 코드, 코드 주석, 그리고 프로젝트의 기존 표기 관례를 따라야 하는 커밋 메시지와 로그 문자열입니다.',
+    ];
+  }
+  return [
+    '적용 대상: 대화 답변, 그리고 세션이 쓰거나 고치는 모든 파일의 한국어를 포함합니다. 문서와 보고서는 물론이고 코드 주석, 화면에 나가는 문자열, 자막과 템플릿, 스크립트가 읽어 산출물을 만드는 데이터 파일까지 모두 해당합니다.',
+    '적용 예외: 원문을 그대로 옮기는 인용과, 프로젝트의 기존 표기 관례를 따라야 하는 커밋 메시지와 로그 문자열입니다.',
+    '쓰기 시점에 기계 검사가 함께 돌아갑니다. 위반을 알리면 그 파일을 고친 뒤에 다음 작업으로 넘어가십시오.',
+  ];
+}
+
 export function koreanStyleInjection({ cfg = loadConfig() } = {}) {
   if (!koreanStyleEnabled(cfg)) return null;
   const text = koreanStyleText();
@@ -124,8 +145,7 @@ export function koreanStyleInjection({ cfg = loadConfig() } = {}) {
   return [
     '[claude-token-saver korean-style] 이 세션에서 한국어를 출력할 때는 아래 지침을 따르십시오.',
     '이 지침은 사용자가 claude-token-saver에 설정한 것입니다.',
-    '적용 대상: 대화 답변, 그리고 새로 작성하거나 수정하는 마크다운·문서·보고서의 한국어 산문을 모두 포함합니다.',
-    '적용 예외: 원문을 그대로 옮기는 인용, 코드, 코드 주석, 그리고 프로젝트의 기존 표기 관례를 따라야 하는 커밋 메시지와 로그 문자열입니다.',
+    ...koreanScopeLines(cfg),
     '표기 규칙(예외 없이 적용): 도구 호출 인자에 한국어를 비롯한 비ASCII 문자열을 담을 때에는 반드시 리터럴 UTF-8로 작성하고, \\uXXXX 유니코드 이스케이프로는 절대 작성하지 마십시오. 이스케이프로 작성하면 글자가 깨진 채 파일에 기록되는 사례가 자주 발생합니다.',
     `(출처: ${KOREAN_STYLE_SOURCE})`,
     '',