leerness 1.36.72 → 1.36.74

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 1.36.74 — 2026-07-25 — codex 9차 홀리스틱 헌트: 미점검 표면 6건 수정 (P1 3·P2 3)
+
+표면 회전 원칙에 따라 최근 라운드가 비추지 않은 사용자 데이터 표면(MCP 프로토콜·memory archive/restore·.leerness state·api-skill)을 헌트. 8건 보고 중 자체 재현 확정 6건 수정.
+
+- **P1 `.leerness/state.json` 스키마 무효 통과**: 파싱은 되지만 형태가 무효인 파일(`{}`)이 손상 가드를 통과해 runCounter 를 0 으로 되돌리고 **기존 run 을 덮어썼다**(실측 original-goal → replacement-goal). 형태 검증도 fail-closed — 단 runs/ 가 비어 있으면 관대(없는 데이터를 지킬 필요 없음).
+- **P1 memory restore 가 활성 중복 생성**: drop → 같은 제목 재생성 → restore 시 동일 제목 2건이 조용히 생겨 어느 쪽이 진짜인지 알 수 없었다. 충돌 기본 거부(`restore_conflict`) + `--force` 우회 — 복원은 되살리기지 복제가 아니다. archive 는 그대로 두어 재시도 가능.
+- **P1 api-skill skeleton 경로 id 충돌**: fetch 경로에만 있던 충돌 해소기가 skeleton 폴백엔 없어 URL 이 다른데 slug 가 같으면 앞 항목을 통째로 덮어썼다(alpha URL·방향 소실 실측). 동일 규칙 공유.
+- **P2 MCP 마지막 요청 유실**: 개행 없이 끝난 마지막 JSON-RPC 요청이 EOF 에서 조용히 버려졌다(실측: 무응답 exit 0). EOF 시 잔여 버퍼도 동일 경로로 처리.
+- **P2 손상 api-skill 이 정상처럼 노출**: frontmatter 깨진 파일이 "URL 0개 정상 스킬"로 강등돼 목록에 섞이던 것 — `corrupt`/`corruptCount` 표기 + 텍스트 경고(로드 자체는 유지, 비파괴).
+- **P2 `api-skill add --json` 계약 위반**(자체 관측): 사람용 진행 로그·실패 메시지가 stdout 을 오염시켜 JSON 소비자가 파싱 불가 — 진행 로그 억제 + 실패 구조화(`{ok:false, code:'fetch_failed'}`), drop/show 에러도 failJson 통일.
+- **(R-0001 검수 17회전이 제 수정의 불완전성 2건을 차단)**: ① state 형태 검증만으론 부족 — **형태는 유효하나 stale 한 runCounter**(0 < 실재 run-0001)가 여전히 기존 run 을 덮어썼다(실측). 디스크 최대 run 번호와 대조해 fail-closed. ② restore 충돌 판정이 "첫 줄 substring"이라 **날짜만 다른 논리적 중복은 통과**시키고 **같은 날 무관한 lesson·'Deploy' vs 'Deploy v2' 는 오탐 차단**했다(양쪽 실측) — 표면별 정체성(decision=title/lesson=text/plan=제목) 파싱 정확 일치로 교체. (검수 Low) 빈 api-skill 저장소도 `corruptCount` 동일 형태.
+- 미재현 이월: 잘린 UTF-8 아카이브 복원(#3)은 제 절단 변형에선 U+FFFD 미유입 — 정확한 바이트 조작 재현 후 별도 판단. MCP 티어/텔레메트리(#2)·긴 파생 id(#8)는 다음 라운드.
+- 정상 확인: MCP 잘못된 JSON(-32700)·미지 도구(-32601)·연속 요청 프레이밍·1MiB 라인, state 동시 8start/12record 무손실, 손상 state 파싱 실패 fail-closed.
+
+## 1.36.73 — 2026-07-25 — 8차 헌트 완전 종결: F12 skills-lock 정합 + F9 설계 결정
+
+8차 홀리스틱 헌트(16건)의 마지막 설계 판단 2건을 결론 — 이로써 16/16 전건 처리 완료.
+
+- **F12**: skills-lock 은 "요청 집합"이 아니라 **디스크 실재**를 기록 — `--skills all` 후 `recommended` 재init 시 9개 디렉토리가 남는데 락은 5개만 주장하던 불일치를 합집합 재생성으로 해소(실측 dirs 9 = lock 9). 스킬 제거는 하지 않음(비파괴 원칙).
+- **F9 (설계 결정)**: 초고령 KO canonical 이 en 프로젝트에 커스텀으로 오인 이월되는 것 — **자동 차감은 하지 않는다**(구판 템플릿 라인과 사용자 노트를 확신으로 구분 불가, false-DROP 이 버그·false-PRESERVE 는 무해). 대신 한글 비중 높은 이월(≥10줄·>50%) 시 Preserved 섹션에 **검토·정리 안내**를 명시해 조용한 동결을 없앤다. 안내는 멱등(재이월 안 됨), 소수 한글 커스텀·ko 프로젝트엔 무경고.
+- 검증: F12 재현 시나리오 실측, F9 순수함수 5프로브(안내/멱등/무손실/소수 무경고/ko 무경고), selftest 334, e2e +1.
+
 ## 1.36.72 — 2026-07-24 — 성장 한계 클래스 4(task list) + F16 lint 거짓 PASS 차단 — R-0001 검수 15회전
 
 - **task list --json 상한**: 기본 최신 100행 + `shown/truncated` 정직 표기(`total` 은 필터 후 전량), `--all/--limit N` 옵트인. MCP `leerness_task_list` 계약 동반 갱신(limit/all 노출+전달). 텍스트 모드 무변경(codex: HEAD 와 바이트 동일 확인).

package/README.md

@@ -122,7 +122,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.72 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.74 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### 정체성 — AI 에이전트 운영 레이어 (UR-0030)
 
@@ -176,7 +176,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.36.72는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **86개 도구**를 노출:
+Leerness v1.36.74는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **86개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -197,7 +197,7 @@ Leerness v1.36.72는 stdio JSON-RPC MCP server를 내장합니다 — Claude Cod
 `<<autonomous-loop-dynamic>>` 신호만 보내면 AI가:
 1) 다음 라운드 후보 선정 → 2) 코드 변경 → 3) 회귀 테스트 갱신 → 4) 전체 e2e 스위트 통과 → 5) npm publish + git tag → 6) main push → 7) session close → 8) 다음 라운드 예약.
 
