claude-token-saver 3.42.6 → 3.42.8

package/README.ko.md

@@ -458,7 +458,11 @@ sprag korean lint scope prose   # 마크다운·텍스트 문서만
 sprag korean lint docs/*.md     # 이미 저장된 파일을 직접 검사
 ```
 
-검사 항목은 사람이 판정할 필요가 없는 것들입니다. 비유 어휘 15종(`~는 자리`, `~의 흐름`, `닿는다`, `걷어내다`, `발목을 잡다` 등), 번역체 표지(`~에 대한`, `~를 위한`, `~되어지`), 구분자(`—`·`ㅡ`·`|`), 한 구에 세 번 이상 이어지는 조사 `의`, 명사형 종결 뒤의 마침표입니다. 판단이 필요한 조항(성분 생략, 한자어 선택)은 그대로 지침이 담당합니다.
+검사 항목은 사람이 판정할 필요가 없는 것들입니다. 비유 어휘 15종(`~는 자리`, `~의 흐름`, `닿는다`, `걷어내다`, `발목을 잡다` 등), 번역체 표지(`~에 대한`, `~를 위한`, `~되어지`), 구분자(`—`·`ㅡ`·`|`), 한 구에 세 번 이상 이어지는 조사 `의`, 명사형 종결 뒤의 마침표, 그리고 v3.42.7부터는 이어지는 두 문장이 똑같은 서술어로 끝나는 종결 반복입니다. 판단이 필요한 조항(성분 생략, 한자어 선택, 비슷하지만 똑같지는 않은 반복)은 그대로 지침이 담당합니다.
+
+검사 대상에는 Bash로 쓴 파일도 들어갑니다(v3.42.7). heredoc과 `tee`, `sed -i`는 Write와 똑같이 한국어를 디스크에 남기고, Write 도구가 없는 하위 에이전트는 `cat > 파일`부터 집습니다. 그래서 Bash를 빼 두면 위임해서 만든 결과물 전체가 검사를 비켜 갔습니다. 리다이렉션 대상 경로만 인식하고 명령문 자체는 읽지 않으므로, `echo`에 담긴 한국어가 잘못 걸리는 일은 없습니다.
+
+검사기를 시험하는 파일이나 문체 보고서처럼 금지된 표현을 일부러 담아야 하는 파일에는 `korean-lint: off` 한 줄을 넣으면 그 파일을 건너뜁니다.
 
 기본 범위 `all`은 문서뿐 아니라 **코드 주석과 화면에 나가는 문자열, 자막·템플릿, 생성 결과물까지** 검사합니다. 벤더링한 지침 원문은 코드 주석을 예외로 두지만, 주석도 사람이 읽고 PDF·HTML 같은 산출물은 그 문자열들로 조립되기 때문에 예외로 두면 정확히 문제가 됐던 경로가 다시 열립니다. 검사에서 빠지는 것은 설치된 의존성(`node_modules`), VCS 내부, 락 파일, 그리고 이진·이미지 파일뿐입니다. `dist`나 `build` 같은 산출물 디렉터리는 검사합니다. 원문 규약대로 문서만 보고 싶으면 `korean lint scope prose`로 되돌립니다.
 

package/README.md

@@ -1,3 +1,8 @@
+> **`claude-token-saver` is the old package name.**
+> Install `sprag-cli` instead — same tool, same binaries, same releases:
+> `npm i -g sprag-cli`
+> (switching needs a swap: `npm uninstall -g claude-token-saver && npm i -g sprag-cli`)
+
 <div align="center">
 
 <picture>
@@ -18,6 +23,8 @@
 ---
 
 <!-- ko:begin (generated from README.ko.md — edit that file, then run npm run sync:ko) -->
+**🇰🇷 한국어 문서: [README.ko.md](https://github.com/rootstudioyaml/sprag/blob/main/README.ko.md)** (아래 토글로도 펼칠 수 있습니다.)
+
 <details>
 <summary><strong>🇰🇷 한국어로 보기 (클릭하면 한국어 전문이 펼쳐집니다)</strong></summary>
 
@@ -462,7 +469,11 @@ sprag korean lint scope prose   # 마크다운·텍스트 문서만
 sprag korean lint docs/*.md     # 이미 저장된 파일을 직접 검사
 ```
 
-검사 항목은 사람이 판정할 필요가 없는 것들입니다. 비유 어휘 15종(`~는 자리`, `~의 흐름`, `닿는다`, `걷어내다`, `발목을 잡다` 등), 번역체 표지(`~에 대한`, `~를 위한`, `~되어지`), 구분자(`—`·`ㅡ`·`|`), 한 구에 세 번 이상 이어지는 조사 `의`, 명사형 종결 뒤의 마침표입니다. 판단이 필요한 조항(성분 생략, 한자어 선택)은 그대로 지침이 담당합니다.
+검사 항목은 사람이 판정할 필요가 없는 것들입니다. 비유 어휘 15종(`~는 자리`, `~의 흐름`, `닿는다`, `걷어내다`, `발목을 잡다` 등), 번역체 표지(`~에 대한`, `~를 위한`, `~되어지`), 구분자(`—`·`ㅡ`·`|`), 한 구에 세 번 이상 이어지는 조사 `의`, 명사형 종결 뒤의 마침표, 그리고 v3.42.7부터는 이어지는 두 문장이 똑같은 서술어로 끝나는 종결 반복입니다. 판단이 필요한 조항(성분 생략, 한자어 선택, 비슷하지만 똑같지는 않은 반복)은 그대로 지침이 담당합니다.
+
+검사 대상에는 Bash로 쓴 파일도 들어갑니다(v3.42.7). heredoc과 `tee`, `sed -i`는 Write와 똑같이 한국어를 디스크에 남기고, Write 도구가 없는 하위 에이전트는 `cat > 파일`부터 집습니다. 그래서 Bash를 빼 두면 위임해서 만든 결과물 전체가 검사를 비켜 갔습니다. 리다이렉션 대상 경로만 인식하고 명령문 자체는 읽지 않으므로, `echo`에 담긴 한국어가 잘못 걸리는 일은 없습니다.
+
+검사기를 시험하는 파일이나 문체 보고서처럼 금지된 표현을 일부러 담아야 하는 파일에는 `korean-lint: off` 한 줄을 넣으면 그 파일을 건너뜁니다.
 
 기본 범위 `all`은 문서뿐 아니라 **코드 주석과 화면에 나가는 문자열, 자막·템플릿, 생성 결과물까지** 검사합니다. 벤더링한 지침 원문은 코드 주석을 예외로 두지만, 주석도 사람이 읽고 PDF·HTML 같은 산출물은 그 문자열들로 조립되기 때문에 예외로 두면 정확히 문제가 됐던 경로가 다시 열립니다. 검사에서 빠지는 것은 설치된 의존성(`node_modules`), VCS 내부, 락 파일, 그리고 이진·이미지 파일뿐입니다. `dist`나 `build` 같은 산출물 디렉터리는 검사합니다. 원문 규약대로 문서만 보고 싶으면 `korean lint scope prose`로 되돌립니다.
 
@@ -1123,7 +1134,11 @@ sprag korean lint scope prose   # documents only
 sprag korean lint docs/*.md     # check files already on disk
 ```
 
-Checked: 15 figurative phrases, translationese markers, separators (`—`·`ㅡ`·`|`), three or more `의` particles in one phrase, and a period after a nominal ending. Clauses that need judgement stay with the guidance text.
+Checked: 15 figurative phrases, translationese markers, separators (`—`·`ㅡ`·`|`), three or more `의` particles in one phrase, a period after a nominal ending, and since v3.42.7 two consecutive sentences closing on the identical predicate. Clauses that genuinely need judgement — dropped sentence elements, word choice, near-miss repetition — stay with the guidance text.
+
+Bash writes are checked too (v3.42.7). A heredoc, a `tee`, or a `sed -i` puts Korean on disk exactly like Write does, and a subagent handed Bash but not Write reaches for `cat > file` first — so leaving Bash off the matcher exempted every artifact produced by delegated work. Only redirection targets are recognised, never the command body, so Korean inside an `echo` is not mistaken for prose.
+
+A file that must quote the banned forms — a fixture for this checker, a style report — opts out with one `korean-lint: off` line anywhere in it.
 
 The default `all` scope covers code comments, UI strings, subtitles, templates, and build output, not just documents. The vendored guidance exempts comments, but comments are read by people and generated artifacts (PDF, HTML) are assembled from those strings, so exempting them reopens the exact gap that was reported. Only installed dependencies, VCS internals, lockfiles, and binary or image files are skipped; `dist/` and `build/` are checked. `korean lint scope prose` restores the narrow reading.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-token-saver",
-  "version": "3.42.6",
+  "version": "3.42.8",
   "description": "Legacy name of sprag-cli (Sprag) - same tool, kept publishing so existing installs stay current. Prefer: npm i -g sprag-cli",
   "type": "module",
   "bin": {

package/presets/korean-style/supplement.md

@@ -83,6 +83,10 @@ LLM 산출물에서 반복적으로 관찰되는 습관입니다. 금지가 아
    - ✗ 토끼와 거북이가 경주를 했다. 토끼는 잠을 잤다. 거북이가 이겼다.
    - ○ 잠을 잔 토끼와 달리, 거북이는 꾸준히 걸어 경주에서 이겼다.
 
+7. 이어지는 두 문장을 같은 서술어로 끝내지 않습니다. 쓰기 시점 검사가 동일한 종결 어절만 '종결 반복'으로 잡아 주므로, 비슷하되 똑같지는 않은 반복은 직접 살펴야 합니다.
+   - ✗ 역회전하는 순간 잠급니다. 에이전트는 그대로 일하고, 퇴행만 잠급니다.
+   - ○ 역회전하는 순간 잠기는 부품입니다. 에이전트도 같아서, 하던 일은 그대로 진행되고 퇴행만 막힙니다.
+
 ### 과교정 금지 조항
 
 교정 자체가 오류가 되는 경우입니다. 나무위키 번역체 문서와 국립국어원 논의가 공통으로 경고하는 지점이므로, 아래 표현에는 위 조항들을 적용하지 않습니다.

package/presets/ratchet-rules.json

@@ -33,6 +33,10 @@
     {
       "ko": "탐색·조회·상태 확인·명령 실행 같은 단순 요청은 `model: haiku` 서브에이전트로 위임해 상위 모델 토큰을 아낀다 (읽기 전용 preset 에이전트가 이미 있으면 그걸 쓰고, 없으면 티어만 내려서 위임)",
       "en": "Delegate simple requests — lookup, status checks, running commands — to a `model: haiku` subagent to keep the expensive model's tokens for real work (use an existing read-only preset agent when there is one; otherwise delegate with the tier lowered)"
+    },
+    {
+      "ko": "지침이나 룰이 지켜지지 않아 같은 품질 문제가 재발하면 문구를 다시 쓰지 말 것 → 그 조항이 기계로 판정 가능한지부터 따지고(문자열 비교나 정규식으로 결정되면 판정 가능), 가능하면 쓰기 시점 훅이나 테스트 같은 차단 지점을 추가한다. 판단이 필요한 잔여 부분만 지침에 남기고 그 경계를 지침에 적는다. 실제 코퍼스에 돌려 오탐 건수를 센 뒤 좁히고, 회귀 테스트를 같은 커밋에 넣는다",
+      "en": "When a guideline keeps being violated and the same quality defect recurs, do NOT reword the instruction → first ask whether the clause is machine-decidable (a string comparison or regex settles it), and if so add an enforcement point such as a write-time hook or a test. Leave only the judgement remainder in the prose and state that boundary there. Measure the false-positive count on a real corpus, narrow until it is acceptable, and land a regression test in the same commit"
     }
   ]
 }

package/src/commands/install.js

@@ -228,6 +228,20 @@ export async function run({ hasFlag }) {
         console.log(lang === 'ko'
           ? `  korean: 기존 설정 유지 — 한국어 문체 지침 ${ks.koreanStyleEnabled() ? '켜짐' : '꺼짐'}`
           : `  korean: keeping your setting — Korean writing guidance is ${ks.koreanStyleEnabled() ? 'on' : 'off'}`);
+        // The answer is kept, but the hook registration behind it still has to
+        // reach the current shape. A machine that enabled the guidance before
+        // Bash joined the matcher would otherwise keep the narrow entry for
+        // good, and upgrading would silently leave shell-written files
+        // unchecked. installKoreanLintHook widens in place and is idempotent.
+        if (ks.koreanStyleEnabled()) {
+          const { installKoreanLintHook } = await import('../installer.js');
+          const migrated = installKoreanLintHook();
+          if (migrated.action === 'updated') {
+            console.log(lang === 'ko'
+              ? '          검사 범위 갱신: Bash 로 쓴 파일도 이제 확인합니다'
+              : '          matcher widened: files written through Bash are checked now');
+          }
+        }
       } 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

package/src/installer.js

@@ -306,6 +306,11 @@ export function installBriefHook() {
 // 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';
+// Bash belongs on this matcher because a heredoc, a `tee`, or a `sed -i` puts
+// Korean on disk exactly like Write does. A subagent without the Write tool
+// reaches for `cat > file` first, so leaving Bash off the list exempted every
+// file those agents produce (found 2026-09-14 by probing a haiku subagent).
+const KOREAN_LINT_MATCHER = 'Write|Edit|MultiEdit|Bash';
 
 export function installKoreanLintHook() {
   const dir = claudeUserDir();
@@ -326,13 +331,24 @@ export function installKoreanLintHook() {
     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) =>
+  const existing = list.find((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' };
+  if (existing) {
+    // An install from before Bash joined the matcher leaves the narrow entry in
+    // place forever, so upgrading a machine would not close the gap. Widen it
+    // here; anything the user hand-edited to something wider is left alone.
+    if (existing.matcher === 'Write|Edit|MultiEdit') {
+      existing.matcher = KOREAN_LINT_MATCHER;
+      settings.hooks.PostToolUse = list;
+      writeFileSync(file, JSON.stringify(settings, null, 2) + '\n');
+      return { path: file, action: 'updated' };
+    }
+    return { path: file, action: 'exists' };
+  }
 
   list.push({
-    matcher: 'Write|Edit|MultiEdit',
+    matcher: KOREAN_LINT_MATCHER,
     hooks: [{ type: 'command', command: KOREAN_LINT_HOOK_COMMAND, timeout: 10 }],
   });
   settings.hooks.PostToolUse = list;

package/src/korean-lint.cjs

@@ -49,7 +49,15 @@ const HTML_EXTENSIONS = new Set(['.html', '.htm', '.xhtml', '.vue', '.svelte']);
 // 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 SELF_PATH = /(^|[\\/])(korean-lint\.cjs|cache-monitor-hook\.cjs|korean-lint\.test\.js)$/i;
+
+// Opt-out marker. A file that exists to exercise the checker has to contain the
+// forms the checker bans, and so does a document quoting a style report. Before
+// Bash joined the matcher those files slipped through by accident; now that
+// every write route is covered, the exemption has to be something the author
+// states on purpose rather than something the tool guesses. One line anywhere
+// in the file turns the check off for that file.
+const OPT_OUT_MARKER = /korean-lint:\s*(?:off|ignore-file)/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',
@@ -115,6 +123,15 @@ const TRANSLATIONESE = [
 // Guidance 3.7: a period belongs after a 종결어미, not after a nominal ending.
 const NOMINAL_ENDING = /(?:음|함|됨|임|점|론|양|성|화)\.$/;
 
+// Sentence closers with no lexical content of their own: existence, negation,
+// the copula, and the do-verb. Korean puts these at the end of most sentences,
+// so repeating one across two sentences is normal writing. Only content verbs
+// repeating is the style problem the cohesion clause means.
+const AUXILIARY_ENDING = /^(?:있|없|않|아니|아닙|같|이|뿐이|때문이|것이|거|합|한|했|됩|된|됐|입|였|이었)/;
+// The copula and the do-verb also attach to a preceding noun, so they have to
+// be matched at the tail as well: `수치입니다`, `설명합니다`, `반영됩니다`.
+const AUXILIARY_TAIL = /(?:입니다|입니다만|이다|합니다|한다|됩니다|된다|있습니다|없습니다|않습니다|않는다)$/;
+
 /**
  * Which files the checker opens.
  *
@@ -195,6 +212,7 @@ function hasKorean(s) {
  */
 function lintKoreanText(text, { maxFindings = 20, code = false } = {}) {
   const findings = [];
+  if (OPT_OUT_MARKER.test(text)) return findings;
   const lines = stripCode(text);
 
   for (let i = 0; i < lines.length; i++) {
@@ -244,9 +262,80 @@ function lintKoreanText(text, { maxFindings = 20, code = false } = {}) {
     }
   }
 
+  findings.push(...repeatedEndings(lines, maxFindings - findings.length));
+
   return findings;
 }
 
