sprag-cli 3.40.0

package/src/commands/install.js

@@ -0,0 +1,358 @@
+/**
+ * Subcommand: install — write the Claude Code auto-trigger skill so the
+ * user can just mention chip wording and Claude responds. v2.6.0 dropped
+ * the redundant /token-monitor slash command in favor of the skill alone;
+ * a legacy command file is removed automatically. Cross-platform.
+ *   claude-token-saver install              # install/update the skill
+ *   claude-token-saver install --force      # overwrite existing skill file
+ *   claude-token-saver install --yes        # take the defaults instead of asking
+ *   claude-token-saver install --no-input   # same as --yes; also implied by CTS_NO_INPUT=1
+ */
+
+import { debug } from '../debug.js';
+
+/** Thrown when the user declines an optional step, so it is not reported as a failure. */
+class SkipStep extends Error {}
+
+export async function run({ hasFlag }) {
+    const { installAll } = await import('../installer.js');
+    const { userLanguage, languageDecided, setUserLanguage } = await import('../config.js');
+    const { canPrompt, confirm } = await import('../prompt.js');
+    const force = hasFlag('--force');
+    // Two features below write to ~/.claude and cost tokens in every session,
+    // so the install shows what they contain and asks before turning them on.
+    // Asking is only possible with a human attached: postinstall, CI and pipes
+    // fall through to the previous automatic defaults so an unattended upgrade
+    // behaves exactly as it did before.
+    const interactive = canPrompt() && !hasFlag('--yes') && !hasFlag('--no-input');
+
+    // Output language, decided first because every line below it — and every
+    // briefing the hooks inject from here on — is written in it. Until now it
+    // fell back to English with no question asked, so a Korean user read English
+    // reports until they happened to find `mode ko`.
+    //
+    // The locale is the default, not the answer: a terminal user gets to
+    // overrule it either way. An unattended install records the detected locale
+    // rather than leaving the setting blank, because "blank" silently means
+    // English — the one outcome a Korean-locale machine should not get by
+    // default. Already decided means never asked again.
+    try {
+      if (!languageDecided() && !process.env.CTS_LANG) {
+        const { koreanLocaleDetected } = await import('../korean-style.js');
+        const detected = koreanLocaleDetected() ? 'ko' : 'en';
+        console.log('');
+        console.log('  language: reports, warnings and session briefings are written in this language.');
+        console.log(`            detected locale: ${detected === 'ko' ? 'Korean' : 'not Korean (English)'}`);
+        let chosen = detected;
+        if (interactive) {
+          const ko = await confirm('            Use Korean? (no = English)', { defaultValue: detected === 'ko' });
+          chosen = ko ? 'ko' : 'en';
+        }
+        setUserLanguage(chosen);
+        console.log(`  language: set to ${chosen === 'ko' ? '한국어' : 'English'} — change it any time with \`claude-token-saver mode lang=${chosen === 'ko' ? 'en' : 'ko'}\``);
+      } else if (process.env.CTS_LANG) {
+        // Escape hatch for scripted installs, which cannot answer a prompt but
+        // do know which language the machine's user reads.
+        const forced = setUserLanguage(process.env.CTS_LANG);
+        console.log('');
+        console.log(forced
+          ? `  language: set to ${forced} (CTS_LANG)`
+          : `  language: ignored CTS_LANG=${process.env.CTS_LANG} — use 'ko' or 'en'`);
+      }
+    } catch (e) {
+      debug('install:language', e); // the English fallback still works
+    }
+    const lang = userLanguage();
+
+    const print = (kind, r) => {
+      const verb = r.action === 'exists' ? 'already exists' : r.action;
+      console.log(`  ${kind}: ${r.path} (${verb})`);
+    };
+    const r = installAll({ force });
+    print('skill', r.skill);
+    print('SessionStart hook (route-scan)', r.sessionStartHook);
+    print('UserPromptSubmit hook (brief)', r.briefHook);
+    {
+      let s = r.statusline;
+      // A different statusline is already installed. Replacing it silently
+      // would be rude and leaving it silently loses the tool's main surface,
+      // so with a human attached the install asks. Default is "keep yours":
+      // an accidental Enter must not clobber someone's custom statusline.
+      if (s.action === 'skipped' && s.conflict && interactive) {
+        console.log('');
+        console.log(lang === 'ko'
+          ? `  statusline: 기존 statusline이 이미 설정되어 있습니다: ${s.existingCommand}`
+          : `  statusline: an existing statusline is already configured: ${s.existingCommand}`);
+        console.log(lang === 'ko'
+          ? '              교체하면 토큰·캐시·상한 경고가 statusline에 표시됩니다. 기존 설정은 사라집니다.'
+          : '              replacing it shows token/cache/cap warnings in the statusline; the current one is removed.');
+        const replace = await confirm(lang === 'ko'
+          ? '              claude-token-saver statusline으로 교체할까요?'
+          : '              Replace it with the claude-token-saver statusline?', { defaultValue: false });
+        if (replace) {
+          const { installStatusline } = await import('../installer.js');
+          s = installStatusline({ force: true });
+        } else {
+          s = { ...s, reason: lang === 'ko'
+            ? '기존 statusline을 유지했습니다. 교체하려면 `claude-token-saver install --force`'
+            : 'kept your statusline — replace later with `claude-token-saver install --force`' };
+        }
+      }
+      const verb = s.action === 'exists' ? 'already configured (refreshInterval=5)'
+        : s.action === 'skipped' ? `skipped — ${s.reason}`
+        : s.reason ? `${s.action} — ${s.reason}`
+        : s.action;
+      console.log(`  statusline: ${s.path} (${verb})`);
+    }
+    if (r.legacy.action === 'removed') {
+      print('legacy /token-monitor', r.legacy);
+      console.log('  (consolidated into the skill — same workflow, triggered by intent)');
+    }
+    // First-time setup: analyze existing session logs right away so the
+    // very first session already sees delegation candidates — without this,
+    // the initial scan would only start from the first session's hook and
+    // its results would surface one session late. Runs inline (a few
+    // seconds on a typical 14-day history): a detached child can be reaped
+    // by sandboxed installers before it finishes, and postinstall carries
+    // `|| true` so a failure here never breaks the install.
+    {
+      const rs = await import('../route-scan.js');
+      if (!rs.readRouteScan()) {
+        try {
+          console.log('');
+          console.log(lang === 'ko'
+            ? '  route-scan: 기존 세션 로그의 사용 패턴을 분석하는 중...'
+            : '  route-scan: analyzing usage patterns in your existing session logs...');
+          const cache = await rs.runRouteScan({ days: 14 });
+          console.log(lang === 'ko'
+            ? `  route-scan: 에피소드 ${cache.totalEpisodes}건 분석 완료 — 위임 후보 ${cache.candidates.length}건.`
+            : `  route-scan: analyzed ${cache.totalEpisodes} episodes — ${cache.candidates.length} delegation candidate(s).`);
+          console.log(lang === 'ko'
+            ? '              (다음 Claude Code 세션에서 티어 위임 후보가 표시됩니다)'
+            : '              (candidates surface in your next Claude Code session)');
+        } catch (e) { debug('install:route-scan-seed', e); /* hook-triggered scan covers it on the first session instead */ }
+      }
+    }
+    // Harness, set up as part of the install rather than left as a manual
+    // follow-up step. The 🅷 statusline segment and the ratchet rules that
+    // route-scan promotes both depend on the block existing in CLAUDE.md, so
+    // an install without it ships a tool that is half wired up.
+    //
+    // Scope is global (~/.claude/CLAUDE.md): a global install is not tied to
+    // any one project, and the harness principles are project-independent.
+    // Only ever ADDS — harnessInit appends its own marked block, backs up the
+    // previous file, and leaves surrounding content untouched. Skipped when a
+    // block is already there (nothing to do) and when CTS_NO_HARNESS=1 is set,
+    // for anyone who wants the statusline without the CLAUDE.md rules.
+    try {
+      const { harnessInit, harnessStatus } = await import('../harness.js');
+      const before = harnessStatus(undefined, { scope: 'global' });
+      if (process.env.CTS_NO_HARNESS === '1') {
+        console.log('');
+        console.log(lang === 'ko'
+          ? '  harness: CTS_NO_HARNESS=1 이므로 건너뜁니다 (나중에 `harness init --global`).'
+          : '  harness: skipped (CTS_NO_HARNESS=1) — run `harness init --global` later.');
+      } else if (before.hasBlock) {
+        console.log('');
+        console.log(lang === 'ko'
+          ? `  harness: 이미 설정됨 — 🅷 ${before.configured}/${before.total} (${before.file})`
+          : `  harness: already set up — 🅷 ${before.configured}/${before.total} (${before.file})`);
+      } else {
+        // Show the five principle headings before writing them. The block goes
+        // into the file the model reads at the start of every session, so the
+        // user should see its contents before agreeing, not after.
+        const { HARNESS_SECTIONS } = await import('../harness-templates.js');
+        console.log('');
+        console.log(lang === 'ko'
+          ? '  harness: 다음 5원칙을 ~/.claude/CLAUDE.md 에 추가합니다 (모든 프로젝트에 적용).'
+          : '  harness: the following 5 principles would be added to ~/.claude/CLAUDE.md (all projects).');
+        for (const s of HARNESS_SECTIONS) {
+          console.log(`           ${s.heading.replace(/^###\s*/, '')}`);
+        }
+        console.log(lang === 'ko'
+          ? '           기존 내용은 지우지 않고 뒤에 덧붙이며, 원본은 .bak 으로 백업됩니다.'
+          : '           existing content is kept — the block is appended and the original is backed up as .bak.');
+        let proceed = true;
+        if (interactive) {
+          proceed = await confirm(lang === 'ko' ? '           지금 설정할까요?' : '           Set this up now?', { defaultValue: true });
+        }
+        if (!proceed) {
+          console.log(lang === 'ko'
+            ? '  harness: 건너뛰었습니다 — 나중에 `claude-token-saver harness init --global` 로 설정할 수 있습니다.'
+            : '  harness: skipped — set it up later with `claude-token-saver harness init --global`.');
+          throw new SkipStep();
+        }
+        const h = harnessInit({ scope: 'global' });
+        console.log('');
+        for (const p of h.backedUp) {
+          console.log(lang === 'ko' ? `  harness: 백업 ${p}` : `  harness: backed up ${p}`);
+        }
+        for (const p of h.wrote) {
+          console.log(lang === 'ko' ? `  harness: 작성 ${p}` : `  harness: wrote ${p}`);
+        }
+        console.log(lang === 'ko'
+          ? '  harness: 5원칙을 ~/.claude/CLAUDE.md 에 설정했습니다 — statusline에 🅷 5/5 가 표시됩니다.'
+          : '  harness: 5 principles installed in ~/.claude/CLAUDE.md — the statusline now shows 🅷 5/5.');
+        console.log(lang === 'ko'
+          ? '           되돌리려면: claude-token-saver harness uninit --global'
+          : '           to undo: claude-token-saver harness uninit --global');
+      }
+    } catch (e) {
+      // A declined prompt already printed its own line; only real failures fall
+      // through to the advice below.
+      if (e instanceof SkipStep) { /* user said no — nothing to report */ }
+      else {
+      // Never fail an install over this — the statusline and Skill are already
+      // in place, and `harness init` remains available as a manual step.
+      debug('install:harness-init', e);
+      console.log(lang === 'ko'
+        ? '  harness: 자동 설정을 건너뛰었습니다 — `claude-token-saver harness init --global` 로 직접 설정하세요.'
+        : '  harness: auto-setup skipped — run `claude-token-saver harness init --global` yourself.');
+      }
+    }
+
+    // Korean writing guidance. Decided here rather than left to a command the
+    // user has to find, because the people who need it are exactly the ones
+    // who would not know to look for it. Enabled when the machine's locale
+    // says Korean; left alone once the user has answered either way, so an
+    // upgrade never re-enables something they turned off.
+    try {
+      const ks = await import('../korean-style.js');
+      if (process.env.CTS_NO_KOREAN === '1') {
+        console.log('');
+        console.log(lang === 'ko'
+          ? '  korean: CTS_NO_KOREAN=1 이므로 건너뜁니다 (나중에 `korean on`).'
+          : '  korean: skipped (CTS_NO_KOREAN=1) — run `korean on` later.');
+      } else if (ks.koreanStyleDecided()) {
+        console.log('');
+        console.log(lang === 'ko'
+          ? `  korean: 기존 설정 유지 — 한국어 문체 지침 ${ks.koreanStyleEnabled() ? '켜짐' : '꺼짐'}`
+          : `  korean: keeping your setting — Korean writing guidance is ${ks.koreanStyleEnabled() ? 'on' : 'off'}`);
+      } else {
+        // The locale only decides what the question defaults to. It is a good
+        // guess, not an answer, so a user at a terminal gets to overrule it
+        // either way — including turning the guidance on where the locale is
+        // English but the person writing is not.
+        const detected = ks.koreanLocaleDetected();
+        console.log('');
+        console.log(lang === 'ko'
+          ? '  korean: 한국어 문체 지침(fluent-korean)을 세션 시작 시 주입할 수 있습니다.'
+          : '  korean: Korean writing guidance (fluent-korean) can be injected at session start.');
+        console.log(lang === 'ko'
+          ? '           내용: 조사·어미를 생략하지 않고, 명사구가 아니라 서술어로 문장을 끝맺으며,'
+          : '           what it does: keeps particles and endings, ends sentences with a predicate,');
+        console.log(lang === 'ko'
+          ? '                 번역체 대신 자연스러운 한국어를 쓰도록 지시합니다. 코드와 주석에는 적용되지 않습니다.'
+          : '                 and asks for idiomatic Korean over translationese. Code and comments are exempt.');
+        console.log(lang === 'ko'
+          ? '           비용: 세션당 약 1.5k 토큰(턴마다가 아니라 세션 시작 시 1회, 이후 프롬프트 캐시에 포함).'
+          : '           cost: ~1.5k tokens per session (once at session start, cached from the second request on).');
+        console.log(lang === 'ko'
+          ? `           출처: ${ks.KOREAN_STYLE_SOURCE}`
+          : `           source: ${ks.KOREAN_STYLE_SOURCE}`);
+        console.log(lang === 'ko'
+          ? `           감지된 환경: ${detected ? '한국어 (기본값 켬)' : '한국어 아님 (기본값 끔)'}`
+          : `           detected locale: ${detected ? 'Korean (default on)' : 'not Korean (default off)'}`);
+        let enable = detected;
+        if (interactive) {
+          enable = await confirm(lang === 'ko' ? '           켤까요?' : '           Enable it?', { defaultValue: detected });
+        }
+        // Record the choice only when it is really a choice. An unattended
+        // install on a non-Korean machine leaves the setting undecided so that
+        // a later run at a terminal still gets to ask, instead of silently
+        // inheriting a default the user never saw.
+        if (interactive || enable) ks.setKoreanStyleEnabled(enable);
+        if (enable) {
+          console.log(lang === 'ko'
+            ? '  korean: 켰습니다 — 모든 프로젝트의 세션 시작 시 주입됩니다. 끄려면 `claude-token-saver korean off`.'
+            : '  korean: enabled — injected at session start in every project. Turn off with `claude-token-saver korean off`.');
+        } else {
+          console.log(lang === 'ko'
+            ? '  korean: 꺼 두었습니다 — 나중에 `claude-token-saver korean on` 으로 켤 수 있습니다.'
+            : '  korean: left off — enable later with `claude-token-saver korean on`.');
+        }
+      }
+    } catch (e) {
+      debug('install:korean-style', e); // optional feature; never fail install
+    }
+
+    // doc2md. The hook itself is two entries in settings.json and costs
+    // nothing until a document shows up, so it goes on with the rest of the
+    // install instead of waiting for the user to discover `doc2md on` — the
+    // people who would save the most tokens are the ones who never find it.
+    // The converter is the expensive half (a venv plus a pip install), so it
+    // is only built when a human is attached; an unattended postinstall just
+    // prints the command.
+    try {
+      const { createRequire } = await import('node:module');
+      const require = createRequire(import.meta.url);
+      const doc2md = require('../doc2md.cjs');
+      if (process.env.CTS_NO_DOC2MD === '1') {
+        console.log('');
+        console.log(lang === 'ko'
+          ? '  doc2md: CTS_NO_DOC2MD=1 이므로 건너뜁니다 (나중에 `doc2md on`).'
+          : '  doc2md: skipped (CTS_NO_DOC2MD=1) — run `doc2md on` later.');
+      } else {
+        const { installDoc2mdHook } = await import('../installer.js');
+        const res = installDoc2mdHook();
+        console.log('');
+        console.log(res.action === 'skipped'
+          ? `  doc2md: ${res.reason}`
+          : `  doc2md: Read/Write hook ${res.action} (${res.path})`);
+        console.log(lang === 'ko'
+          ? `           대상 형식: ${doc2md.TARGET_EXTENSIONS.join(' ')} — 모델이 읽기 전에 Markdown으로 변환합니다.`
+          : `           formats: ${doc2md.TARGET_EXTENSIONS.join(' ')} — converted to Markdown before the model reads them.`);
+        let python = doc2md.findInterpreter();
+        if (!python && interactive) {
+          const build = await confirm(lang === 'ko'
+            ? '           변환기(markitdown)를 지금 설치할까요? 몇 분 걸립니다.'
+            : '           Install the converter (markitdown) now? Takes a few minutes.', { defaultValue: true });
+          if (build) {
+            const cres = doc2md.installConverter({ onProgress: (m) => console.log(`           ${m}`) });
+            if (cres.ok) python = cres.python;
+            else console.log(`           ${cres.reason}: ${cres.detail || ''}`);
+          }
+        }
+        console.log(python
+          ? (lang === 'ko' ? `           변환기: ${python}` : `           converter: ${python}`)
+          : (lang === 'ko'
+            ? `           변환기가 없습니다 — \`${doc2md.INSTALL_HINT}\` 를 실행해야 훅이 동작합니다.`
+            : `           converter missing — run \`${doc2md.INSTALL_HINT}\` or the hook does nothing.`));
+      }
+    } catch (e) {
+      debug('install:doc2md', e); // optional feature; never fail install
+    }
+
+    // Starter rules. The asking itself belongs to the first session — a
+    // postinstall cannot hold a conversation, and a prompt here would be
+    // answered by whoever happens to be at the terminal for a set of rules
+    // they have not read. All the install does is say what is waiting.
+    try {
+      const { pendingSeeds } = await import('../seed-rules.js');
+      const pending = pendingSeeds();
+      if (pending.length > 0) {
+        console.log('');
+        console.log(lang === 'ko'
+          ? `  seed: 추천 룰 ${pending.length}건이 대기 중입니다 (모델 피팅 + 랫쳇 프리셋).`
+          : `  seed: ${pending.length} recommended rule(s) are waiting (model-fitting + ratchet presets).`);
+        console.log(lang === 'ko'
+          ? '        다음 Claude Code 세션에서 한 건씩 등록할지 물어봅니다. 지금 보려면: claude-token-saver seed'
+          : '        the next Claude Code session asks about them one at a time. See them now: claude-token-saver seed');
+      }
+    } catch (e) {
+      debug('install:seed-offer', e); // optional feature; never fail install
+    }
+
+    console.log('');
+    console.log('Open Claude Code in any directory and just mention:');
+    console.log('  "cache hit rate" / "1M context" / "5H cap" — the skill auto-activates.');
+    if (!force) {
+      console.log('');
+      console.log('Tip: re-run with --force to overwrite the existing skill file.');
+    }
+    console.log('');
+    console.log(lang === 'ko'
+      ? '버그 제보·기능 제안: https://github.com/rootstudioyaml/claude-token-saver/issues'
+      : 'Bug reports & feature requests: https://github.com/rootstudioyaml/claude-token-saver/issues');
+    return;
+}