-현재 누적: **v1.9.x → 1.36.72 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.74 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
 
 ### 성능 가이드
 
@@ -235,5 +235,5 @@ leerness release pack --close --auto-main-push
 - `.harness/session-handoff.md`: 다음 세션 인수인계 (자동 작성)
 - `.harness/lessons.md` / `decisions.md` / `rules.md`: 영구 메모리 (5 surface)
 
-Last synced by Leerness v1.36.72: 2026-07-25
+Last synced by Leerness v1.36.74: 2026-07-25
 <!-- leerness:project-readme:end -->

package/bin/leerness.js

@@ -34,7 +34,7 @@ const { CAPABILITY_SURFACE, POWERFUL_COMMANDS, ADAPTERS, REUSE_CATEGORIES, REUSE
 const { tokenizeForRank: _tokenizeForRank, expandQuery: _expandQuery, scoreHits: _scoreHits, suggestTerms: _suggestTerms } = require('../lib/search-core');  // 1.36.23: memory search 랭킹 코어(순수·0-deps)
 const { findCorruptedStateJson: _findCorruptedStateJson } = require('../lib/state-integrity');  // 1.36.1 (클린룸 리뷰 FN): .harness/*.json 상태 무결성 (audit/health/check 공유)
 
-const VERSION = '1.36.72';
+const VERSION = '1.36.74';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -525,9 +525,21 @@ function mergeReadmeSection(existing, block) {
   return _mergeReadmeSection(existing, block, README_START, README_END);
 }
 
-function skillLock(skills) {
+function skillLock(skills, root) {
+  // 1.36.73 (8차 헌트 F12): 락은 "요청 집합"이 아니라 디스크 실재를 기록 — `--skills all` 후 `recommended` 재init 시
+  //   9개 디렉토리가 남는데 락은 5개만 주장하던 불일치. 기존 설치 디렉토리(카탈로그 내장분)와 합집합.
+  //   스킬 제거는 하지 않음(비파괴 원칙 — 사용자가 쓰고 있을 수 있다).
+  const set = new Set(skills);
+  try {
+    if (root) {
+      const dir = path.join(root, '.harness', 'skills');
+      if (exists(dir)) for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (e.isDirectory() && skillCatalog[e.name]) set.add(e.name);
+      }
+    }
+  } catch {}
   const data = { leernessVersion: VERSION, updatedAt: now(), installedSkills: {} };
-  for (const s of skills) data.installedSkills[s] = skillCatalog[s] || { version: 'unknown' };
+  for (const s of [...set].sort()) data.installedSkills[s] = skillCatalog[s] || { version: 'unknown' };   // (검수 #4) 정렬 직렬화 — 동일 멤버십이면 바이트 동일(no-op 보존)
   return JSON.stringify(data, null, 2) + '\n';
 }
 
@@ -543,7 +555,7 @@ function coreFiles(root, lang = 'ko', selectedSkills = [], opts = {}) {
     '.harness/HARNESS_VERSION': VERSION + '\n',
     '.harness/LANGUAGE': lang + '\n',
     '.harness/manifest.json': JSON.stringify({ project, leernessVersion: VERSION, language: lang, installedAt: now(), minimal: !!opts.minimal }, null, 2) + '\n',
-    '.harness/skills-lock.json': skillLock(selectedSkills),
+    '.harness/skills-lock.json': skillLock(selectedSkills, root),
     '.harness/project-brief.md': fm('project-brief', ['프로젝트 목적 확인','신규 기능 판단','계획 수립'], ['프로젝트 목적 변경','사용자/범위 변경'], `# Project Brief\n\n## Project\n${project}\n\n## Purpose\n- 이 프로젝트의 목적을 실제 내용으로 업데이트하세요.\n\n## Users\n-\n\n## Success Criteria\n-\n`),
     '.harness/plan.md': fm('plan', ['작업 시작 전','새 요청 접수','범위 변경','신규 프로젝트 감지'], ['계획 추가/수정/드랍','milestone 변경','목표 변경'], `# Plan\n\n## Goal\n- 사용자 목적을 기준으로 전체 계획을 유지합니다.\n\n## Scope\n- 포함 범위를 기록합니다.\n\n## Out of Scope / Dropped\n| ID | Item | Reason | Date |\n|---|---|---|---|\n\n## Milestones\n\n### M-0001. 프로젝트 계획 정리\nStatus: planned\nProgress: 0%\n\nTasks:\n- [ ] project-brief.md를 실제 프로젝트 목적에 맞게 작성\n- [ ] context-map.md를 실제 파일 구조에 맞게 작성\n`),
     '.harness/progress-tracker.md': _canonicalProgressHeader(lang) + '\n',  // 1.9.293: _canonicalProgressHeader 단일 출처 · 1.36.63: lang 전달
@@ -6082,7 +6094,9 @@ function _loadAPISkill(root, id) {
   // 1.12.5 (15th 버그헌트 P2, UR-0017): read()(BOM strip) + CRLF/CR 정규화 — 이전 raw readFileSync 는 CRLF 파일에서 '^---\n' 불일치로 frontmatter 전부 유실(1.9.408 SKILL.md 수정 누락분). 또 fallback 에 body 추가 → _matchAPISkills 의 s.body.slice 크래시 방지.
   const content = read(fp).replace(/\r\n/g, '\n').replace(/\r/g, '\n');
   const fm = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!fm) return { id, content, urls: [], name: id, body: content };
+  // 1.36.74 (9차 헌트 #6 P2): frontmatter 가 깨진 파일(닫는 --- 누락 등)이 "URL 0개짜리 정상 스킬"로 조용히 강등돼
+  //   목록에 섞였다 — 손상 사실을 표시해 사용자가 고칠 수 있게(로드 자체는 유지, 비파괴).
+  if (!fm) return { id, content, urls: [], name: id, body: content, corrupt: true, corruptReason: 'frontmatter_unparsable' };
   const meta = {};
   fm[1].split('\n').forEach(l => {
     const m = l.match(/^(\w+):\s*(.*)$/);
@@ -6128,23 +6142,28 @@ async function apiSkillCmd(root, sub) {
   const dir = _apiSkillsDir(root);
   if (sub === 'list') {
     if (!fs.existsSync(dir)) {
-      if (has('--json')) { log(JSON.stringify({ skills: [] })); return; }
+      if (has('--json')) { log(JSON.stringify({ skills: [], corruptCount: 0 })); return; }   // (검수 Low) 빈 저장소도 동일 필드 형태
       log(dm(`(아직 API skill 없음 — leerness api-skill add <url> 으로 생성)`));
       return;
     }
     const skills = _listAPISkills(root);
+    const _corrupt = skills.filter(s => s.corrupt);   // 1.36.74 (#6): 손상 레코드를 정상처럼 보이게 두지 않는다
     if (has('--json')) {
-      log(JSON.stringify({ skills: skills.map(s => ({ id: s.id, name: s.name, urls: s.urls, captured_at: s.captured_at })) }, null, 2));
+      log(JSON.stringify({
+        skills: skills.map(s => ({ id: s.id, name: s.name, urls: s.urls, captured_at: s.captured_at, ...(s.corrupt ? { corrupt: true, corruptReason: s.corruptReason } : {}) })),
+        corruptCount: _corrupt.length
+      }, null, 2));
       return;
     }
     log(cy(`# leerness api-skill list (1.9.245, UR-0015)`));
     log('');
     if (skills.length === 0) { log(dm(`(없음)`)); return; }
     skills.forEach(s => {
-      log(`  • ${gr(s.id)} — ${s.name}`);
+      log(`  • ${gr(s.id)} — ${s.name}${s.corrupt ? yl('  ⚠ 손상(frontmatter 파싱 불가)') : ''}`);
       if (s.urls && s.urls.length) log(dm(`       ${s.urls[0]}${s.urls.length > 1 ? ` (+${s.urls.length - 1})` : ''}`));
       if (s.direction) log(dm(`       방향: ${s.direction.slice(0, 80)}`));
     });
+    if (_corrupt.length) log(yl(`  ⚠ 손상 ${_corrupt.length}건 — 해당 .md 의 frontmatter(--- 구분선)를 확인하세요`));
     return;
   }
   // 1.9.245: 위치 인자 robust 추출 — argv 에서 cmd/sub 뒤 첫 non-flag (flag value 도 skip)
@@ -6165,9 +6184,9 @@ async function apiSkillCmd(root, sub) {
   };
   if (sub === 'show') {
     const id = arg('--id') || _positionalAfterSub();
-    if (!id) { log(rd('id 필요: leerness api-skill show <id>')); process.exitCode = 1; return; }
+    if (!id) { failJson(has('--json'), 'missing_args', 'id 필요: leerness api-skill show <id>'); return; }   // 1.36.74: --json 에러 구조화
     const s = _loadAPISkill(root, id);
-    if (!s) { log(rd(`api-skill 없음: ${id}`)); process.exitCode = 1; return; }
+    if (!s) { failJson(has('--json'), 'not_found', `api-skill 없음: ${id}`); return; }
     if (has('--json')) { log(JSON.stringify(s, null, 2)); return; }
     log(fs.readFileSync(path.join(dir, id + '.md'), 'utf8'));
     return;
@@ -6186,23 +6205,28 @@ async function apiSkillCmd(root, sub) {
   }
   if (sub === 'drop') {
     const id = arg('--id') || _positionalAfterSub();
-    if (!id) { log(rd('id 필요: leerness api-skill drop <id>')); process.exitCode = 1; return; }
+    if (!id) { failJson(has('--json'), 'missing_args', 'id 필요: leerness api-skill drop <id>'); return; }
     const fp = path.join(dir, id + '.md');
-    if (!fs.existsSync(fp)) { log(rd(`없음: ${id}`)); process.exitCode = 1; return; }
+    if (!fs.existsSync(fp)) { failJson(has('--json'), 'not_found', `없음: ${id}`); return; }   // 1.36.74: --json 에러 구조화
     fs.unlinkSync(fp);
+    if (has('--json')) { log(JSON.stringify({ ok: true, dropped: id }, null, 2)); return; }
     log(gr(`✓ 삭제: ${id}`));
     return;
   }
   if (sub === 'add') {
+    // 1.36.74 (9차 헌트 자체관측): --json 인데 사람용 진행 로그/실패 메시지가 stdout 을 오염시켜 JSON 소비자(MCP/CI)가
+    //   파싱 불가 — 다른 표면에서 이미 고친 --json 계약 위반의 잔존 지점. 진행 로그 억제 + 실패도 구조화.
+    const _j = has('--json');
+    const _hlog = (s) => { if (!_j) log(s); };
     const url = arg('--url') || _positionalAfterSub();
-    if (!url) { log(rd('URL 필요: leerness api-skill add <url> [--direction "..."]')); process.exitCode = 1; return; }
+    if (!url) { failJson(_j, 'missing_args', 'URL 필요: leerness api-skill add <url> [--direction "..."]'); return; }
     const direction = arg('--direction', '');
     const name = arg('--name', '');
     const noCrawl = has('--no-crawl');
-    log(cy(`# leerness api-skill add (1.9.245, UR-0015)`));
-    log(`  URL: ${url}`);
-    if (direction) log(`  방향: ${direction}`);
-    log(dm(`  Fetch + crawl (depth=1, same-domain, max 10)...`));
+    _hlog(cy(`# leerness api-skill add (1.9.245, UR-0015)`));
+    _hlog(`  URL: ${url}`);
+    if (direction) _hlog(`  방향: ${direction}`);
+    _hlog(dm(`  Fetch + crawl (depth=1, same-domain, max 10)...`));
     try {
       const doc = await _collectAPIDoc(url, { direction, noCrawl });
       const skillName = name || doc.title || new URL(url).hostname;
@@ -6219,17 +6243,27 @@ async function apiSkillCmd(root, sub) {
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
       const md = _serializeAPISkill(id, skillName, [url], direction, doc);
       fs.writeFileSync(path.join(dir, id + '.md'), md, 'utf8');
-      log(gr(`✓ 저장: .harness/api-skills/${id}.md`));
-      log(dm(`  title: ${doc.title || '(none)'}`));
-      log(dm(`  related links: ${(doc.related_links || []).length}`));
-      log(dm(`  text size: ${doc.text.length} chars`));
-      if (has('--json')) log(JSON.stringify({ id, name: skillName, url, related_count: (doc.related_links || []).length }, null, 2));
+      _hlog(gr(`✓ 저장: .harness/api-skills/${id}.md`));
+      _hlog(dm(`  title: ${doc.title || '(none)'}`));
+      _hlog(dm(`  related links: ${(doc.related_links || []).length}`));
+      _hlog(dm(`  text size: ${doc.text.length} chars`));
+      if (_j) log(JSON.stringify({ ok: true, id, name: skillName, url, related_count: (doc.related_links || []).length }, null, 2));
     } catch (e) {
-      log(rd(`✗ Fetch 실패: ${e.message}`));
+      _hlog(rd(`✗ Fetch 실패: ${e.message}`));
       // 1.9.245: --skeleton fallback — Cloudflare/WAF 차단된 URL 도 빈 .md 골격 생성 → 사용자가 수동 채움
       if (has('--skeleton') || /403|401|429/.test(e.message)) {
-        const skillName = name || new URL(url).hostname;
-        const id = _apiSkillId(url, name);
+        // 1.36.74 (9차 헌트 #5 P1): skeleton 폴백에 충돌 해소기가 없어 URL 이 다른데 slug 가 같으면 앞 항목을
+        //   통째로 덮어썼다(실측: alpha URL·direction 소실). fetch 경로(1.36.28 #4)와 동일 규칙 공유.
+        let skillName, id;
+        try { skillName = name || new URL(url).hostname; } catch { skillName = name || String(url).slice(0, 60); }
+        id = _apiSkillId(url, name);
+        const _idFileS = (i) => path.join(dir, i + '.md');
+        if (fs.existsSync(_idFileS(id))) {
+          const existing = fs.readFileSync(_idFileS(id), 'utf8');
+          const um = existing.match(/^urls:\s*\r?\n\s*-\s*(\S.*)$/m);
+          const storedUrl = um ? um[1].trim() : '';
+          if (storedUrl && storedUrl !== url) id = id + '-' + _shortHash(url);
+        }
         if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
         const stub = {
           url, title: skillName, text: `(fetch 실패 — 사용자가 직접 ${url} 에서 내용을 복사해 채워주세요)`,
@@ -6237,11 +6271,12 @@ async function apiSkillCmd(root, sub) {
         };
         const md = _serializeAPISkill(id, skillName, [url], direction, stub);
         fs.writeFileSync(path.join(dir, id + '.md'), md, 'utf8');
-        log(yl(`⚠ 빈 골격 생성 (--skeleton fallback): .harness/api-skills/${id}.md`));
-        log(dm(`  → 직접 ${url} 내용을 복사해서 .md 파일에 채워넣어주세요`));
-        log(dm(`  → 이후 leerness handoff 가 매칭 시 참조됩니다`));
-        if (has('--json')) log(JSON.stringify({ id, skeleton: true, url, name: skillName }, null, 2));
+        _hlog(yl(`⚠ 빈 골격 생성 (--skeleton fallback): .harness/api-skills/${id}.md`));
+        _hlog(dm(`  → 직접 ${url} 내용을 복사해서 .md 파일에 채워넣어주세요`));
+        _hlog(dm(`  → 이후 leerness handoff 가 매칭 시 참조됩니다`));
+        if (_j) log(JSON.stringify({ ok: true, id, skeleton: true, url, name: skillName, fetchError: e.message }, null, 2));
       } else {
+        if (_j) log(JSON.stringify({ ok: false, code: 'fetch_failed', error: e.message, url }, null, 2));   // 실패도 구조화(종전: --json 에 사람용 텍스트만)
         process.exitCode = 1;
       }
     }
@@ -9732,6 +9767,39 @@ function memoryRestoreCmd(root, surface, target) {
   const activePath = surface === 'decisions' ? decisionsPath(root)
                     : surface === 'lessons'   ? lessonsPath(root)
                     : planPath(root);
+  // 1.36.74 (9차 헌트 #4 P1): 같은 항목이 이미 active 에 있으면 복원이 조용히 중복 레코드를 만들었다
+  //   (drop → 같은 제목 재생성 → restore = 동일 제목 2건, 어느 쪽이 진짜인지 불명). 충돌은 기본 거부하고
+  //   --force 로만 진행 — 복원은 "되살리기"지 "복제"가 아니다. archive 는 손대지 않으므로 재시도 가능.
+  if (!has('--force')) {
+    // 1.36.74 (검수 High-2 + Medium): 첫 줄 substring 비교는 (a) 날짜만 다른 논리적 중복을 놓치고
+    //   (b) 같은 날 저장된 무관한 lesson·'Deploy' vs 'Deploy v2' 를 오탐 차단했다(양쪽 실측).
+    //   표면별 "정체성"(decision=title, lesson=text, plan=제목)을 파싱해 정확 일치로만 판정.
+    const _activeNow = exists(activePath) ? read(activePath) : '';
+    const _identities = (mdText) => {
+      try {
+        if (surface === 'decisions') return new Set((_decisionsFromMd(mdText) || []).map(d => String(d.title || '').trim()).filter(Boolean));
+        if (surface === 'lessons') return new Set((_parseLessonEntries(mdText) || []).map(l => String(l.text || '').trim()).filter(Boolean));
+      } catch {}
+      // plan: '## M-XXXX 제목' 헤딩의 제목부 (M-ID 는 재발급될 수 있어 제목으로 판정)
+      const out = new Set();
+      for (const l of String(mdText).split('\n')) {
+        const m = l.match(/^##+\s*(?:M-\d+\s*)?(.+?)\s*$/);
+        if (m && m[1] && !/^제거 /.test(m[1])) out.add(m[1].trim());
+      }
+      return out;
+    };
+    const _activeIds = _identities(_activeNow);
+    const _dupes = [];
+    for (const blk of restoredBlocks) {
+      for (const id of _identities(blk)) if (_activeIds.has(id)) _dupes.push(id.slice(0, 70));
+    }
+    if (_dupes.length) {
+      failJson(has('--json'), 'restore_conflict',
+        `이미 active 에 동일 항목 존재 — 중복 생성 방지로 복원 거부 (${_dupes.length}건: ${_dupes.slice(0, 2).join(' · ')}). ` +
+        `archive 는 그대로 두었으니 active 쪽을 정리 후 재시도하거나, 의도한 중복이면 --force`);
+      return;
+    }
+  }
   // active 파일에 복귀 (헤더 보존)
   for (const blk of restoredBlocks) {
     append(activePath, '\n' + blk + '\n');
@@ -19045,6 +19113,17 @@ function mcpServeCmd(root) {
 
   // stdin JSON-RPC 한 줄 단위
   let buf = '';
+  // 1.36.74 (9차 헌트 #7): 한 줄 처리 로직을 함수로 — EOF 시 개행 없이 남은 마지막 요청이 조용히 유실되던 것
+  //   (실측: 개행 없는 ping 은 무응답 exit 0, 개행 있는 동일 요청은 정상 응답). 클라이언트가 flush 를 개행 없이 끝내면 요청 손실.
+  const _handleLine = (line) => {
+    if (!line) return;
+    // 1.36.39 (#3): 파싱과 핸들링 분리 — 핸들러 내부 예외가 -32700 "Parse error"(id null)로 오보되지 않게.
+    let req = null;
+    try { req = JSON.parse(line); }
+    catch (e) { send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error: ' + e.message } }); return; }
+    try { handleRequest(req); }
+    catch (e) { send({ jsonrpc: '2.0', id: (req && req.id != null) ? req.id : null, error: { code: -32603, message: 'Internal error: ' + e.message } }); }
+  };
   process.stdin.setEncoding('utf8');
   process.stdin.on('data', chunk => {
     buf += chunk;
@@ -19052,16 +19131,15 @@ function mcpServeCmd(root) {
     while ((nl = buf.indexOf('\n')) !== -1) {
       const line = buf.slice(0, nl).trim();
       buf = buf.slice(nl + 1);
-      if (!line) continue;
-      // 1.36.39 (#3): 파싱과 핸들링 분리 — 핸들러 내부 예외가 -32700 "Parse error"(id null)로 오보되지 않게.
-      let req = null;
-      try { req = JSON.parse(line); }
-      catch (e) { send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error: ' + e.message } }); continue; }
-      try { handleRequest(req); }
-      catch (e) { send({ jsonrpc: '2.0', id: (req && req.id != null) ? req.id : null, error: { code: -32603, message: 'Internal error: ' + e.message } }); }
+      _handleLine(line);
     }
   });
-  process.stdin.on('end', () => process.exit(0));
+  process.stdin.on('end', () => {
+    const rest = buf.trim();
+    buf = '';
+    if (rest) _handleLine(rest);   // 개행 없이 끝난 마지막 요청도 처리
+    process.exit(0);
+  });
   // 인터럽트 처리
   process.on('SIGINT', () => process.exit(0));
   process.on('SIGTERM', () => process.exit(0));
@@ -20236,7 +20314,32 @@ function _loadLeernessState(root) {
   const f = path.join(_leernessStateDir(root), 'state.json');
   if (!exists(f)) return { schemaVersion: 1, project: detectProjectName(root), currentRunId: null, runCounter: 0, updatedAt: null };
   // 1.36.28 (#3): 손상 파일을 빈 상태로 오인하면 카운터가 0으로 리셋돼 run-0001 을 덮어쓴다(데이터 유실). 파싱 실패는 던진다.
-  try { return JSON.parse(read(f)); } catch { throw Object.assign(new Error(`.leerness/state.json 손상 — 덮어쓰기 거부: ${f} (복구/삭제 후 재시도)`), { code: 'E_STORE_CORRUPT', file: f }); }
+  let _st;
+  try { _st = JSON.parse(read(f)); } catch { throw Object.assign(new Error(`.leerness/state.json 손상 — 덮어쓰기 거부: ${f} (복구/삭제 후 재시도)`), { code: 'E_STORE_CORRUPT', file: f }); }
+  // 1.36.74 (9차 헌트 #1 P1): "파싱은 되지만 스키마 무효"(예: `{}`)가 위 가드를 통과해 runCounter 를 0 으로 되돌리고
+  //   기존 run-0001.json 을 덮어쓰던 것(실측: original-goal → replacement-goal). 형태 검증도 fail-closed.
+  //   단, runs 디렉토리가 비어 있으면(진짜 신규/빈 상태) 관대하게 기본값 — 없는 데이터를 지킬 필요는 없다.
+  const _shapeOk = _st && typeof _st === 'object' && !Array.isArray(_st)
+    && Number.isInteger(_st.runCounter) && _st.runCounter >= 0
+    && (_st.currentRunId === null || typeof _st.currentRunId === 'string');
+  // 디스크의 최대 run 번호 — 카운터의 진실성 대조 기준
+  let _maxRun = 0;
+  try {
+    for (const x of fs.readdirSync(path.join(_leernessStateDir(root), 'runs'))) {
+      const m = /^run-(\d+)\.json$/.exec(x);
+      if (m) _maxRun = Math.max(_maxRun, parseInt(m[1], 10));
+    }
+  } catch {}
+  if (!_shapeOk) {
+    if (_maxRun > 0) throw Object.assign(new Error(`.leerness/state.json 스키마 무효 — 덮어쓰기 거부: ${f} (runs/ 에 기존 기록 있음 · 복구/삭제 후 재시도)`), { code: 'E_STORE_CORRUPT', file: f });
+    return { schemaVersion: 1, project: detectProjectName(root), currentRunId: null, runCounter: 0, updatedAt: null };
+  }
+  // 1.36.74 (검수 High-1): 형태는 유효한데 값이 stale 한 카운터(runCounter < 실재 최대 run)도 다음 start 가
+  //   기존 run 파일을 덮어쓴다(실측 ORIGINAL→REPLACEMENT). 형태 검증만으론 부족 — 디스크 실재와 대조해 fail-closed.
+  if (_st.runCounter < _maxRun) {
+    throw Object.assign(new Error(`.leerness/state.json 카운터 불일치 — 덮어쓰기 거부: runCounter=${_st.runCounter} < 실재 run-${String(_maxRun).padStart(4, '0')} (${f} 복구 또는 runCounter 를 ${_maxRun} 이상으로 수정 후 재시도)`), { code: 'E_STORE_CORRUPT', file: f });
+  }
+  return _st;
 }
 function _saveLeernessState(root, state) {
   const dir = _leernessStateDir(root); mkdirp(dir);

package/lib/pure-utils.js

@@ -804,7 +804,7 @@ function _managedMerge(file, next, previous, archiveRel, overwriteSet, opts = {}
     // preserved 래퍼 자체의 보일러플레이트는 이월 대상 아님 (구 <details> 형식 + 신 평문 형식 + en 래퍼 모두)
     if (l === tag || l === '---' || l === '<details>' || l === '</details>') continue;
     if (/^```/.test(l) || /^<summary>/.test(l)) continue;
-    if (/^## Preserved previous content|^Previous content was backed up|^`[^`]*archive[^`]*`$|^> 이전 버전에서 이어진|^> Custom user\/project content carried over/.test(l)) continue;
+    if (/^## Preserved previous content|^Previous content was backed up|^`[^`]*archive[^`]*`$|^> 이전 버전에서 이어진|^> Custom user\/project content carried over|^> ⚠ \d+ Korean lines were preserved below\. If this project never had Korean customizations.*with certainty\.$/.test(l)) continue;   // (검수 #2) 생성 문장 전체 앵커 — 같은 접두의 사용자 커스텀 라인 오삭제 방지
     if (seen.has(l)) continue;
     seen.add(l);
     custom.push(raw.replace(/\\`\\`\\`/g, '```'));   // 구 형식에서 이스케이프된 펜스 복원
@@ -812,9 +812,18 @@ function _managedMerge(file, next, previous, archiveRel, overwriteSet, opts = {}
   if (!custom.length) return next;
   const ar = archiveRel || '.harness/archive';
   // 1.36.60 (검수): 보존 래퍼 문구도 프로젝트 언어를 따른다 — en 프로젝트에 한글 래퍼가 새 한글원을 만들던 것 해소
-  const note = opts.lang === 'en'
+  let note = opts.lang === 'en'
     ? `> Custom user/project content carried over from the previous version — re-carried automatically on every migration. Full original backup: \`${ar}\``
     : `> 이전 버전에서 이어진 사용자/프로젝트 커스텀 내용 — 마이그레이션마다 자동 이월됩니다. 전체 원본 백업: \`${ar}\``;
+  // 1.36.73 (8차 헌트 F9 설계 결정): 초고령 KO canonical(현행 altTemplate 에 없는 구판 템플릿)이 en 프로젝트에
+  //   커스텀으로 오인 이월될 수 있다. 자동 차감은 데이터 손실 위험(어느 라인이 템플릿인지 확신 불가 — false-DROP 이 버그)
+  //   이라 하지 않고, 한글 비중이 높으면 "검토·정리 안내"를 명시해 조용한 동결만 없앤다.
+  if (opts.lang === 'en') {
+    const hangulLines = custom.filter(l => /[가-힣]/.test(l)).length;
+    if (hangulLines >= 10 && hangulLines > custom.length * 0.5) {
+      note += `\n> ⚠ ${hangulLines} Korean lines were preserved below. If this project never had Korean customizations, most of these are likely template text from an old Korean install — review and prune manually (data is also in the backup above). leerness will not auto-delete them: it cannot distinguish old template lines from your own notes with certainty.`;
+    }
+  }
   return next.trimEnd() + `\n\n---\n${tag}\n## Preserved previous content\n\n${note}\n\n` + custom.join('\n') + '\n';
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.72",
+  "version": "1.36.74",
   "description": "The AI-coding operations layer that makes \"done\" require evidence — persistent memory, evidence-gated completion checks, and clean handoffs for any AI agent (Claude Code, Codex, Cursor). State lives as plain files in your repo. CLI + MCP, 0 runtime dependencies.",
   "keywords": [
     "leerness",

package/scripts/e2e.js

@@ -7298,5 +7298,119 @@ total++;
   if (!ok) failed++;
 }
 
+// 1.36.73 (8차 헌트 F12/F9 종결): skills-lock = 디스크 실재 + KO-잔존 이월 안내
+total++;
+{
+  let ok = false;
+  const _d = [];
+  try {
+    const d = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-f12-')); _d.push(d);
+    // (검수 #3) exit 단언 + 정렬 집합 정확 비교 — 카운트만 비교하면 2차 init 실패를 1차 결과가 가렸다
+    const i1 = cp.spawnSync(process.execPath, [CLI, 'init', d, '--yes', '--language', 'en', '--skills', 'all', '--no-stale-check', '--no-env'], { encoding: 'utf8', timeout: 40000 });
+    const i2 = cp.spawnSync(process.execPath, [CLI, 'init', d, '--yes', '--language', 'en', '--skills', 'recommended', '--no-stale-check', '--no-env'], { encoding: 'utf8', timeout: 40000 });
+    const dirSet = fs.readdirSync(path.join(d, '.harness', 'skills'), { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name).sort();
+    const lockSet = Object.keys(JSON.parse(fs.readFileSync(path.join(d, '.harness', 'skills-lock.json'), 'utf8')).installedSkills).sort();
+    const f12Ok = i1.status === 0 && i2.status === 0 && dirSet.length > 5 && JSON.stringify(dirSet) === JSON.stringify(lockSet);
+    // F9: 실 CLI migrate 경유 — 구판 KO canonical 을 en 프로젝트 CLAUDE.md 에 심고 migrate
+    const d9 = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-f9-')); _d.push(d9);
+    const i3 = cp.spawnSync(process.execPath, [CLI, 'init', d9, '--yes', '--language', 'en', '--no-stale-check', '--no-env'], { encoding: 'utf8', timeout: 40000 });
+    const cl = path.join(d9, 'CLAUDE.md');
+    const ko = Array.from({ length: 15 }, (_, i) => '한국어 구판 템플릿 라인 ' + i).join('\n');
+    fs.appendFileSync(cl, '\n' + ko + '\nMY_CUSTOM_KEEP_42\n');
+    fs.writeFileSync(path.join(d9, '.harness', 'HARNESS_VERSION'), '1.36.0');
+    const mg = cp.spawnSync(process.execPath, [CLI, 'migrate', d9], { encoding: 'utf8', timeout: 60000, maxBuffer: 32 * 1024 * 1024 });
+    const after = fs.readFileSync(cl, 'utf8');
+    const mg2 = cp.spawnSync(process.execPath, [CLI, 'migrate', d9], { encoding: 'utf8', timeout: 60000, maxBuffer: 32 * 1024 * 1024 });
+    const after2 = fs.readFileSync(cl, 'utf8');
+    const f9Ok = i3.status === 0 && mg.status === 0 && mg2.status === 0
+      && after.includes('Korean lines were preserved')                    // 실 파일에 안내
+      && after.includes('MY_CUSTOM_KEEP_42')                              // 커스텀 무손실
+      && (after2.match(/Korean lines were preserved/g) || []).length === 1;   // 재migrate 멱등
+    // (검수 #2 회귀) 같은 접두의 사용자 커스텀 라인은 생존해야
+    const m = require(path.join(path.dirname(CLI), '..', 'lib', 'pure-utils.js'));
+    const userLine = '> ⚠ 10 Korean lines were preserved for localization QA.';
+    const surv = m._managedMerge('CLAUDE.md', '# N\n', '# O\n' + userLine, 'a', null, { lang: 'en' }).includes(userLine);
+    ok = f12Ok && f9Ok && surv;
+    if (!ok) console.log(`   [f12/f9 디버그] f12=${f12Ok}(${dirSet.length}/${lockSet.length}) f9=${f9Ok}(mg=${mg.status}) surv=${surv}`);
+  } catch (e) {} finally { _d.forEach(x => { try { fs.rmSync(x, { recursive: true, force: true }); } catch {} }); }
+  console.log(ok ? '✓ B(1.36.73) F12 skills-lock=디스크 실재 + F9 KO-잔존 이월 안내(멱등·무손실·소수 무경고)' : '✗ F12/F9 실패');
+  if (!ok) failed++;
+}
+
+// 1.36.74 (9차 헌트): state 스키마 fail-closed · restore 중복 거부 · api-skill skeleton 충돌 · MCP 마지막 줄 · 손상 표시 · --json 계약
+total++;
+{
+  let ok = false;
+  const _d = [];
+  try {
+    // #1 파싱되지만 스키마 무효인 state.json → 기존 run 보호
+    const d1 = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-h9s-')); _d.push(d1);
+    cp.spawnSync(process.execPath, [CLI, 'state', 'start', 'original-goal', '--path', d1, '--json'], { encoding: 'utf8', timeout: 30000 });
+    const runFile = path.join(d1, '.leerness', 'runs', 'run-0001.json');
+    const before = fs.readFileSync(runFile, 'utf8');
+    fs.writeFileSync(path.join(d1, '.leerness', 'state.json'), '{}\n');
+    const s2 = cp.spawnSync(process.execPath, [CLI, 'state', 'start', 'replacement-goal', '--path', d1, '--json'], { encoding: 'utf8', timeout: 30000 });
+    const stateOk = s2.status === 1 && fs.readFileSync(runFile, 'utf8') === before;
+    // 신규(빈 runs) 프로젝트에서는 관대 — 무효 state 가 있어도 정상 시작
+    const d1b = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-h9s2-')); _d.push(d1b);
+    fs.mkdirSync(path.join(d1b, '.leerness'), { recursive: true });
+    fs.writeFileSync(path.join(d1b, '.leerness', 'state.json'), '{}\n');
+    const freshOk = cp.spawnSync(process.execPath, [CLI, 'state', 'start', 'g', '--path', d1b, '--json'], { encoding: 'utf8', timeout: 30000 }).status === 0;
+    // #4 restore 충돌 거부 + 정상 복원 무회귀 + --force 우회
+    const d2 = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-h9r-')); _d.push(d2);
+    cp.spawnSync(process.execPath, [CLI, 'init', d2, '--yes', '--minimal', '--no-env', '--no-stale-check'], { encoding: 'utf8', timeout: 40000 });
+    const D = (a) => cp.spawnSync(process.execPath, [CLI, ...a, '--path', d2], { encoding: 'utf8', timeout: 20000 });
+    D(['decision', 'add', 'Collision Decision', '--reason', 'archived-original']);
+    D(['decision', 'drop', 'Collision Decision']);
+    D(['decision', 'add', 'Collision Decision', '--reason', 'active-replacement']);
+    const conflict = D(['memory', 'restore', 'decisions', 'Collision Decision']);
+    const cnt = () => { try { return (JSON.parse(D(['decision', 'list', '--json']).stdout).decisions || []).filter(x => x.title === 'Collision Decision').length; } catch { return -1; } };
+    const restoreOk = conflict.status === 1 && cnt() === 1 && D(['memory', 'restore', 'decisions', 'Collision Decision', '--force']).status === 0 && cnt() === 2;
+    // (검수 High-1) 형태는 유효하나 stale 한 runCounter 도 기존 run 을 덮어쓰면 안 된다
+    const d1c = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-h9st-')); _d.push(d1c);
+    cp.spawnSync(process.execPath, [CLI, 'state', 'start', 'ORIGINAL', '--path', d1c, '--json'], { encoding: 'utf8', timeout: 30000 });
+    const rf1 = path.join(d1c, '.leerness', 'runs', 'run-0001.json');
+    const beforeStale = fs.readFileSync(rf1, 'utf8');
+    const stp = path.join(d1c, '.leerness', 'state.json');
+    const stj = JSON.parse(fs.readFileSync(stp, 'utf8')); stj.runCounter = 0; stj.currentRunId = null;
+    fs.writeFileSync(stp, JSON.stringify(stj, null, 2));
+    const staleR = cp.spawnSync(process.execPath, [CLI, 'state', 'start', 'REPLACEMENT', '--path', d1c, '--json'], { encoding: 'utf8', timeout: 30000 });
+    const staleOk = staleR.status === 1 && fs.readFileSync(rf1, 'utf8') === beforeStale;
+    // (검수 High-2) 날짜만 다른 논리적 중복도 차단 · (검수 Medium) 같은 날 무관한 항목은 오탐 없이 복원
+    const d2b = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-h9id-')); _d.push(d2b);
+    cp.spawnSync(process.execPath, [CLI, 'init', d2b, '--yes', '--minimal', '--no-env', '--no-stale-check'], { encoding: 'utf8', timeout: 40000 });
+    const D2 = (a) => cp.spawnSync(process.execPath, [CLI, ...a, '--path', d2b], { encoding: 'utf8', timeout: 20000 });
+    D2(['decision', 'add', 'Dup Title', '--reason', 'first']); D2(['decision', 'drop', 'Dup Title']);
+    const ap2 = path.join(d2b, '.harness', 'decisions.archive.md');
+    if (fs.existsSync(ap2)) fs.writeFileSync(ap2, fs.readFileSync(ap2, 'utf8').replace(/### \d{4}-\d{2}-\d{2}/g, '### 2020-01-01'));
+    D2(['decision', 'add', 'Dup Title', '--reason', 'second']);
+    const logicalOk = D2(['memory', 'restore', 'decisions', 'Dup Title']).status === 1;
+    D2(['lesson', 'save', 'AAA 무관한 교훈']); D2(['lesson', 'save', 'BBB 다른 교훈']); D2(['lesson', 'drop', 'AAA 무관한 교훈']);
+    const noFpOk = D2(['memory', 'restore', 'lessons', 'AAA']).status === 0;   // 같은 날 저장이어도 정당한 복원은 통과
+    // #5 skeleton 경로 id 충돌 → 양쪽 보존
+    const d3 = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-h9a-')); _d.push(d3);
+    const A = (u, dir) => cp.spawnSync(process.execPath, [CLI, 'api-skill', 'add', u, '--skeleton', '--no-crawl', '--direction', dir, '--path', d3, '--json'], { encoding: 'utf8', timeout: 25000 });
+    A('ftp://example.test/docs?alpha', 'alpha-direction'); A('ftp://example.test/docs?beta', 'beta-direction');
+    const askDir = path.join(d3, '.harness', 'api-skills');
+    const all = fs.existsSync(askDir) ? fs.readdirSync(askDir).map(f => fs.readFileSync(path.join(askDir, f), 'utf8')).join('\n') : '';
+    const apiOk = /alpha-direction/.test(all) && /beta-direction/.test(all);
+    // #7 개행 없는 마지막 MCP 요청도 응답
+    const noNl = cp.spawnSync(process.execPath, [CLI, 'mcp', 'serve'], { encoding: 'utf8', timeout: 25000, input: JSON.stringify({ jsonrpc: '2.0', id: 101, method: 'ping' }) });
+    let mcpOk = false;
+    try { mcpOk = JSON.parse((noNl.stdout || '').trim()).id === 101; } catch {}
+    // #6 손상 frontmatter 표시 + api-skill --json 계약(사람용 텍스트 오염 0)
+    const d4 = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-h9c-')); _d.push(d4);
+    fs.mkdirSync(path.join(d4, '.harness', 'api-skills'), { recursive: true });
+    fs.writeFileSync(path.join(d4, '.harness', 'api-skills', 'bad.md'), '---\nid: intended\nname: X\n# no closing');
+    let corruptOk = false, jsonOk = false;
+    try { const j = JSON.parse(cp.spawnSync(process.execPath, [CLI, 'api-skill', 'list', '--path', d4, '--json'], { encoding: 'utf8', timeout: 20000 }).stdout); corruptOk = j.corruptCount === 1 && j.skills[0].corrupt === true; } catch {}
+    try { const j = JSON.parse(cp.spawnSync(process.execPath, [CLI, 'api-skill', 'add', 'not-a-url', '--path', d4, '--json'], { encoding: 'utf8', timeout: 25000 }).stdout); jsonOk = j.ok === false && j.code === 'fetch_failed'; } catch {}
+    ok = stateOk && freshOk && restoreOk && staleOk && logicalOk && noFpOk && apiOk && mcpOk && corruptOk && jsonOk;
+    if (!ok) console.log(`   [h9 디버그] state=${stateOk} fresh=${freshOk} restore=${restoreOk} stale=${staleOk} logical=${logicalOk} noFp=${noFpOk} api=${apiOk} mcp=${mcpOk} corrupt=${corruptOk} json=${jsonOk}`);
+  } catch (e) {} finally { _d.forEach(x => { try { fs.rmSync(x, { recursive: true, force: true }); } catch {} }); }
+  console.log(ok ? '✓ B(1.36.74) 9차헌트: state 스키마 fail-closed · restore 충돌거부(--force 우회) · skeleton 충돌보존 · MCP 마지막줄 · 손상표시 · --json 계약' : '✗ 9차 헌트 수정 실패');
+  if (!ok) failed++;
+}
+
 console.log(`\nE2E result: ${total - failed}/${total} passed · ${((Date.now() - _e2eStart) / 1000).toFixed(0)}s`);
 if (failed > 0) process.exit(1);