sprag-cli 3.40.0

package/src/korean-lint.cjs

@@ -0,0 +1,303 @@
+#!/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']);
+
+// HTML is a document a reader receives, so it is checked under BOTH scopes,
+// like prose — but through `stripHtml` first, so tags, comments, and CSS never
+// trip the rules. Script bodies are kept: on a static page the Korean UI copy
+// (i18n dictionaries, template strings) lives exactly there, and that gap is
+// how an em dash shipped to a real landing page unchecked (2026-09-13).
+const HTML_EXTENSIONS = new Set(['.html', '.htm', '.xhtml', '.vue', '.svelte']);
+
+// 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;
+// This module and the hook copy that embeds it quote every banned form.
+const SELF_PATH = /(^|[\\/])(korean-lint\.cjs|cache-monitor-hook\.cjs)$/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: "'동작을 시작하다'·'실행되지 않고 있다'로 바꿉니다" },
+  // Added 2026-09-13. "fails loudly / fails silently" reads as idiom in English
+  // but lands as figurative vocabulary in Korean: a failure has no volume.
+  // 0 hits across 400 Korean files in yaml-sns-agent, so the confirm-request is
+  // not noise.
+  {
+    re: /(?:시끄럽게|시끄러운|조용히|조용한)\s*[가-힣]*(?:실패|틀리|드러나|어긋)|(?:실패|오류|버그)[가은는이]?\s*(?:시끄럽|시끄러운|조용하|조용한)/,
+    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: '단정하거나 근거를 붙여 서술합니다' },
+  // Conservative additions (2026-09-13), sourced from 국립국어원 공공언어
+  // 지침·한글문화연대 교정 사례·쿠버네티스 한글화 가이드. Bar for inclusion:
+  // the form is nearly always an improvement to change, so a confirm-request
+  // on it is rarely noise. See presets/korean-style/supplement.md.
+  { re: /(?:보여|쓰여|불려|잊혀)[지집진질져]/, fix: "이중 피동입니다. '보인다'·'쓰인'·'불린'·'잊힌'처럼 단일 피동으로 씁니다" },
+  { re: /에 다름 아니/, fix: "일본어 번역투입니다. '~일 뿐이다'·'바로 ~이다'로 바꿉니다" },
+  { re: /지 않으면 안 [되된됩돼]/, fix: "이중 부정 번역투입니다. '~해야 합니다'로 바꿉니다" },
+  { re: /(?<!여기|거기|저기|어디)에 있어서/, fix: "'~에서'·'~에는'으로 바꿉니다" },
+  { re: /(?:의미|특징|장점|단점|성격|가능성|중요성|효과)[을를] 가지고 있/, fix: "'~이다'·'~가 있다'로 바꿉니다 (have 직역)" },
+];
+
+// 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;
+  // The rule table has to spell every banned form out, so this file always
+  // matches its own lexicon. Checking it reports the rules, not a breach.
+  if (SELF_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 (HTML_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');
+}
+
+function isHtmlFile(filePath) {
+  const dot = String(filePath).lastIndexOf('.');
+  const ext = dot === -1 ? '' : String(filePath).slice(dot).toLowerCase();
+  return HTML_EXTENSIONS.has(ext);
+}
+
+/**
+ * Blank out the parts of an HTML document no reader sees — comments, CSS, and
+ * the tags themselves — while keeping every newline, so finding line numbers
+ * still point into the original file. Script bodies stay: that is where the
+ * page's Korean copy lives on a static site.
+ */
+function stripHtml(text) {
+  const blank = (m) => m.replace(/[^\n]/g, ' ');
+  return String(text)
+    .replace(/<!--[\s\S]*?-->/g, blank)
+    .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, blank)
+    .replace(/<[^>]+>/g, blank);
+}
+
+/** 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;
+
+  let text = writtenTextOf(toolName, toolInput);
+  if (!text || !hasKorean(text)) return null;
+
+  // Edits arrive as fragments, so tag-stripping only applies when the payload
+  // is a whole document; a fragment is still linted, just without stripping.
+  if (isHtmlFile(filePath) && toolName === 'Write') text = stripHtml(text);
+  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,
+  isHtmlFile,
+  stripHtml,
+  lintKoreanText,
+  writtenTextOf,
+  lintToolUse,
+  formatFindings,
+};

package/src/korean-style.js

@@ -0,0 +1,187 @@
+/**
+ * korean-style — inject Korean writing guidance into every session.
+ *
+ * Claude Code's own mechanism for this is an output style, which is a global
+ * switch: turning it on replaces whatever style the user had, and it only
+ * applies where the user remembered to configure it. Projects opened on a
+ * different machine, or by a teammate, get nothing.
+ *
+ * This module carries the guidance inside the package instead and hands it to
+ * the model through the SessionStart hook claude-token-saver already installs.
+ * The rules then apply in every project on the machine, with no output-style
+ * change and no plugin to install, and they survive `/clear` because the hook
+ * fires again.
+ *
+ * Cost: the text is ~1.3k tokens, injected once per session (not per turn) and
+ * covered by the prompt cache from the second request on. A token-saving tool
+ * has no business spending that silently, so the feature is opt-in via
+ * `claude-token-saver korean on`.
+ *
+ * The guidance itself is vendored from fluent-korean
+ * (https://github.com/snflkd/fluent-korean), Copyright (c) 2026 snflkd, MIT
+ * License — see presets/korean-style/LICENSE-fluent-korean. Only the
+ * output-style frontmatter was stripped; the wording is unmodified.
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { loadConfig, saveConfig } from './config.js';
+
+const require = createRequire(import.meta.url);
+
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+export const KOREAN_STYLE_PATH = join(packageRoot, 'presets', 'korean-style', 'fluent-korean.md');
+// Our own conservative additions (국립국어원 공공언어 지침, 쿠버네티스 한글화
+// 가이드 등에서 수집). Appended after the vendored text so the vendored file
+// stays byte-identical to upstream.
+export const KOREAN_STYLE_SUPPLEMENT_PATH = join(packageRoot, 'presets', 'korean-style', 'supplement.md');
+export const KOREAN_STYLE_LICENSE_PATH = join(packageRoot, 'presets', 'korean-style', 'LICENSE-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()) {
+  return cfg?.koreanStyle?.enabled === true;
+}
+
+/** True once the user has turned the feature on or off explicitly. */
+export function koreanStyleDecided(cfg = loadConfig()) {
+  return typeof cfg?.koreanStyle?.enabled === 'boolean';
+}
+
+/**
+ * Whether this machine looks like it writes Korean.
+ *
+ * Used only to decide the DEFAULT at install time. Turning the guidance on for
+ * everyone would bill ~1.5k tokens per session to users who never write a
+ * Korean sentence; leaving it off for everyone means the people who need it
+ * have to discover a command that exists for exactly them. Locale answers the
+ * question well enough, and the user can override either way afterwards.
+ *
+ * Signals, cheapest first: the tool's own language setting, then the POSIX
+ * locale variables, then (macOS only, where those are routinely unset) the
+ * system locale.
+ */
+export function koreanLocaleDetected({ env = process.env, platform = process.platform } = {}) {
+  try {
+    if (loadConfig().language === 'ko') return true;
+  } catch { /* unreadable config falls through to the env checks */ }
+  const posix = [env.LC_ALL, env.LC_MESSAGES, env.LANG, env.LANGUAGE].filter(
+    (v) => typeof v === 'string' && v.trim() && v !== 'C' && v !== 'POSIX',
+  );
+  for (const v of posix) {
+    // `ko` must be a whole subtag: `ko`, `ko_KR.UTF-8`, `ko-KR`, and the
+    // colon-separated `LANGUAGE=ko:en` all count, while `kok` (Konkani) and
+    // `tok` do not.
+    if (/(^|[:._-])ko([:._-]|$)/i.test(v)) return true;
+  }
+  // A locale variable that is set and is NOT Korean is an answer, not a missing
+  // signal: `LANG=en_US.UTF-8` on a machine whose system locale is Korean means
+  // the user chose English for their shell. Only consult the system locale when
+  // the POSIX variables say nothing at all, which is the macOS GUI-shell case
+  // this fallback exists for.
+  if (platform === 'darwin' && posix.length === 0) {
+    try {
+      // `LANG` is commonly unset in macOS GUI-launched shells, so the system
+      // locale is the only reliable signal there.
+      const { execFileSync } = require('node:child_process');
+      const out = execFileSync('defaults', ['read', '-g', 'AppleLocale'], {
+        encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'],
+      }).trim();
+      if (/^ko(_|-|$)/i.test(out)) return true;
+    } catch { /* `defaults` missing or slow — treat as "not detected" */ }
+  }
+  return false;
+}
+
+export function setKoreanStyleEnabled(enabled) {
+  const cfg = loadConfig();
+  cfg.koreanStyle = { ...(cfg.koreanStyle || {}), enabled: !!enabled };
+  saveConfig(cfg);
+  return cfg.koreanStyle;
+}
+
+/**
+ * The guidance text, with the vendoring comment stripped (it is provenance for
+ * readers of the repo, not instruction for the model — and every token of it
+ * would be charged on each session).
+ *
+ * Returns null when the file is missing, which the hook reads as "inject
+ * nothing" rather than failing a session start.
+ */
+export function koreanStyleText() {
+  try {
+    if (!existsSync(KOREAN_STYLE_PATH)) return null;
+    const raw = readFileSync(KOREAN_STYLE_PATH, 'utf8');
+    const body = raw.replace(/^<!--[\s\S]*?-->\s*/, '').trim();
+    if (!body) return null;
+    // The supplement is optional: a missing or empty file degrades to the
+    // vendored guidance alone rather than failing the injection.
+    try {
+      if (existsSync(KOREAN_STYLE_SUPPLEMENT_PATH)) {
+        const sup = readFileSync(KOREAN_STYLE_SUPPLEMENT_PATH, 'utf8')
+          .replace(/^<!--[\s\S]*?-->\s*/, '')
+          .trim();
+        if (sup) return `${body}\n\n${sup}`;
+      }
+    } catch { /* supplement unreadable: fall back to the vendored text */ }
+    return body;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Block to inject at session start, or null when disabled/unavailable.
+ *
+ * The framing line matters: without it the model can read the guidance as
+ * "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 [
+    '적용 대상: 대화 답변, 그리고 세션이 쓰거나 고치는 모든 파일의 한국어를 포함합니다. 문서와 보고서는 물론이고 코드 주석, 화면에 나가는 문자열, 자막과 템플릿, 스크립트가 읽어 산출물을 만드는 데이터 파일까지 모두 해당합니다.',
+    '적용 예외: 원문을 그대로 옮기는 인용과, 프로젝트의 기존 표기 관례를 따라야 하는 커밋 메시지와 로그 문자열입니다.',
+    // 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번 조항에서 한 번 더 강조합니다. 그러나 이 세션에서는 바로 위의 적용 대상과 적용 예외가 그 문장보다 우선합니다. 즉 코드 주석에도 지침을 적용하십시오.',
+    '쓰기 시점에 기계 검사가 함께 돌아갑니다. 위반을 알리면 그 파일을 고친 뒤에 다음 작업으로 넘어가십시오.',
+  ];
+}
+
+export function koreanStyleInjection({ cfg = loadConfig() } = {}) {
+  if (!koreanStyleEnabled(cfg)) return null;
+  const text = koreanStyleText();
+  if (!text) return null;
+  return [
+    '[claude-token-saver korean-style] 이 세션에서 한국어를 출력할 때는 아래 지침을 따르십시오.',
+    '이 지침은 사용자가 claude-token-saver에 설정한 것입니다.',
+    ...koreanScopeLines(cfg),
+    '표기 규칙(예외 없이 적용): 도구 호출 인자에 한국어를 비롯한 비ASCII 문자열을 담을 때에는 반드시 리터럴 UTF-8로 작성하고, \\uXXXX 유니코드 이스케이프로는 절대 작성하지 마십시오. 이스케이프로 작성하면 글자가 깨진 채 파일에 기록되는 사례가 자주 발생합니다.',
+    `(출처: ${KOREAN_STYLE_SOURCE})`,
+    '',
+    text,
+  ].join('\n');
+}