hanlint 0.0.18 → 0.0.19

package/data/translationese.json

@@ -3,112 +3,111 @@
     {
       "pattern": "에 있어서",
       "fix": "에서",
-      "why": "번역투다. `분야에 있어서` 는 `분야에서` 다",
+      "why": "번역투다. `분야에 있어서`는 `분야에서`로 쓴다",
       "source": "urimal.org 김민지 2020"
     },
     {
       "pattern": "에 위치해 있",
       "fix": "에 있",
-      "why": "번역투다. `서울에 위치해 있다` 는 `서울에 있다` 다",
+      "why": "번역투다. `서울에 위치해 있다`는 `서울에 있다`로 쓴다",
       "source": "egowriting 번역투 고치기"
     },
     {
       "pattern": "에 위치하",
       "fix": "에 있",
-      "why": "번역투다. `평창에 위치하고 있습니다` 는 `평창에 있습니다` 다",
+      "why": "번역투다. `평창에 위치하고 있습니다`는 `평창에 있습니다`로 쓴다",
       "source": "egowriting 번역투 고치기"
     },
     {
-      "pattern": "([가-힣])로부터",
-      "fix": "$1에게",
-      "why": "번역투다. `상사로부터 인정받다` 는 `상사에게 인정받다` 다. 출발점이 장소면 `에서` 다",
+      "pattern": "(?<=[가-힣])로부터",
+      "why": "번역투다. 받는 사람이면 `에게`, 출발점이면 `에서`로 쓴다. `상사로부터 인정받다`는 `상사에게 인정받다`로, `부산으로부터 왔다`는 `부산에서 왔다`로 쓴다",
       "source": "egowriting 번역투 고치기"
     },
     {
       "pattern": "음에도 불구하고",
       "fix": "지만",
-      "why": "번역투다. `늦었음에도 불구하고` 는 `늦었지만` 이다",
+      "why": "번역투다. `늦었음에도 불구하고`는 `늦었지만`으로 쓴다",
       "source": "egowriting 번역투 고치기"
     },
     {
       "pattern": "에도 불구하고",
-      "why": "번역투다. `지만` 이나 `는데도` 로 푼다",
+      "why": "번역투다. `-지만`이나 `-는데도`로 풀어 쓴다",
       "source": "egowriting 번역투 고치기"
     },
     {
       "pattern": "([가-힣])(?:을|를) 통해(?:서)?",
-      "why": "through 의 직역이다. `밤샘 공부를 통해` 는 `밤샘 공부로` 다. 수단이면 `로`, 경로면 `거쳐` 다",
+      "why": "영어 through를 그대로 옮긴 말이다. `밤샘 공부를 통해` 대신 `밤샘 공부로`라고 쓴다. 수단이면 `로`, 경로면 `거쳐`를 쓴다",
       "source": "한빛미디어 번역투 TOP 12, im-not-ai A-2"
     },
     {
       "pattern": "에 의(?:해|하여|해서)",
-      "why": "by 피동의 직역이다. 한 것을 주어로 세워 능동으로 쓴다. `보육원에 의해 보호되었다` 는 `보육원이 보호했다` 다",
+      "why": "영어 수동태의 by를 그대로 옮긴 말이다. 행동한 쪽을 주어로 세워 능동으로 쓴다. `보육원에 의해 보호되었다`는 `보육원이 보호했다`로 쓴다",
       "source": "urimal.org 김민지 2020"
     },
     {
       "pattern": "(?:으)?로 인(?:해|하여)",
-      "why": "번역투다. `국민투표로 인하여 결정` 은 `국민투표로 결정` 이다. 원인이면 `때문에` 다",
+      "why": "번역투다. `국민투표로 인하여 결정`은 `국민투표로 결정`으로 쓴다. 원인이면 `때문에`를 쓴다",
       "source": "urimal.org 김민지 2020"
     },
     {
       "pattern": "에 대(?:해|하여|해서)",
-      "why": "번역투다. `물음에 대해 답하다` 는 `물음에 답하다` 다. 목적어로 되돌린다",
+      "why": "번역투다. `물음에 대해 답하다`는 `물음에 답하다`로 쓴다. 목적어로 되돌린다",
       "source": "urimal.org 김민지 2020"
     },
     {
       "pattern": "에 관(?:해|하여|해서)",
-      "why": "번역투다. 목적어나 `~은` 으로 되돌린다",
+      "why": "번역투다. 목적어나 `~은`으로 되돌린다",
       "source": "urimal.org 김민지 2020"
     },
     {
       "pattern": "에 대한",
-      "why": "번역투다. `문제점에 대한 이해` 는 `문제점을 아는 것` 이다. 목적어로 되돌린다",
+      "why": "번역투다. `문제점에 대한 이해`는 `문제점을 아는 것`으로 쓴다. 목적어로 되돌린다",
       "source": "urimal.org 김민지 2020"
     },
     {
       "pattern": "에 관한",
-      "why": "번역투다. `설정에 관한 설명` 은 `설정 설명` 이다. 목적어나 `~은` 으로 되돌린다",
+      "why": "번역투다. `설정에 관한 설명`은 `설정 설명`으로 쓴다. 목적어나 `~은`으로 되돌린다",
       "source": "urimal.org 김민지 2020"
     },
     {
       "pattern": "(?:을|를) 위(?:해|하여|해서)",
-      "why": "번역투다. `여행을 가기 위해` 는 `여행 가려고` 다",
+      "why": "번역투다. `여행을 가기 위해`는 `여행 가려고`로 쓴다",
       "source": "urimal.org 김민지 2020"
     },
     {
       "pattern": "(?:을|를) 필요로 하",
-      "why": "번역투다. `사회가 필요로 하는 것` 은 `사회가 필요한 것` 이다",
+      "why": "번역투다. `사회가 필요로 하는 것`은 `사회가 필요한 것`으로 쓴다",
       "source": "서울신문 바른 말글 2018"
     },
     {
       "pattern": "하는 중(?:이다|입니다|이었다)",
-      "why": "진행형 직역이다. `도착하는 중입니다` 는 `도착합니다` 다",
+      "why": "영어 진행형을 그대로 옮긴 말이다. `도착하는 중입니다`는 `도착합니다`로 쓴다",
       "source": "egowriting 번역투 고치기"
     },
     {
       "pattern": "[가-힣](?:으로의|에의) ",
-      "why": "전치사구를 명사화한 번역투다. `성공으로의 길` 은 `성공에 이르는 길` 이다",
+      "why": "전치사구를 명사로 만든 번역투다. `성공으로의 길`은 `성공에 이르는 길`로 쓴다",
       "source": "국립국어원 새국어생활 1990"
     },
     {
       "pattern": "에 다름 아니",
-      "why": "일본어 직역이다. `바로 ~이다` 로 쓴다",
+      "why": "일본어를 그대로 옮긴 말이다. `바로 ~이다`로 쓴다",
       "source": "부산일보 바른말 광 2018"
     },
     {
       "pattern": "(?:이|가) 가능(?:하다|합니다|해진다)",
-      "why": "possible 의 직역이다. `스킵이 가능하다` 는 `스킵할 수 있다` 다",
+      "why": "영어 possible을 그대로 옮긴 말이다. `스킵이 가능하다`는 `스킵할 수 있다`로 쓴다",
       "source": "나무위키 번역체 문장"
     },
     {
       "pattern": "하게 만들(?:었|었습|었다|다)",
-      "why": "make 사동의 직역이다. `나를 행복하게 만들었다` 는 `난 그 일로 행복했다` 다",
+      "why": "영어 make를 쓴 사동문을 그대로 옮긴 말이다. `나를 행복하게 만들었다`는 `난 그 일로 행복했다`로 쓴다",
       "source": "hanmal 번역투 정리 2011"
     },
     {
       "pattern": "(?:을|를) 가지고 있",
-      "why": "have 의 직역이다. `목소리를 가지고 있다` 는 `목소리가 좋다`, `책을 가지고 있다` 는 `책이 있다` 다",
-      "source": "김순영 2012 (이근희 2005 재인용)"
+      "why": "영어 have를 그대로 옮긴 말이다. `목소리를 가지고 있다`는 `목소리가 좋다`로, `책을 가지고 있다`는 `책이 있다`로 쓴다",
+      "source": "김순영 2012, 이근희 2005 재인용"
     }
   ]
 }