package/src/commands/korean.js

@@ -0,0 +1,220 @@
+/**
+ * Subcommand: korean — Korean writing guidance for every session.
+ *   claude-token-saver korean on       # inject at session start, all projects
+ *   claude-token-saver korean off      # stop injecting
+ *   claude-token-saver korean status   # current state, cost, and provenance
+ *   claude-token-saver korean show     # print the guidance itself
+ *
+ * Why this exists rather than pointing users at Claude Code's output styles:
+ * an output style is one global slot, so turning it on takes the slot away
+ * from whatever else the user had there, and it has to be configured on every
+ * machine. This ships the guidance with the package and delivers it through
+ * the SessionStart hook that is already installed, so it applies everywhere
+ * the CLI is installed and leaves the output-style slot free.
+ *
+ * Injection alone turned out to be half the job. The guidance is read once at
+ * session start and never again, so a long session writes documents that drift
+ * back to the patterns it forbids, and the drift is caught only when a human
+ * reads the finished file. `korean on` therefore also installs a PostToolUse
+ * hook that runs the machine-checkable clauses over the prose the model just
+ * wrote:
+ *   claude-token-saver korean lint block|warn|off   # how findings are handled
+ *   claude-token-saver korean lint <file...>        # check files on disk
+ */
+
+// Enforcement is only useful if it is on by default — a check the user has to
+// discover is the same hole in a different shape.
+function koreanLintMode(cfg) {
+  const mode = cfg?.koreanStyle?.lint;
+  return mode === 'off' || mode === 'warn' ? mode : 'block';
+}
+
+// `all` checks every text file the session writes, including Korean sitting in
+// comments and UI strings. That is wider than the vendored guidance's own
+// exemption list, and deliberately so: a comment is read by a person, and
+// generated artifacts (PDF, HTML, captions) are assembled from those strings,
+// so exempting them reopens the gap for exactly the outputs users complained
+// about. `prose` restores the narrow reading.
+function koreanLintScope(cfg) {
+  return cfg?.koreanStyle?.lintScope === 'prose' ? 'prose' : 'all';
+}
+
+export async function run({ args, hasFlag }) {
+  const sub = args[1] || 'status';
+  const ks = await import('../korean-style.js');
+  const { userLanguage, loadConfig, saveConfig } = await import('../config.js');
+  const lang = userLanguage();
+
+  // PostToolUse hook. Claude Code feeds the tool-call payload on stdin; we
+  // check the prose the model just wrote and hand any findings straight back
+  // to it. Silent and cheap when the file is clean, which is the common case.
+  if (hasFlag?.('--hook') || sub === '--hook') {
+    const { readStdinJson } = await import('../stdin-payload.js');
+    const payload = readStdinJson();
+    if (!payload || !ks.koreanStyleEnabled()) return;
+    const mode = koreanLintMode(loadConfig());
+    if (mode === 'off') return;
+    const { createRequire } = await import('node:module');
+    const req = createRequire(import.meta.url);
+    const lint = req('../korean-lint.cjs');
+    const result = lint.lintToolUse(payload, { scope: koreanLintScope(loadConfig()) });
+    if (!result) return;
+    const message = lint.formatFindings(result.filePath, result.findings);
+    if (mode === 'block') {
+      // Exit 2 is Claude Code's blocking-feedback channel: the file is already
+      // written, so nothing is lost, but the model must address this before it
+      // moves on. That is the whole point — a warning it can scroll past is
+      // what failed in the first place.
+      process.stderr.write(message + '\n');
+      process.exit(2);
+    }
+    console.log(message);
+    return;
+  }
+
+  // Manual run over files already on disk: `korean lint docs/*.md`.
+  if (sub === 'lint' && args.length > 2 && !['on', 'off', 'warn', 'block', 'scope'].includes(args[2])) {
+    const { readFileSync } = await import('node:fs');
+    const { createRequire } = await import('node:module');
+    const lint = createRequire(import.meta.url)('../korean-lint.cjs');
+    let total = 0;
+    for (const file of args.slice(2)) {
+      let text;
+      try {
+        text = readFileSync(file, 'utf8');
+      } catch (e) {
+        console.error(`${file}: ${e.message}`);
+        continue;
+      }
+      if (lint.isHtmlFile(file)) text = lint.stripHtml(text);
+      const findings = lint.lintKoreanText(text, { code: !lint.isProseFile(file) });
+      total += findings.length;
+      if (findings.length) console.log(lint.formatFindings(file, findings));
+    }
+    if (total === 0) {
+      console.log(lang === 'ko' ? '문체 규약 위반이 없습니다.' : 'No findings.');
+    }
+    process.exit(total > 0 ? 1 : 0);
+  }
+
+  // Scope switch: `korean lint scope all|prose`.
+  if (sub === 'lint' && args[2] === 'scope') {
+    const cfg = loadConfig();
+    const next = args[3];
+    if (!next) {
+      console.log(lang === 'ko'
+        ? `검사 범위: ${koreanLintScope(cfg)}`
+        : `Check scope: ${koreanLintScope(cfg)}`);
+      return;
+    }
+    if (!['all', 'prose'].includes(next)) {
+      console.error('Usage: claude-token-saver korean lint scope [all|prose]');
+      process.exit(1);
+    }
+    cfg.koreanStyle = cfg.koreanStyle || {};
+    cfg.koreanStyle.lintScope = next;
+    saveConfig(cfg);
+    console.log(lang === 'ko'
+      ? (next === 'all'
+        ? '검사 범위: all — 문서와 코드 주석, UI 문자열까지 세션이 쓴 모든 텍스트 파일을 검사합니다.'
+        : '검사 범위: prose — 마크다운과 텍스트 문서만 검사합니다.')
+      : (next === 'all'
+        ? 'Check scope: all — every text file the session writes, comments and UI strings included.'
+        : 'Check scope: prose — documents only.'));
+    return;
+  }
+
+  // Enforcement mode: `korean lint block|warn|off`.
+  if (sub === 'lint') {
+    const mode = args[2];
+    const cfg = loadConfig();
+    if (!mode) {
+      console.log(lang === 'ko'
+        ? `쓰기 시점 검사: ${koreanLintMode(cfg)} (범위 ${koreanLintScope(cfg)})`
+        : `Write-time check: ${koreanLintMode(cfg)} (scope ${koreanLintScope(cfg)})`);
+      return;
+    }
+    if (!['block', 'warn', 'off'].includes(mode)) {
+      console.error('Usage: claude-token-saver korean lint [block|warn|off] | korean lint <file...>');
+      process.exit(1);
+    }
+    cfg.koreanStyle = cfg.koreanStyle || {};
+    cfg.koreanStyle.lint = mode;
+    saveConfig(cfg);
+    const note = {
+      block: lang === 'ko' ? '위반을 발견하면 모델에게 되돌려 보내 고치게 합니다.' : 'Findings are handed back to the model as blocking feedback.',
+      warn: lang === 'ko' ? '위반을 알리기만 하고 진행을 막지 않습니다.' : 'Findings are printed as a note and do not block.',
+      off: lang === 'ko' ? '쓰기 시점 검사를 하지 않습니다.' : 'The write-time check is disabled.',
+    }[mode];
+    console.log(`${lang === 'ko' ? '쓰기 시점 검사' : 'Write-time check'}: ${mode} — ${note}`);
+    return;
+  }
+
+  if (sub === 'show') {
+    const text = ks.koreanStyleText();
+    if (!text) {
+      console.error('Korean style guidance file is missing from the package.');
+      process.exit(1);
+    }
+    console.log(text);
+    return;
+  }
+
+  if (sub === 'on' || sub === 'off') {
+    const enabled = sub === 'on';
+    ks.setKoreanStyleEnabled(enabled);
+    const { installKoreanLintHook, removeKoreanLintHook } = await import('../installer.js');
+    const hook = enabled ? installKoreanLintHook() : removeKoreanLintHook();
+    if (enabled) {
+      console.log(lang === 'ko'
+        ? '한국어 문체 지침을 켰습니다. 다음 세션부터 모든 프로젝트에 적용됩니다.'
+        : 'Korean writing guidance is on. It applies in every project from the next session.');
+      console.log(lang === 'ko'
+        ? '  주입 시점: 세션 시작 1회 (매 턴이 아니므로 두 번째 요청부터는 캐시에 올라갑니다)'
+        : '  Injected once per session (not per turn), so it rides the prompt cache from the second request on.');
+      console.log(lang === 'ko'
+        ? `  출처: ${ks.KOREAN_STYLE_SOURCE}`
+        : `  Source: ${ks.KOREAN_STYLE_SOURCE}`);
+      if (hook.action === 'skipped') {
+        console.log(lang === 'ko'
+          ? `  ⚠ 쓰기 시점 검사 훅을 못 걸었습니다: ${hook.reason}`
+          : `  ⚠ Could not register the write-time hook: ${hook.reason}`);
+      } else {
+        console.log(lang === 'ko'
+          ? `  쓰기 시점 검사: ${koreanLintMode(loadConfig())}, 범위 ${koreanLintScope(loadConfig())} (Write·Edit 로 쓴 한국어를 검사합니다)`
+          : `  Write-time check: ${koreanLintMode(loadConfig())}, scope ${koreanLintScope(loadConfig())} (runs on Korean written via Write/Edit)`);
+      }
+    } else {
+      console.log(lang === 'ko'
+        ? '한국어 문체 지침을 껐습니다. 다음 세션부터 주입하지 않습니다.'
+        : 'Korean writing guidance is off. Nothing is injected from the next session.');
+    }
+    return;
+  }
+
+  // status (default)
+  const on = ks.koreanStyleEnabled();
+  const text = ks.koreanStyleText();
+  // 4 bytes/token is the usual mixed ko/en approximation, same as the ratchet
+  // size report — this is the number the user is trading for the style.
+  const tokens = text ? Math.round(Buffer.byteLength(text, 'utf8') / 4) : 0;
+  if (lang === 'ko') {
+    console.log(`한국어 문체 지침: ${on ? '켜짐' : '꺼짐'}`);
+    console.log(`  비용: 세션당 약 ${tokens} 토큰 (세션 시작 1회 주입)`);
+    console.log(`  쓰기 시점 검사: ${koreanLintMode(loadConfig())}, 범위 ${koreanLintScope(loadConfig())} (바꾸려면 claude-token-saver korean lint block|warn|off, korean lint scope all|prose)`);
+    console.log(`  출처: ${ks.KOREAN_STYLE_SOURCE}`);
+    console.log(`  라이선스 전문: ${ks.KOREAN_STYLE_LICENSE_PATH}`);
+    console.log(on
+      ? '  끄려면: claude-token-saver korean off'
+      : '  켜려면: claude-token-saver korean on');
+  } else {
+    console.log(`Korean writing guidance: ${on ? 'on' : 'off'}`);
+    console.log(`  Cost: ~${tokens} tokens per session (injected once at session start)`);
+    console.log(`  Write-time check: ${koreanLintMode(loadConfig())}, scope ${koreanLintScope(loadConfig())} (change with: claude-token-saver korean lint block|warn|off, korean lint scope all|prose)`);
+    console.log(`  Source: ${ks.KOREAN_STYLE_SOURCE}`);
+    console.log(`  License text: ${ks.KOREAN_STYLE_LICENSE_PATH}`);
+    console.log(on
+      ? '  Turn off with: claude-token-saver korean off'
+      : '  Turn on with: claude-token-saver korean on');
+  }
+}