+/**
+ * Adjacent sentences closing on the same predicate.
+ *
+ * This is a cohesion clause, and cohesion was written off as "needs judgement,
+ * so the guidance text has to carry it". That reading cost us the September
+ * 2026 report: two sentences in a row ended in `잠급니다`, the machine layer
+ * passed the file, and a human caught it on the published page. Identical
+ * final 어절 in consecutive sentences needs no judgement at all — it is a
+ * string comparison — so it belongs here, where it blocks, rather than in an
+ * instruction nobody re-reads.
+ *
+ * Deliberately narrow to keep the false-positive rate at zero on our own
+ * corpus: the two 어절 must match exactly, run at least three characters, and
+ * close a sentence. Near-misses (`막습니다` after `잠급니다`) are a judgement
+ * call and stay with the cohesion review.
+ */
+function repeatedEndings(lines, budget) {
+  if (budget <= 0) return [];
+  const out = [];
+  // Sentences are collected with the line they end on, so a finding still
+  // points the model at a line it can jump to.
+  const sentences = [];
+  let buf = '';
+  let startLine = 1;
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    // Headings, list markers and table rows are labels, not flowing prose.
+    if (/^\s*(?:#|\||[-*+]\s|\d+\.\s|>)/.test(raw)) { buf = ''; continue; }
+    // Structured data (YAML keys, JSON fields, front matter) holds independent
+    // values that happen to sit on neighbouring lines. Joining them invents
+    // sentence adjacency that no reader ever experiences.
+    if (/^\s*["'\w.-]+\s*:\s/.test(raw) || /^\s*---\s*$/.test(raw)) { buf = ''; continue; }
+    if (!buf) startLine = i + 1;
+    buf += (buf ? ' ' : '') + raw.trim();
+    const parts = buf.split(/(?<=[.!?])\s+/);
+    buf = /[.!?]\s*$/.test(raw.trim()) ? '' : parts.pop() || '';
+    for (const p of parts) sentences.push({ text: p, line: i + 1, startLine });
+    if (!buf) startLine = i + 2;
+  }
+
+  const tailOf = (s) => {
+    const m = String(s).trim().replace(/[.!?]+$/, '').match(/([가-힣]+)$/);
+    const t = m ? m[1] : '';
+    // Only verb/adjective endings count; a sentence closing on a noun is
+    // already covered by the nominal-ending rule.
+    if (!/다$/.test(t) || t.length < 3) return '';
+    // Existential, negative and copular closers carry no lexical content, so
+    // two of them in a row is ordinary Korean, not a repetition the writer
+    // should fix. Measured on 272 Korean files: without this stoplist the rule
+    // fires 74 times and nearly all of it is this class.
+    if (AUXILIARY_ENDING.test(t) || AUXILIARY_TAIL.test(t)) return '';
+    return t;
+  };
+
+  for (let i = 1; i < sentences.length && out.length < budget; i++) {
+    const a = tailOf(sentences[i - 1].text);
+    const b = tailOf(sentences[i].text);
+    if (a && a === b) {
+      out.push({
+        line: sentences[i].line,
+        rule: '종결 반복',
+        hit: a,
+        fix: '앞 문장과 같은 서술어로 끝납니다. 한쪽을 다른 서술어로 바꾸거나 두 문장을 합칩니다',
+      });
+    }
+  }
+  return out;
+}
+
 /** Pull the text a Write/Edit/MultiEdit call just put on disk. */
 function writtenTextOf(toolName, toolInput) {
   if (!toolInput || typeof toolInput !== 'object') return null;
@@ -260,6 +349,37 @@ function writtenTextOf(toolName, toolInput) {
   return null;
 }
 
+/**
+ * Files a shell command just wrote.
+ *
+ * Write is not the only way Korean reaches disk. A heredoc, a `tee`, a `sed -i`
+ * or a generator script puts the same prose in the same file, and a subagent
+ * that was handed Bash but not Write reaches for `cat > file` as its first
+ * choice. Matching only the file-editing tools therefore exempted exactly the
+ * artifacts produced by delegated work.
+ *
+ * Only redirection targets are recognised, never the command body: the body is
+ * shell, and linting shell would flag every Korean string in an echo. The file
+ * is read back from disk afterwards, so whatever the command actually produced
+ * is what gets checked.
+ */
+function writtenPathsOfBash(command) {
+  if (typeof command !== 'string' || !command) return [];
+  const out = new Set();
+  const add = (p) => {
+    if (!p) return;
+    const clean = p.replace(/^["']|["']$/g, '');
+    if (clean && !clean.startsWith('/dev/') && !/[*?]/.test(clean)) out.add(clean);
+  };
+  // `> file`, `>> file` — the redirection that covers heredocs and echo alike.
+  for (const m of command.matchAll(/(?<![0-9&])>>?\s*("[^"]+"|'[^']+'|[^\s|&;<>()]+)/g)) add(m[1]);
+  // `tee file`, `tee -a file`
+  for (const m of command.matchAll(/\btee\b(?:\s+-\w+)*\s+("[^"]+"|'[^']+'|[^\s|&;<>()]+)/g)) add(m[1]);
+  // In-place edits name their target at the end of the argument list.
+  for (const m of command.matchAll(/\b(?:sed|perl)\b[^|;&]*?\s-\w*i\w*\b[^|;&]*?\s("[^"]+"|'[^']+'|[^\s|&;<>()]+)\s*(?:$|[|;&])/g)) add(m[1]);
+  return [...out];
+}
+
 /**
  * Full check for one PostToolUse payload. Returns null when there is nothing to
  * say, which is the common case and must stay cheap.
@@ -268,6 +388,9 @@ function lintToolUse(context, { scope = 'all' } = {}) {
   if (!context) return null;
   const toolName = context.tool_name;
   const toolInput = context.tool_input;
+
+  if (toolName === 'Bash') return lintBashWrites(toolInput, scope);
+
   const filePath = toolInput && typeof toolInput.file_path === 'string' ? toolInput.file_path : '';
   if (!isLintTarget(filePath, scope)) return null;
 
@@ -282,6 +405,37 @@ function lintToolUse(context, { scope = 'all' } = {}) {
   return { filePath, findings };
 }
 
+/**
+ * Check the files a Bash call redirected into. Reads from disk rather than from
+ * the command text, because the command is a recipe and only the result is
+ * prose. A path that does not exist, is unreadable, or is too large to be
+ * authored prose is skipped in silence: this runs after every shell command, so
+ * it must cost nothing in the overwhelmingly common case.
+ */
+const BASH_LINT_MAX_BYTES = 512 * 1024;
+
+function lintBashWrites(toolInput, scope) {
+  const command = toolInput && typeof toolInput.command === 'string' ? toolInput.command : '';
+  const paths = writtenPathsOfBash(command).filter((p) => isLintTarget(p, scope));
+  if (paths.length === 0) return null;
+
+  const fs = require('node:fs');
+  for (const p of paths) {
+    let text;
+    try {
+      const st = fs.statSync(p);
+      if (!st.isFile() || st.size > BASH_LINT_MAX_BYTES) continue;
+      text = fs.readFileSync(p, 'utf8');
+    } catch {
+      continue;
+    }
+    if (!hasKorean(text)) continue;
+    const findings = lintKoreanText(isHtmlFile(p) ? stripHtml(text) : text, { code: !isProseFile(p) });
+    if (findings.length > 0) return { filePath: p, findings };
+  }
+  return null;
+}
+
 /** Render findings as the message handed back to the model. */
 function formatFindings(filePath, findings) {
   const head = `[korean-style] ${filePath} 에 문체 규약 위반 ${findings.length}건이 있습니다. 파일을 고친 뒤 계속하십시오.`;
@@ -293,11 +447,13 @@ function formatFindings(filePath, findings) {
 module.exports = {
   METAPHOR_LEXICON,
   isLintTarget,
+  OPT_OUT_MARKER,
   isProseFile,
   isHtmlFile,
   stripHtml,
   lintKoreanText,
   writtenTextOf,
   lintToolUse,
+  writtenPathsOfBash,
   formatFindings,
 };