package/data/usageCounts.report.json

@@ -1644,7 +1644,7 @@
    "(?<![가-힣])잔고": 165
   },
   "redundantPair": {
-   "(?:또)?다시 재(?!(?:력|주|산|물|화|벌|원|무|정|능|치|간|료|목|질|난|해|앙|고|판){조사})([가-힣]+)": 12,
+   "(?:또)?다시 재(?!(?:력|주|산|물|화|벌|원|무|정|능|치|간|료|목|질|난|해|앙|고|판){조사})(?!(?:거나|면|서|며|니|는|어|어서|었다|야|요|다|도|지)(?![가-힣]))([가-힣]+)": 12,
    "결실을 맺": 25,
    "과반수 이상": 94,
    "남은 여생": 1,
@@ -1656,8 +1656,8 @@
    "(?:을|를) 위(?:해|하여|해서)": 3184,
    "(?:을|를) 필요로 하": 1196,
    "(?:이|가) 가능(?:하다|합니다|해진다)": 2099,
+   "(?<=[가-힣])로부터": 3184,
    "([가-힣])(?:을|를) 통해(?:서)?": 3171,
-   "([가-힣])로부터": 3184,
    "[가-힣](?:으로의|에의) ": 1906,
    "에 관(?:해|하여|해서)": 1676,
    "에 관한": 3189,

package/data/version.json

@@ -1 +1 @@
-{"version": "0.0.18"}
+{"version": "0.0.19"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hanlint",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "한국어 글 검사기. Korean prose linter for Markdown: translationese, noun piles, double passives, weak structure. Zero dependencies",
   "type": "module",
   "bin": {

package/src/analysis/grammar/ending.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 파이썬 `analysis/grammar/ending.py`와 `predicate.py`의 투영. 종결 서술어를 풀고 세 문체로 짠다. */
+/** 파이썬 `analysis/grammar/ending.py`와 `predicate.py`를 옮긴 것. 종결 서술어를 풀고 세 문체로 짠다. */
 import { loadLines } from "../../data/load.js";
 import * as hangul from "./hangul.js";
 

package/src/analysis/grammar/hangul.js

@@ -1,6 +1,6 @@
 // @ts-check
 /**
- * 한글 음절의 자모 산술. 파이썬 `analysis/grammar/hangul.py` 의 투영이다. 표 대신 산술로 하는 까닭은 그 파일이 소유한다.
+ * 한글 음절의 자모 산술. 파이썬 `analysis/grammar/hangul.py`를 옮긴 것이다. 표 대신 산술로 하는 까닭은 그 파일에 적었다.
  */
 
 export const BASE = 0xac00;
@@ -31,7 +31,7 @@ export const EU = 18;
 export const UI = 19;
 export const IH = 20;
 
-// 종성 자리 번호 가운데 형태 층이 이름으로 부르는 것.
+// 종성 자리 번호 가운데 형태 부분이 이름으로 부르는 것.
 export const NONE = 0;
 export const GIYEOK = 1;
 export const NIEUN = 4;
@@ -44,7 +44,7 @@ export const SSANGSIOT = 20;
 export const IEUNG = 21;
 export const HIEUT = 27;
 
-/** 양성 모음. 이 모음 뒤에는 `아` 가 붙고 나머지에는 `어` 가 붙는다. */
+/** 양성 모음. 이 모음 뒤에는 `아`가 붙고 나머지에는 `어`가 붙는다. */
 export const BRIGHT = new Set([A, OH, YA, YO, WA]);
 
 /** @param {string} ch */
@@ -88,7 +88,7 @@ export function withVowel(ch, vowel) {
   return join(initial, vowel, final);
 }
 
-/** 낱말의 마지막 한글 음절. 없으면 null. @param {string} word */
+/** 단어의 마지막 한글 음절. 없으면 null. @param {string} word */
 export function lastSyllable(word) {
   return word && isSyllable(word[word.length - 1]) ? word[word.length - 1] : null;
 }

package/src/analysis/grammar/josa.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 파이썬 `analysis/grammar/josa.py`의 투영. 받침에 따라 조사 꼴을 맞춘다. */
+/** 파이썬 `analysis/grammar/josa.py`를 옮긴 것. 받침에 따라 조사 꼴을 맞춘다. */
 import * as hangul from "./hangul.js";
 
 const PAIRS = [

package/src/analysis/grammar/register.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 파이썬 `analysis/grammar/register.py`의 투영. 글의 문체를 판별하고 문장 끝 서술어를 맞춘다. */
+/** 파이썬 `analysis/grammar/register.py`를 옮긴 것. 글의 문체를 판별하고 문장 끝 서술어를 맞춘다. */
 import * as hangul from "./hangul.js";
 import { HAEYO, HANDA, HAPNIDA, REGISTERS, parsePredicate, render } from "./ending.js";
 

package/src/analysis/grammar/voice.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 파이썬 `analysis/grammar/voice.py`의 투영. 확정되는 사동과 피동의 겹만 분해한다. */
+/** 파이썬 `analysis/grammar/voice.py`를 옮긴 것. 확정되는 사동과 피동의 겹만 분해한다. */
 import { loadLines } from "../../data/load.js";
 
 export const PASSIVE = "피동";

package/src/analysis/index.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
- * 분석 층. 문장 분리와 어절 판정을 표층 (어절과 꼬리 사전) 으로 한다. 형태소 분석기는 없다. 파이썬 analysis/__init__.py 와 같다.
- * 지문이 필요로 하는 것은 넷이다. splitSentences, euiCount 와 euiAdjacent, longestNounRun, doublePassives.
+ * 분석 부분. 문장 분리와 어절 판정을 글자 모양(어절과 꼬리 사전)만으로 한다. 형태소 분석기는 없다. 파이썬 analysis/__init__.py와 같다.
+ * 글 분석에 필요한 것은 넷이다. splitSentences, euiCount와 euiAdjacent, longestNounRun, doublePassives.
  */
 export { splitSentences } from "./splitSentences.js";
 export { doublePassives, doublePassiveSpans, euiAdjacent, euiCount, longestNounRun, nounRuns } from "./tokenize.js";

package/src/analysis/josa.js

@@ -1,2 +1,2 @@
-// 이전 deep path 호환. 정본 투영은 grammar/josa.js다.
+// 이전 deep path 호환. 실제 구현은 grammar/josa.js에 있다.
 export * from "./grammar/josa.js";

package/src/analysis/splitSentences.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 종결 부호 뒤 공백에서 문장을 나눈다. 파이썬 analysis/splitSentences.py 와 같다. */
+/** 종결 부호 뒤 공백에서 문장을 나눈다. 파이썬 analysis/splitSentences.py와 같다. */
 
 const TERMINAL = /[.?!]+\s+(?=\S)/g;
 const ABBREVIATION = /(?:^|[^A-Za-z])[A-Za-z]$/;

package/src/analysis/tokenize.js

@@ -1,6 +1,6 @@
 // @ts-check
 /**
- * 어절 단위 근사. 조사와 어미 꼬리 사전으로 명사 어절을 가려낸다. 파이썬 analysis/tokenize.py 와 같은 판정이다.
+ * 어절 단위 어림. 조사와 어미 꼬리 사전으로 명사 어절을 가려낸다. 파이썬 analysis/tokenize.py와 같은 판정이다.
  * 띄어 쓴 조사와 계사는 앞 어절에 붙은 것으로, 영문 어절 연속은 한 덩어리로, 수사와 바로 뒤 단위는 수량으로 본다.
  */
 import { loadLines } from "../data/load.js";
@@ -9,7 +9,7 @@ import { splitWords, stripChars } from "../text.js";
 const HANGUL = /[가-힣]/;
 const HANGUL_WORD = /^[가-힣]+$/;
 const WORD_CHARS = /^[가-힣A-Za-z0-9]+$/;
-/** 관형격 조사 의. 영문과 숫자 뒤 (API의, 600MiB의) 와 닫는 괄호 뒤 (L7(HTTP)의) 도 센다. 파이썬 tokenize.py 와 같다. */
+/** 관형격 조사 `의`. 영문과 숫자 뒤(`API의`, `600MiB의`)와 닫는 괄호 뒤(`L7(HTTP)의`)도 센다. 파이썬 tokenize.py와 같다. */
 const GENITIVE = /([가-힣A-Za-z0-9]+|\))의(?=[\s,.)\]]|$)/g;
 const SPACED_GENITIVE = /(?<=\s)의(?=\s)/g;
 export const COPULA = /^(?:이(?:고|며|다|라|란|면|라서|므로|지만|어서|었다|었고)|인|인데|입니다|였다)$/;
@@ -77,8 +77,8 @@ export function inNouns() {
 }
 
 /**
- * `도구인`, `규모인` 처럼 명사에 계사 관형형 인 이 붙은 어절. 서술어라 명사 나열을 끊는다. 어간이 두 음절 이상일 때만이고
- * 외국인 같은 세 음절 명사는 data/inNouns.txt 가 뺀다. 파이썬 tokenize.py 와 같다.
+ * `도구인`, `규모인`처럼 명사에 계사 관형형 `인`이 붙은 어절. 서술어라 명사 나열을 끊는다. 어간이 두 음절 이상일 때만이고
+ * 외국인 같은 세 음절 명사는 data/inNouns.txt가 뺀다. 파이썬 tokenize.py와 같다.
  * @param {string} core
  */
 export function isCopulaAdnominal(core) {
@@ -126,12 +126,12 @@ export function isBareNoun(core) {
 }
 
 /**
- * 명사 어절 연속의 최대 길이. 의존명사와 관형사와 부사 (`수`, `몇`, `직접`) 는 조사도 어미도 안 붙어
- * 표층으로는 명사로 보이지만 명사 쌓기의 재료가 아니다. data/nonNouns.txt 가 그 목록이고 연속을 끊는다.
+ * 명사 어절 연속의 최대 길이. 의존명사와 관형사와 부사(`수`, `몇`, `직접`)는 조사도 어미도 안 붙어
+ * 글자 모양으로는 명사로 보이지만 명사 쌓기의 재료가 아니다. data/nonNouns.txt가 그 목록이고 연속을 끊는다.
  * @param {string} text
  */
 /**
- * 명사 어절 연속마다 [어절들, 센 길이]. 뜻은 파이썬 analysis/tokenize.py 의 nounRuns 가 소유한다.
+ * 명사 어절 연속마다 [어절들, 센 길이]. 뜻은 파이썬 analysis/tokenize.py의 nounRuns가 정한다.
  * 수사와 단위는 세지도 끊지도 않고 어절에도 안 넣는다. 잇달은 영문 어절은 하나로 센다.
  * @param {string} text @returns {[string[], number][]}
  */
@@ -167,14 +167,14 @@ export function nounRuns(text) {
   return runs;
 }
 
-/** 명사 어절 연속의 최대 길이. nounRuns 의 센 길이 가운데 가장 큰 것. @param {string} text */
+/** 명사 어절 연속의 최대 길이. nounRuns의 센 길이 가운데 가장 큰 것. @param {string} text */
 export function longestNounRun(text) {
   let longest = 0;
   for (const [, length] of nounRuns(text)) longest = Math.max(longest, length);
   return longest;
 }
 
-/** 관형격 조사 의 가 붙은 자리 [시작, 끝]. 정의, 회의 처럼 의 로 끝나는 낱말은 빼고 띄어 쓴 의 는 넣는다. @param {string} text @returns {[number, number][]} */
+/** 관형격 조사 `의`가 붙은 곳 [시작, 끝]. `정의`, `회의`처럼 `의`로 끝나는 단어는 빼고 띄어 쓴 `의`는 넣는다. @param {string} text @returns {[number, number][]} */
 export function genitiveSpans(text) {
   /** @type {[number, number][]} */
   const spans = [];
@@ -185,13 +185,13 @@ export function genitiveSpans(text) {
   return spans.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
 }
 
-/** 의 로 끝나는 어절 둘이 붙어 있는가 (회사의 팀의). 사이가 공백뿐이어야 한다. @param {string} text */
+/** `의`로 끝나는 어절 둘이 붙어 있는가(`회사의 팀의`). 사이가 공백뿐이어야 한다. @param {string} text */
 export function euiAdjacent(text) {
   const spans = genitiveSpans(text);
   return spans.some((span, index) => index > 0 && /^\s+$/.test(text.slice(spans[index - 1][1], span[0])));
 }
 
-/** 관형격 조사 의 의 수. @param {string} text */
+/** 관형격 조사 `의`의 수. @param {string} text */
 export function euiCount(text) {
   return genitiveSpans(text).length;
 }
@@ -220,7 +220,7 @@ export function doublePassivePattern() {
   return passivePattern;
 }
 
-/** 이중 피동의 [시작, 끝, `되어지` 꼴 표층형]. @param {string} text @returns {[number, number, string][]} */
+/** 이중 피동의 [시작, 끝, `되어지` 꼴로 쓴 글자]. @param {string} text @returns {[number, number, string][]} */
 export function doublePassiveSpans(text) {
   return [...text.matchAll(doublePassivePattern())].map((match) => {
     const start = /** @type {number} */ (match.index);
@@ -228,7 +228,7 @@ export function doublePassiveSpans(text) {
   });
 }
 
-/** 이중 피동의 표층형을 `되어지` 꼴로. @param {string} text */
+/** 이중 피동의 글자를 `되어지` 꼴로. @param {string} text */
 export function doublePassives(text) {
   return doublePassiveSpans(text).map(([, , surface]) => surface);
 }

package/src/baseline/store.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
- * 이미 있는 지적을 잠가 두고 새로 생긴 것만 막는다. 파이썬 `hanlint/baseline/store.py` 의 투영이다.
- * 왜 줄 번호가 아니라 글자인지, 왜 사람이 읽는 꼴인지는 그 파일의 docstring 이 정본이다.
+ * 이미 있는 지적을 baseline 파일에 적어 두고 새로 생긴 지적만 막는다. 파이썬 `hanlint/baseline/store.py`를 옮긴 것이다.
+ * 왜 줄 번호가 아니라 글자인지, 왜 사람이 읽는 형식인지는 그 파일의 docstring에 있다.
  */
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, posix, relative, resolve, sep } from "node:path";
@@ -20,7 +20,7 @@ export function keyOf(finding) {
   return `${finding.rule}\u0000${normalizeQuote(finding.quote)}`;
 }
 
-/** 잠금 파일이 있는 폴더 기준의 상대 경로. @param {string} path @param {string | null} target */
+/** baseline 파일이 있는 폴더에서 본 상대 경로. @param {string} path @param {string | null} target */
 export function pathKey(path, target) {
   if (!target || !path || path.startsWith("<")) return path;
   return relative(dirname(resolve(target)), resolve(path)).split(sep).join(posix.sep);
@@ -44,7 +44,7 @@ export class Baseline {
     return (this.locked.get(pathKey(path, this.source)) ?? new Set()).has(keyOf(finding));
   }
 
-  /** 잠기지 않은 지적만 남긴다. @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
+  /** baseline 파일에 없는 지적만 남긴다. @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
   keep(path, findings) {
     return findings.filter((finding) => !this.isLocked(path, finding));
   }
@@ -60,7 +60,7 @@ export function build(results, target = null) {
   return new Baseline(locked, target ? resolve(target) : null);
 }
 
-/** 사람이 읽고 리뷰하는 꼴. 정렬해 담아 같은 입력에 같은 파일이 나온다. @param {Baseline} baseline */
+/** 사람이 읽고 리뷰하는 형식. 정렬해 담아 같은 입력에 같은 파일이 나온다. @param {Baseline} baseline */
 export function render(baseline) {
   /** @type {Record<string, {rule: string, quote: string}[]>} */
   const files = {};
@@ -80,7 +80,7 @@ export function render(baseline) {
 /** @param {string} text @param {string | null} [source] */
 export function parse(text, source = null) {
   const data = JSON.parse(text);
-  if (data.version !== VERSION) throw new Error(`모르는 baseline 판 ${data.version}. hanlint baseline 으로 다시 만든다`);
+  if (data.version !== VERSION) throw new Error(`지원하지 않는 baseline 버전: ${data.version}. hanlint baseline으로 다시 만든다`);
   /** @type {Map<string, Set<string>>} */
   const locked = new Map();
   for (const [path, entries] of Object.entries(data.files ?? {})) {
@@ -92,7 +92,7 @@ export function parse(text, source = null) {
 /** @param {string} path */
 export function load(path) {
   if (!existsSync(path)) {
-    const error = /** @type {NodeJS.ErrnoException} */ (new Error(`${path} 를 찾지 못했다`));
+    const error = /** @type {NodeJS.ErrnoException} */ (new Error(`파일을 찾지 못했다: ${path}`));
     error.code = "ENOENT";
     error.path = path;
     throw error;
@@ -100,7 +100,7 @@ export function load(path) {
   return parse(readFileSync(path, "utf-8"), resolve(path));
 }
 
-/** 지금 글에 더 없는 잠금을 지운다. @param {Baseline} baseline @param {Map<string, import("../rules/finding.js").Finding[]>} results */
+/** 지금 글에 더는 없는 지적을 baseline 파일에서 지운다. @param {Baseline} baseline @param {Map<string, import("../rules/finding.js").Finding[]>} results */
 export function prune(baseline, results) {
   const kept = new Map(baseline.locked);
   for (const [path, findings] of results) {

package/src/cli/help.js

@@ -2,14 +2,14 @@
 /** 첫 화면 다음에 보이는 작업 흐름 중심 도움말. */
 
 export function rootHelp() {
-  return `hanlint: 한국어 마크다운에서 반복되는 결함과 계약 위반을 결정적으로 찾는다
+  return `hanlint: 한국어 글에서 규칙으로 잡을 수 있는 잘못을 찾는다
 
 일상 검사
   hanlint 글.md                         글을 검사한다
   hanlint fix 글.md                     안전한 고침만 적용한다
-  hanlint hook                          AI에게 쓰기 전 작법서를 싣고, 저장한 마크다운을 같은 턴에 검사한다
+  hanlint hook                          AI가 쓰기 전에 글쓰기 지침을 넣어 주고, 저장한 마크다운을 같은 턴에 검사한다
 
-요구사항 잠금
+요구사항 고정
   hanlint contract init 글.md --reader "독자" --goal "목표" --outline h2
   hanlint check contract.json 글.md --format text
   hanlint verify-patch contract.json 글.md patch.json
@@ -17,20 +17,20 @@ export function rootHelp() {
 설정과 이해
   hanlint init                           설정 파일을 만든다
   hanlint doctor                         적용 설정과 꺼진 규칙을 본다
-  hanlint rules                          규칙을 부류별로 본다
-  hanlint explain <규칙>                 규칙의 이유와 본보기를 본다
+  hanlint rules                          규칙을 카테고리별로 본다
+  hanlint explain <규칙>                 규칙의 이유와 예시를 본다
   hanlint patterns --rule <규칙>         다시 쓸 문장 틀을 본다
   hanlint spec --preset <종류> --chars 800
-                                         쓰기 전 숫자 사양을 만든다
-  hanlint primer --preset <종류>         쓰기 전에 규칙의 고치는 법과 본보기를 한 장으로 본다
-  hanlint sheet src/ --preset screen    소스의 화면 글을 표 하나로 내보낸다. 고친 표는 sheet apply 로 되돌려 쓴다
-  hanlint usage "낱말 낱말"             그 종류의 실제 글에서 낱말이 쓰인 문장을 본다. 색인은 usage build 가 만든다
+                                         쓰기 전에 볼 스펙을 만든다
+  hanlint primer --preset <종류>         쓰기 전에 규칙의 고치는 법과 예시를 한 장으로 본다
+  hanlint sheet src/ --preset screen    소스의 화면 글을 표 하나로 내보낸다. 고친 표는 sheet apply로 원본에 반영한다
+  hanlint usage "단어 단어"             그 종류의 실제 글에서 단어가 쓰인 문장을 본다. 색인은 usage build가 만든다
 
 추가 명령
   baseline, print
   Python 전용: audit, map, watch, profile, coverage, diff, learn, packet,
   guard, arena, blueprint, evidence, entailment, terms
 
-자세한 옵션은 hanlint <명령> --help 로 본다. 폴더를 주면 그 아래 마크다운을 검사한다.
-종료 코드: 0 error 없음, 1 error 있음, 2 입력이나 설정 문제. 좋은 글인지는 판정하지 않는다.`;
+명령마다의 옵션은 README의 명령 표에 있다. 폴더를 주면 그 아래 마크다운을 검사한다.
+종료 코드: 0은 오류 없음, 1은 오류 있음, 2는 입력이나 설정 문제. 좋은 글인지는 판정하지 않는다.`;
 }