leerness 1.9.16 → 1.9.19

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## 1.9.19 — 2026-05-14
+
+**1.9.18 후속 다듬기 — verify-claim에 동적 실행, --strict-elements 정확도 강화**.
+
+1.9.18을 실전 sub-agent 검수에 쓰면서 발견한 두 가지 가공할 점을 마저 보완.
+
+### Added
+
+- **`leerness verify-claim --run-tests`**: 정적 점검(파일 존재 + 테스트 카운트)에 더해 `npm test`를 동적으로 실행. stdout에서 `X/Y passed` 패턴을 파싱해 evidence 주장과 비교. 주장이 `5/5 통과`인데 실제 `3/5`면 exit 1. `--json`에 `run.parsed`, `verdict.declaredPassMatches` 포함.
+- **`--strict-elements` 출력 강화**: 같은 함수명이라도 (a) 같은 파일이면 `⚠ 진짜 중복 가능`, (b) 다른 파일이면 `ℹ 의도 분리 가능` (예: 모듈 함수 vs CLI 명령)으로 분류. 1.9.18의 평면 출력보다 false positive 식별이 쉬워짐.
+
+### Why
+- `verify-claim`만으로는 "파일이 있고 check() 호출이 많다" 정도까지만 보장. `--run-tests`가 추가되면 메인 에이전트가 sub-agent의 evidence를 **한 번의 명령으로 정적+동적 모두 검증**.
+- 1.9.18 `--strict-elements`가 city-insights의 `MemoStats`/`StatsCli`(둘 다 `stats()` 함수, 다른 파일) 같은 의도된 분리를 잠재 중복으로 평면 표시 → 사용자가 직접 판별해야 했음. 1.9.19에선 정보를 더 줘서 즉시 분류 가능.
+
+### Migration
+```bash
+npx leerness@latest update . --yes
+```
+
+## 1.9.18 — 2026-05-14
+
+**오케스트레이션 검수 패키지 — `--since` 시간 필터 + `--strict-elements` 잠재 중복 + `depends-on` 그래프 + `verify-claim` 자동 검증**.
+
+1.9.17의 워크스페이스 모드를 실전 멀티 에이전트 작업에서 사용하다 발견한 4가지 갭을 모두 보완합니다. 검수 자동화에 초점.
+
+### Added
+
+- **`leerness handoff --since <duration>`**: `24h` / `3d` / `1w` / `30m` 형식. 해당 기간 내 수정된 T-row에 🆕 마크 + 별도 "최근 변경" 섹션. sub-agent들이 방금 무엇을 추가했는지 한눈에.
+- **`leerness reuse-map --strict-elements`**: element 컬럼에서 함수명 추출 (`src/build.js (escapeHtml)` → `escapeHtml`), **다른 capability 이름인데 같은 함수**를 잠재 중복으로 감지. 명명 일관성 검사용.
+- **`reuse-map` depends-on 표기**: notes 컬럼에 `depends-on: A, B` 표기 시 자동 추출해 의존 그래프로 표시. 단일/워크스페이스 모두 지원. JSON에 `dependsEdges` 포함.
+- **`leerness verify-claim <T-ID>`**: progress-tracker의 evidence 컬럼 자동 파싱 — 주장한 파일 경로 존재 확인, 주장한 테스트 수 vs 실제 `check()/test()/it()` 호출 수 대조. 불일치 시 `exit 1`. CI 통합용 `--json`.
+
+### Why
+멀티 에이전트 병렬 작업 검수 시 메인 에이전트가 매번 수동으로 `wc -l`, `grep`, `npm test`를 돌리고 있었음. 1.9.18은 그 패턴을 하나의 명령으로 자동화:
+- "지금 sub-agent들이 뭘 추가했지?" → `handoff --all-apps --since 1h`
+- "같은 함수를 두 번 만든 거 아닌가?" → `reuse-map --all-apps --strict-elements`
+- "이 에이전트의 evidence가 진짜인가?" → `verify-claim T-0008`
+
+### Migration
+```bash
+npx leerness@latest update . --yes
+```
+
+## 1.9.17 — 2026-05-14
+
+**워크스페이스 오케스트레이션 — `handoff --all-apps` + `reuse-map --all-apps` + 중복 capability 감지**.
+
+멀티 에이전트 병렬 작업 시 메인 에이전트가 한 번의 명령으로 모든 sub-agent의 진행 상태를 파악하고, 새 패턴이 다른 프로젝트와 중복되는지 즉시 검증할 수 있습니다.
+
+### Added
+
+- **`leerness handoff --all-apps` / `--include`**: 워크스페이스 전체의 진행 상태(WIP/blocked/다음 작업)를 한 화면에 출력. 4개 sub-agent가 병렬로 일할 때 메인 agent의 상황 인식용. `--json`도 지원.
+- **`leerness reuse-map [path]`**: 단일 프로젝트의 reuse-map.md 파싱 출력.
+- **`leerness reuse-map --all-apps` / `--include`**: 다수 프로젝트의 모든 capability를 모아 **동일 이름 capability를 자동 중복 감지**. 재사용/공통 모듈 추출 기회 식별. `--json`도 지원.
+
+### Why
+1.9.16까지의 `retro --all-apps`는 누적 회고용. 1.9.17은 **실시간 오케스트레이션용**: "지금 어떤 에이전트가 무엇을 하고 있고, 새 패턴이 다른 프로젝트와 겹치는가?"에 답합니다.
+
+### Migration
+```bash
+npx leerness@latest update . --yes
+```
+
 ## 1.9.16 — 2026-05-13
 
 **brainstorm 워크스페이스 통합 + 3 명령 JSON export + session close 워크스페이스 안내**.

package/bin/harness.js

@@ -6,7 +6,7 @@ const path = require('path');
 const cp = require('child_process');
 const readline = require('readline');
 
-const VERSION = '1.9.16';
+const VERSION = '1.9.19';
 const MARK = '<!-- leerness:managed -->';
 const README_START = '<!-- leerness:project-readme:start -->';
 const README_END = '<!-- leerness:project-readme:end -->';
@@ -113,7 +113,7 @@ function arg(name, def = null) { const i = process.argv.indexOf(name); return i
 function has(name) { return process.argv.includes(name); }
 function nonFlagArgs() {
   const out = [];
-  const withValue = new Set(['--language','--skills','--path','--status','--progress','--goal','--reason','--next','--target','--token-env','--package','--out','--from','--repo','--id','--note','--evidence','--query','--limit','--action','--agent','--tool','--doc','--command','--capability','--before','--after','--display','--threshold','--trigger','--check','--set','--min-score','--include','--days','--gh-pages-src','--roadmap']);
+  const withValue = new Set(['--language','--skills','--path','--status','--progress','--goal','--reason','--next','--target','--token-env','--package','--out','--from','--repo','--id','--note','--evidence','--query','--limit','--action','--agent','--tool','--doc','--command','--capability','--before','--after','--display','--threshold','--trigger','--check','--set','--min-score','--include','--days','--gh-pages-src','--roadmap','--since']);
   const a = process.argv.slice(2);
   for (let i = 0; i < a.length; i++) {
     const x = a[i];
@@ -1200,6 +1200,430 @@ function handoff(root) {
   ok('handoff loaded; current-state updated');
 }
 
+// 1.9.18: --since 파서 ("24h", "3d", "1w", "30m") → cutoff ISO date
+function _parseSince(s) {
+  if (!s) return null;
+  const m = String(s).match(/^(\d+(?:\.\d+)?)\s*([mhdw])$/i);
+  if (!m) return null;
+  const n = parseFloat(m[1]);
+  const unit = m[2].toLowerCase();
+  const ms = unit === 'm' ? n * 60 * 1000
+           : unit === 'h' ? n * 3600 * 1000
+           : unit === 'd' ? n * 86400 * 1000
+           : /* w */        n * 7 * 86400 * 1000;
+  const cutoff = new Date(Date.now() - ms);
+  return cutoff.toISOString().slice(0, 10); // YYYY-MM-DD
+}
+
+// 1.9.17→1.9.18: 워크스페이스 통합 handoff — 4개 agent 동시 작업 시 메인 agent용 한 줄 요약
+// 1.9.18: --since <duration> 추가, 최근 수정된 T-row 강조 (🆕 마크 + 별도 섹션)
+function _handoffWorkspace(rootBase) {
+  const paths = _collectWorkspacePaths(rootBase);
+  if (!paths.length) return fail('대상 프로젝트 없음. --include 또는 --all-apps 사용.');
+  const sinceArg = arg('--since', null);
+  const sinceCutoff = sinceArg ? _parseSince(sinceArg) : null;
+  if (sinceArg && !sinceCutoff) { fail(`--since 형식 오류: "${sinceArg}" (예: 24h, 3d, 1w)`); return process.exit(1); }
+
+  function isRecent(row) {
+    if (!sinceCutoff || !row.updated) return false;
+    return row.updated >= sinceCutoff;
+  }
+
+  if (has('--json')) {
+    const projects = paths.map(p => {
+      const rows = readProgressRows(p);
+      const buckets = {};
+      for (const r of rows) (buckets[r.status] || (buckets[r.status] = [])).push(r);
+      const activeRules = readRules(p).filter(r => r.status === 'active').length;
+      const recent = sinceCutoff ? rows.filter(isRecent) : [];
+      return {
+        project: path.basename(p),
+        path: p,
+        total: rows.length,
+        done: (buckets['done'] || []).length,
+        inProgress: (buckets['in-progress'] || []).length,
+        planned: (buckets['planned'] || []).length,
+        blocked: (buckets['blocked'] || []).length,
+        activeRules,
+        nextAction: (buckets['in-progress']?.[0]?.nextAction) || (buckets['planned']?.[0]?.nextAction) || (buckets['requested']?.[0]?.nextAction) || null,
+        recent: recent.map(r => ({ id: r.id, status: r.status, request: r.request, updated: r.updated }))
+      };
+    });
+    log(JSON.stringify({ workspace: path.basename(rootBase), since: sinceCutoff, projects, totals: {
+      tasks: projects.reduce((a, b) => a + b.total, 0),
+      done: projects.reduce((a, b) => a + b.done, 0),
+      inProgress: projects.reduce((a, b) => a + b.inProgress, 0),
+      blocked: projects.reduce((a, b) => a + b.blocked, 0),
+      recent: projects.reduce((a, b) => a + (b.recent?.length || 0), 0)
+    } }, null, 2));
+    return;
+  }
+  log(`# Workspace Handoff — ${paths.length}개 프로젝트 (1.9.18)`);
+  log(`Date: ${today()}`);
+  if (sinceCutoff) log(`Filter: since ${sinceArg} (${sinceCutoff} 이후 수정된 항목 🆕 강조)`);
+  log('');
+  log('## 프로젝트별 진행 상태');
+  let totalDone = 0, totalTasks = 0, totalWIP = 0, totalBlocked = 0, totalRecent = 0;
+  const allRecent = [];
+  for (const p of paths) {
+    const rows = readProgressRows(p);
+    const buckets = {};
+    for (const r of rows) (buckets[r.status] || (buckets[r.status] = [])).push(r);
+    const done = (buckets['done'] || []).length;
+    const wip = (buckets['in-progress'] || []).length;
+    const planned = (buckets['planned'] || []).length;
+    const blocked = (buckets['blocked'] || []).length;
+    const recent = sinceCutoff ? rows.filter(isRecent) : [];
+    totalDone += done; totalTasks += rows.length; totalWIP += wip; totalBlocked += blocked; totalRecent += recent.length;
+    for (const r of recent) allRecent.push({ project: path.basename(p), ...r });
+    const nx = (buckets['in-progress']?.[0]) || (buckets['planned']?.[0]) || null;
+    const pct = rows.length ? Math.round(done / rows.length * 100) : 0;
+    const recentBadge = recent.length ? ` · 🆕 ${recent.length}` : '';
+    log(`  ${path.basename(p)}: ${done}/${rows.length} (${pct}%) · WIP ${wip} · planned ${planned}${blocked ? ` · 🚫 blocked ${blocked}` : ''}${recentBadge}`);
+    if (nx) log(`    └ 다음: ${nx.id} [${nx.status}] ${nx.nextAction || nx.request}`);
+  }
+  // 1.9.18: --since 모드일 때 최근 추가/수정 섹션
+  if (sinceCutoff) {
+    log('');
+    log(`## 🆕 최근 변경 (${sinceArg} 내, ${totalRecent}건)`);
+    if (!totalRecent) log(`  (없음) — ${sinceCutoff} 이후 progress-tracker 업데이트 없음`);
+    else {
+      for (const r of allRecent) log(`  - ${r.project}/${r.id} [${r.status}] ${r.request} (updated ${r.updated})`);
+    }
+  }
+  log('');
+  log(`## 📊 워크스페이스 총합`);
+  log(`  - 누적 task: ${totalTasks} (done ${totalDone}, ${totalTasks ? Math.round(totalDone / totalTasks * 100) : 0}%)`);
+  log(`  - 진행중 (WIP): ${totalWIP} · 차단: ${totalBlocked}${sinceCutoff ? ` · 🆕 최근 ${totalRecent}` : ''}`);
+  if (totalBlocked > 0) log(`  - ⚠ ${totalBlocked}건이 blocked — 우선 처리 검토`);
+  log('');
+  log(`## 💡 멀티에이전트 오케스트레이션 권장`);
+  log(`  - 각 프로젝트의 "다음" 작업을 sub-agent 1명씩 병렬 진행 가능`);
+  log(`  - 새 패턴 추가 시 \`leerness reuse-map --all-apps\`로 중복 감지${sinceCutoff ? '' : ' / `--since 24h`로 최근 변경 추적'}`);
+}
+
+function handoffCmd(root) {
+  // 1.9.17: --all-apps / --include 통합 모드
+  if (has('--all-apps') || arg('--include', null)) {
+    return _handoffWorkspace(absRoot(root));
+  }
+  return handoff(root);
+}
+
+// 1.9.17: 워크스페이스 통합 reuse-map — Capability 중복 자동 감지
+// 1.9.18: element에서 함수명 추출, notes에서 depends-on 추출
+function _extractFunctionName(element) {
+  // "src/build.js (escapeHtml)" → "escapeHtml"
+  // "src/openMeteo.js (fetchBatch)" → "fetchBatch"
+  // "src/cities.js" → null
+  const m = String(element).match(/\(([A-Za-z_$][\w$]*)\s*\)?\s*$/);
+  return m ? m[1] : null;
+}
+function _extractFilePath(element) {
+  // "src/build.js (escapeHtml)" → "src/build.js"
+  // "src/cities.js" → "src/cities.js"
+  const m = String(element).match(/^([^\s(]+)/);
+  return m ? m[1] : null;
+}
+function _extractDependsOn(notes) {
+  // notes 컬럼에서 "depends-on: A, B" 또는 "depends: A" 패턴 추출
+  const m = String(notes).match(/depends(?:-on)?:\s*([^|]+?)(?:\s*\)|$)/i);
+  if (!m) return [];
+  return m[1].split(/[,;]/).map(s => s.trim()).filter(Boolean);
+}
+
+function _readReuseMap(root) {
+  const p = path.join(root, '.harness', 'reuse-map.md');
+  if (!exists(p)) return [];
+  const txt = read(p);
+  const lines = txt.split('\n');
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i].trim();
+    // skip header + separator + empty
+    if (!l.startsWith('|') || l.startsWith('|--') || /^\|\s*Capability\s*\|/i.test(l)) continue;
+    const cells = l.split('|').map(c => c.trim()).filter((_, idx, arr) => idx !== 0 && idx !== arr.length - 1);
+    if (cells.length < 2 || !cells[0]) continue;
+    const notes = cells[3] || '';
+    out.push({
+      capability: cells[0],
+      element: cells[1] || '',
+      method: cells[2] || '',
+      notes,
+      line: i + 1,
+      // 1.9.18: 파생 필드
+      functionName: _extractFunctionName(cells[1] || ''),
+      filePath: _extractFilePath(cells[1] || ''),
+      dependsOn: _extractDependsOn(notes)
+    });
+  }
+  return out;
+}
+
+function reuseMapCmd(root) {
+  root = absRoot(root || process.cwd());
+  // 단일 프로젝트 모드
+  if (!has('--all-apps') && !arg('--include', null)) {
+    const entries = _readReuseMap(root);
+    if (has('--json')) { log(JSON.stringify({ project: path.basename(root), entries }, null, 2)); return; }
+    log(`# Reuse Map — ${path.basename(root)} (${entries.length}개)`);
+    if (!entries.length) { log('  (없음) — 새 컴포넌트/유틸 추가 후 등록 권장'); return; }
+    entries.forEach(e => {
+      const dep = e.dependsOn.length ? ` ← depends: ${e.dependsOn.join(', ')}` : '';
+      log(`  - ${e.capability} → ${e.element} [${e.method}] ${e.notes}${dep}`);
+    });
+    return;
+  }
+  // 워크스페이스 모드
+  const paths = _collectWorkspacePaths(root);
+  if (!paths.length) return fail('대상 프로젝트 없음. --include 또는 --all-apps 사용.');
+  const strictElements = has('--strict-elements');
+  const byCap = new Map();   // capability(lowercase) → [{ project, entry }]
+  const byFunc = new Map();  // functionName → [{ project, entry }]    // 1.9.18
+  const dependsEdges = [];   // 1.9.18: { from: {project, cap}, to: cap }
+  const projects = paths.map(p => {
+    const entries = _readReuseMap(p);
+    for (const e of entries) {
+      const k = e.capability.toLowerCase().trim();
+      if (!byCap.has(k)) byCap.set(k, []);
+      byCap.get(k).push({ project: path.basename(p), path: p, entry: e });
+      // 1.9.18: function-name 인덱스
+      if (e.functionName) {
+        const fk = e.functionName.toLowerCase();
+        if (!byFunc.has(fk)) byFunc.set(fk, []);
+        byFunc.get(fk).push({ project: path.basename(p), path: p, entry: e });
+      }
+      // 1.9.18: depends-on 엣지
+      for (const dep of e.dependsOn) {
+        dependsEdges.push({ from: { project: path.basename(p), cap: e.capability }, to: dep });
+      }
+    }
+    return { project: path.basename(p), path: p, entries };
+  });
+  // exact capability 중복
+  const dupes = [...byCap.entries()].filter(([, occ]) => occ.length >= 2);
+  // 1.9.18: --strict-elements: 같은 함수명이 다른 capability로 등록된 경우 잠재 중복
+  const funcDupes = strictElements ? [...byFunc.entries()].filter(([, occ]) => {
+    if (occ.length < 2) return false;
+    // 정확 capability 중복이 아닌 경우만 (이미 dupes로 잡힌 건 제외)
+    const caps = new Set(occ.map(o => o.entry.capability.toLowerCase()));
+    return caps.size >= 2;
+  }) : [];
+
+  if (has('--json')) {
+    const duplicates = dupes.map(([cap, occ]) => ({ capability: cap, occurrences: occ.length, projects: occ.map(o => o.project) }));
+    const fuzzyDuplicates = funcDupes.map(([fn, occ]) => ({
+      functionName: fn,
+      occurrences: occ.length,
+      entries: occ.map(o => ({ project: o.project, capability: o.entry.capability, element: o.entry.element }))
+    }));
+    log(JSON.stringify({
+      workspace: path.basename(root),
+      projects,
+      duplicates,
+      fuzzyDuplicates,
+      dependsEdges,
+      totalCapabilities: byCap.size,
+      strictElements
+    }, null, 2));
+    return;
+  }
+  log(`# Workspace Reuse Map — ${paths.length}개 프로젝트 / ${byCap.size}개 capability (1.9.18)`);
+  log('');
+  log(`## 프로젝트별 등록 수`);
+  projects.forEach(p => log(`  ${p.project}: ${p.entries.length}개`));
+
+  log('');
+  log(`## 🔁 정확 중복 capability (이름 동일)`);
+  if (!dupes.length) log('  (없음) — 모든 capability 이름이 단일 프로젝트에만 존재');
+  else {
+    for (const [cap, occ] of dupes) {
+      log(`  - "${occ[0].entry.capability}" — ${occ.length}개 프로젝트`);
+      for (const o of occ) log(`    · ${o.project}: ${o.entry.element} [${o.entry.method}]`);
+    }
+    log('');
+    log(`  💡 권장: 가장 안정적인 1개 구현을 추출해 ${dupes.length}건 중복을 공통 모듈로 통합 검토`);
+  }
+
+  // 1.9.18→1.9.19: --strict-elements 결과 (false-positive 줄이기 위해 same-file vs diff-file 구분)
+  if (strictElements) {
+    log('');
+    log(`## 🔍 잠재 중복 (--strict-elements: 함수명 동일 / capability 이름 다름)`);
+    if (!funcDupes.length) log('  (없음) — 동일 함수명을 다른 capability로 등록한 경우 없음');
+    else {
+      let exactMatches = 0; // 같은 파일 + 같은 함수 (진짜 중복 가능성 ↑)
+      let intentionalSplits = 0; // 같은 함수 / 다른 파일 (의도 분리 가능성 ↑)
+      for (const [fn, occ] of funcDupes) {
+        const files = new Set(occ.map(o => o.entry.filePath));
+        const sameFile = files.size === 1;
+        const tag = sameFile ? '⚠ 진짜 중복 가능' : 'ℹ 의도 분리 가능';
+        if (sameFile) exactMatches++; else intentionalSplits++;
+        log(`  - 함수 "${fn}()" — ${occ.length}건  ${tag}`);
+        for (const o of occ) log(`    · ${o.project}/${o.entry.capability}: ${o.entry.element}`);
+      }
+      log('');
+      if (exactMatches > 0) log(`  ⚠ 같은 파일 + 같은 함수: ${exactMatches}건 — 명명 통일 또는 실제 통합 검토`);
+      if (intentionalSplits > 0) log(`  ℹ 다른 파일 + 같은 함수: ${intentionalSplits}건 — 의도된 분리(예: 모듈 함수 vs CLI 명령)일 가능성. 보고용`);
+    }
+  }
+
+  // 1.9.18: depends-on 그래프
+  if (dependsEdges.length) {
+    log('');
+    log(`## 🔗 의존 관계 (depends-on, ${dependsEdges.length}개 엣지)`);
+    for (const e of dependsEdges) log(`  - ${e.from.project}/${e.from.cap}  ─→  ${e.to}`);
+    log('');
+    log(`  💡 의존 capability는 제거하지 말 것. depends-on 표기: \`notes\` 컬럼에 "depends-on: A, B"`);
+  }
+
+  log('');
+  const fuzzyCount = funcDupes.length;
+  log(`## 📊 워크스페이스 총합: capability ${byCap.size}건 / 정확 중복 ${dupes.length}건${strictElements ? ` / 잠재 중복 ${fuzzyCount}건` : ''} / 의존 ${dependsEdges.length}건`);
+  if (!strictElements) log(`  💡 \`--strict-elements\`로 함수명 기반 잠재 중복도 탐지 가능`);
+}
+
+// 1.9.18: verify-claim — progress-tracker의 evidence 컬럼 자동 검증
+// "src/foo.js + 5개 테스트 (54/54 통과)" 같은 주장을 파싱해 실제 파일/카운트 확인
+function verifyClaimCmd(root, taskId) {
+  root = absRoot(root);
+  if (!taskId) return fail('verify-claim <T-ID> 필요. 예: leerness verify-claim T-0008');
+  const rows = readProgressRows(root);
+  const row = rows.find(r => r.id === taskId);
+  if (!row) return fail(`progress-tracker.md에 ${taskId} 없음.`);
+
+  const evidence = row.evidence || '';
+  // 파일 경로 추출: src/x.js, bin/y.js, tests/z.js 등
+  const filePatterns = evidence.match(/(?:src|bin|tests|public|lib)\/[\w./-]+\.(?:js|ts|html|css|json|md|webmanifest|xml)/g) || [];
+  const files = Array.from(new Set(filePatterns));
+  // 테스트 수 / pass 비율: "X/Y 통과" 또는 "X개 테스트"
+  const passMatch = evidence.match(/(\d+)\s*\/\s*(\d+)\s*(통과|passed|pass)/);
+  const testCountMatch = evidence.match(/(\d+)\s*개\s*테스트/);
+  const declaredPass = passMatch ? { num: parseInt(passMatch[1], 10), denom: parseInt(passMatch[2], 10) } : null;
+  const declaredTestCount = testCountMatch ? parseInt(testCountMatch[1], 10) : null;
+
+  // 실제 파일 존재 검사
+  const fileChecks = files.map(f => ({ file: f, exists: exists(path.join(root, f)) }));
+  // 테스트 카운트: tests/test.js의 check( 또는 it( 또는 test( 개수
+  let actualTestCount = null;
+  const candidateTestFiles = ['tests/test.js', 'test/test.js', 'tests/index.js'];
+  for (const tf of candidateTestFiles) {
+    const tp = path.join(root, tf);
+    if (exists(tp)) {
+      const t = read(tp);
+      actualTestCount = (t.match(/\bcheck\s*\(/g) || t.match(/\b(it|test)\s*\(/g) || []).length;
+      break;
+    }
+  }
+
+  // 1.9.19: --run-tests — npm test 자동 실행 + pass/fail 파싱
+  let runResult = null;
+  if (has('--run-tests')) {
+    const pkgPath = path.join(root, 'package.json');
+    if (!exists(pkgPath)) {
+      runResult = { skipped: true, reason: 'package.json 없음' };
+    } else {
+      let pkg = null;
+      try { pkg = JSON.parse(read(pkgPath)); } catch {}
+      const hasTestScript = pkg && pkg.scripts && pkg.scripts.test;
+      if (!hasTestScript) {
+        runResult = { skipped: true, reason: 'scripts.test 없음' };
+      } else {
+        const r = cp.spawnSync('npm test', [], { cwd: root, encoding: 'utf8', shell: true, timeout: 5 * 60 * 1000 });
+        const out = (r.stdout || '') + (r.stderr || '');
+        // "54/54 passed" 또는 "54/54 통과" 등을 파싱
+        const m = out.match(/(\d+)\s*\/\s*(\d+)\s*(?:passed|통과|pass)/);
+        runResult = {
+          skipped: false,
+          exitCode: r.status,
+          parsed: m ? { num: parseInt(m[1], 10), denom: parseInt(m[2], 10) } : null,
+          allPassed: r.status === 0 && (!m || (m && m[1] === m[2]))
+        };
+      }
+    }
+  }
+
+  if (has('--json')) {
+    const out = {
+      project: path.basename(root),
+      taskId, row,
+      declared: { files: files.length, pass: declaredPass, testCount: declaredTestCount },
+      actual: { fileChecks, testCount: actualTestCount },
+      verdict: {
+        filesAllExist: fileChecks.every(c => c.exists),
+        testCountMatch: declaredTestCount == null || actualTestCount == null || actualTestCount >= declaredTestCount
+      }
+    };
+    if (runResult) {
+      out.run = runResult;
+      out.verdict.runTests = !!runResult.allPassed;
+      // declared pass와 실제 비교
+      if (declaredPass && runResult.parsed) {
+        out.verdict.declaredPassMatches = (runResult.parsed.num === declaredPass.num && runResult.parsed.denom === declaredPass.denom);
+      }
+    }
+    log(JSON.stringify(out, null, 2));
+    if (runResult && !runResult.skipped && !runResult.allPassed) return process.exit(1);
+    if (!out.verdict.filesAllExist || !out.verdict.testCountMatch) return process.exit(1);
+    return;
+  }
+
+  log(`# verify-claim ${taskId} (${path.basename(root)})`);
+  log(`Request: ${row.request}`);
+  log(`Status: ${row.status}  ·  Updated: ${row.updated}`);
+  log(`Evidence: ${evidence.slice(0, 200)}${evidence.length > 200 ? '…' : ''}`);
+  log('');
+  log(`## 📂 파일 검증 (${files.length}건 주장)`);
+  if (!files.length) log('  (evidence에서 파일 경로를 추출하지 못함)');
+  else {
+    for (const c of fileChecks) log(`  ${c.exists ? '✓' : '✗'} ${c.file}${c.exists ? '' : '  ← 누락'}`);
+  }
+  log('');
+  log(`## 🧪 테스트 카운트`);
+  if (declaredPass) log(`  주장 (pass): ${declaredPass.num}/${declaredPass.denom}`);
+  if (declaredTestCount) log(`  주장 (개수): ${declaredTestCount}개`);
+  if (actualTestCount != null) log(`  실측: tests/test.js에 ${actualTestCount}개 check/test 호출`);
+  else log(`  실측: 테스트 파일 못 찾음 (tests/test.js 등)`);
+
+  // 1.9.19: --run-tests 결과
+  let runTestsOk = true;
+  let declaredPassMatchesActual = true;
+  if (runResult) {
+    log('');
+    log(`## 🚦 npm test 실행 (--run-tests)`);
+    if (runResult.skipped) {
+      log(`  ⚠ skipped: ${runResult.reason}`);
+    } else {
+      log(`  exit: ${runResult.exitCode}`);
+      if (runResult.parsed) log(`  실행 결과: ${runResult.parsed.num}/${runResult.parsed.denom} ${runResult.parsed.num === runResult.parsed.denom ? 'passed' : 'partial'}`);
+      else log(`  (pass/fail 비율을 stdout에서 파싱 못함)`);
+      runTestsOk = runResult.allPassed;
+      if (declaredPass && runResult.parsed) {
+        declaredPassMatchesActual = (runResult.parsed.num === declaredPass.num && runResult.parsed.denom === declaredPass.denom);
+        log(`  주장 vs 실행: ${declaredPassMatchesActual ? '✓ 일치' : `⚠ 불일치 (주장 ${declaredPass.num}/${declaredPass.denom} ≠ 실행 ${runResult.parsed.num}/${runResult.parsed.denom})`}`);
+      }
+    }
+  }
+
+  log('');
+  const allFilesOk = fileChecks.every(c => c.exists);
+  const testOk = declaredTestCount == null || actualTestCount == null || actualTestCount >= declaredTestCount;
+  log(`## 종합`);
+  log(`  - 파일 모두 존재: ${allFilesOk ? '✓ pass' : '✗ FAIL (일부 누락)'}`);
+  log(`  - 테스트 카운트: ${testOk ? '✓ pass (실측 ≥ 주장)' : '⚠ 주장보다 적음'}`);
+  if (runResult && !runResult.skipped) {
+    log(`  - npm test 실행: ${runTestsOk ? '✓ all passed' : '✗ FAIL'}`);
+    if (declaredPass) log(`  - 주장과 실행 결과 일치: ${declaredPassMatchesActual ? '✓ pass' : '⚠ 다름'}`);
+  }
+  const overallFail = !allFilesOk || !testOk || (runResult && !runResult.skipped && !runTestsOk);
+  if (overallFail) {
+    log('');
+    log(`  ⚠ evidence 주장과 실제가 일치하지 않음 — task 상태 재검토 권장`);
+    return process.exit(1);
+  }
+  log('');
+  log(`  ✓ evidence 주장이 실제 파일·테스트${runResult && !runResult.skipped ? '·실행 결과' : ''}와 일치`);
+}
+
 function sessionClose(root) {
   root = absRoot(root);
   const rows = readProgressRows(root);
@@ -3195,7 +3619,7 @@ function viewworkInstall(root) {
 }
 
 function help() {
-  log(`Leerness v${VERSION}\n\nUsage:\n  leerness init [path] [--language auto|ko|en] [--skills recommended|all|a,b]\n  leerness migrate [path] [--dry-run] [--force]\n  leerness update [path] [--check|--yes|--force|--from <tarball>]\n  leerness auto-update install [path]\n  leerness status [path]\n  leerness verify [path]\n  leerness debug [path]\n  leerness audit [path]\n  leerness check [path]\n  leerness scan secrets [path]\n  leerness encoding check [path]\n  leerness lazy detect [path]\n  leerness memory search "query" [--limit 5]\n  leerness handoff [path]\n  leerness session close [path]\n  leerness viewwork install [path]\n  leerness viewwork emit [path] [--action a] [--note n] [--agent x] [--tool t]\n  leerness route <task-type>\n  leerness self check [path]\n  leerness readme sync [path]\n  leerness consistency check [path]\n  leerness consistency merge-design-guide [path]\n  leerness plan show|init|add|drop|progress|sync [args]\n  leerness task list|add|update|drop|fix-evidence|relink [args]\n  leerness skill list|info <name>\n  leerness skill learn <id> --doc <url> --command "..." --capability "..." [--note ...]\n  leerness skill use <id> [--note ...]\n  leerness skill optimize <id> --before "..." --after "..." [--note ...]\n  leerness skill remove <id>\n  leerness skill consolidate [--threshold 0.3]\n  leerness gate [path]                       # verify+audit+scan+encoding+lazy
+  log(`Leerness v${VERSION}\n\nUsage:\n  leerness init [path] [--language auto|ko|en] [--skills recommended|all|a,b]\n  leerness migrate [path] [--dry-run] [--force]\n  leerness update [path] [--check|--yes|--force|--from <tarball>]\n  leerness auto-update install [path]\n  leerness status [path]\n  leerness verify [path]\n  leerness debug [path]\n  leerness audit [path]\n  leerness check [path]\n  leerness scan secrets [path]\n  leerness encoding check [path]\n  leerness lazy detect [path]\n  leerness memory search "query" [--limit 5]\n  leerness handoff [path] [--all-apps] [--include p1,p2] [--since 24h|3d] [--json]   # 1.9.17/18 워크스페이스\n  leerness reuse-map [path] [--all-apps] [--include p1,p2] [--strict-elements] [--json] # 1.9.18 중복/잠재중복/depends-on\n  leerness verify-claim <T-ID> [--path .] [--run-tests] [--json]   # 1.9.18/19 evidence 자동 검증 (+npm test 동적)\n  leerness session close [path]\n  leerness viewwork install [path]\n  leerness viewwork emit [path] [--action a] [--note n] [--agent x] [--tool t]\n  leerness route <task-type>\n  leerness self check [path]\n  leerness readme sync [path]\n  leerness consistency check [path]\n  leerness consistency merge-design-guide [path]\n  leerness plan show|init|add|drop|progress|sync [args]\n  leerness task list|add|update|drop|fix-evidence|relink [args]\n  leerness skill list|info <name>\n  leerness skill learn <id> --doc <url> --command "..." --capability "..." [--note ...]\n  leerness skill use <id> [--note ...]\n  leerness skill optimize <id> --before "..." --after "..." [--note ...]\n  leerness skill remove <id>\n  leerness skill consolidate [--threshold 0.3]\n  leerness gate [path]                       # verify+audit+scan+encoding+lazy
   leerness retro [path] [--days 7] [--all-apps] [--include p1,p2] [--json]  # 회고 (1.9.13~1.9.16)
   leerness insights [path] [--all-apps] [--include p1,p2] [--json]         # 누적 통계 (1.9.13~1.9.16)
   leerness brainstorm "<주제>" [--all-apps] [--include p1,p2] [--json]    # 브레인스토밍 (1.9.13~1.9.16)
@@ -3228,7 +3652,9 @@ async function main() {
   if (cmd === 'encoding' && args[1] === 'check') return encodingCheck(args[2] || process.cwd());
   if (cmd === 'lazy' && args[1] === 'detect')    return lazyDetect(args[2] || process.cwd());
   if (cmd === 'memory' && args[1] === 'search')  return memorySearch(arg('--path', process.cwd()), args.slice(2).join(' '));
-  if (cmd === 'handoff')   return handoff(args[1] || process.cwd());
+  if (cmd === 'handoff')      return handoffCmd(args[1] || process.cwd());
+  if (cmd === 'reuse-map')    return reuseMapCmd(args[1] || process.cwd());
+  if (cmd === 'verify-claim') return verifyClaimCmd(arg('--path', process.cwd()), args[1]);
   if (cmd === 'session' && args[1] === 'close') { const r = sessionClose(args[2] || process.cwd()); viewworkEmit(args[2] || process.cwd(), { action: 'task', tool: 'session-close', note: 'session close' }); return r; }
   if (cmd === 'viewwork' && args[1] === 'install') return viewworkInstall(args[2] || process.cwd());
   if (cmd === 'viewwork' && args[1] === 'emit')    return viewworkEmit(args[2] || process.cwd(), { action: arg('--action','task'), note: arg('--note',''), agent: arg('--agent','leerness'), tool: arg('--tool','leerness-cli') });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.9.16",
+  "version": "1.9.19",
   "description": "Leerness: 비파괴 마이그레이션, 자동 버전 감지·업데이트, 계획/진행/핸드오프 자동화, 게으름·시크릿·인코딩 자동 가드, Claude Code 슬래시 통합을 갖춘 한국어 우선 AI 개발 하네스.",
   "keywords": [
     "leerness",

package/scripts/e2e.js

@@ -312,6 +312,237 @@ total++;
   if (!ok) { failed++; console.log(r.stdout.slice(-500)); }
 }
 
+// 1.9.17 회귀: handoff --all-apps / reuse-map --all-apps (워크스페이스 오케스트레이션)
+total++;
+{
+  // handoff --include
+  const tmpA = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-ha-'));
+  const tmpB = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-hb-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpA, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpB, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  const r = cp.spawnSync(process.execPath, [CLI, 'handoff', '--include', `${tmpA},${tmpB}`], { encoding: 'utf8', timeout: 15000, cwd: os.tmpdir() });
+  const ok = r.status === 0 && /Workspace Handoff — 2개 프로젝트 \(1\.9\.1[78]\)/.test(r.stdout) && /워크스페이스 총합/.test(r.stdout) && /오케스트레이션 권장/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.17) handoff --include 통합 워크스페이스 뷰' : '✗ handoff --include 실패');
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 600)); }
+}
+
+total++;
+{
+  // handoff --include --json
+  const tmpA = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-haj-'));
+  const tmpB = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-hbj-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpA, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpB, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  const r = cp.spawnSync(process.execPath, [CLI, 'handoff', '--include', `${tmpA},${tmpB}`, '--json'], { encoding: 'utf8', timeout: 15000, cwd: os.tmpdir() });
+  let parsed = null;
+  try { parsed = JSON.parse(r.stdout); } catch {}
+  const ok = r.status === 0 && parsed && Array.isArray(parsed.projects) && parsed.projects.length === 2 && parsed.totals;
+  console.log(ok ? '✓ B(1.9.17) handoff --include --json' : '✗ handoff --json 실패');
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+total++;
+{
+  // reuse-map 단일 + 워크스페이스 모드 + 중복 감지
+  const tmpA = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-rma-'));
+  const tmpB = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-rmb-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpA, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpB, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  // 양쪽에 같은 capability "Cache" 추가 → 중복 감지 기대
+  const rowA = '| Cache | src/cache.js | util | LRU |\n';
+  const rowB = '| Cache | src/foo.js | util | Memoize |\n';
+  fs.appendFileSync(path.join(tmpA, '.harness/reuse-map.md'), rowA);
+  fs.appendFileSync(path.join(tmpB, '.harness/reuse-map.md'), rowB);
+  // 단일
+  const rs = cp.spawnSync(process.execPath, [CLI, 'reuse-map', tmpA], { encoding: 'utf8', timeout: 15000 });
+  const okSingle = rs.status === 0 && /Reuse Map/.test(rs.stdout) && /Cache/.test(rs.stdout);
+  // 워크스페이스
+  const rw = cp.spawnSync(process.execPath, [CLI, 'reuse-map', '--include', `${tmpA},${tmpB}`], { encoding: 'utf8', timeout: 15000, cwd: os.tmpdir() });
+  const okMulti = rw.status === 0 && /Workspace Reuse Map — 2개 프로젝트/.test(rw.stdout) && /중복 capability/.test(rw.stdout) && /"Cache"/.test(rw.stdout);
+  // JSON
+  const rj = cp.spawnSync(process.execPath, [CLI, 'reuse-map', '--include', `${tmpA},${tmpB}`, '--json'], { encoding: 'utf8', timeout: 15000, cwd: os.tmpdir() });
+  let parsed = null;
+  try { parsed = JSON.parse(rj.stdout); } catch {}
+  const okJson = rj.status === 0 && parsed && Array.isArray(parsed.duplicates) && parsed.duplicates.length >= 1;
+  const ok = okSingle && okMulti && okJson;
+  console.log(ok ? '✓ B(1.9.17) reuse-map 단일/워크스페이스/JSON + 중복 감지' : `✗ reuse-map 실패 (단일=${okSingle} 멀티=${okMulti} JSON=${okJson})`);
+  if (!ok) { failed++; console.log(rw.stdout.slice(0, 400)); }
+}
+
+// 1.9.18 회귀: handoff --since / reuse-map --strict-elements + depends-on / verify-claim
+total++;
+{
+  // handoff --since: 최근 변경 강조
+  const tmpA = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-sincea-'));
+  const tmpB = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-sinceb-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpA, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpB, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  // 오늘 날짜로 T-row 추가
+  const today = new Date().toISOString().slice(0,10);
+  fs.appendFileSync(path.join(tmpA, '.harness/progress-tracker.md'), `| T-9999 | done | 신규 기능 | src/x.js | M-NEW | ${today} |\n`);
+  const r = cp.spawnSync(process.execPath, [CLI, 'handoff', '--include', `${tmpA},${tmpB}`, '--since', '1d'], { encoding: 'utf8', timeout: 15000, cwd: os.tmpdir() });
+  const ok = r.status === 0 && /1\.9\.18/.test(r.stdout) && /Filter: since 1d/.test(r.stdout) && /🆕/.test(r.stdout) && /최근 변경/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.18) handoff --since: 최근 변경 강조' : '✗ handoff --since 실패');
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 500)); }
+}
+
+total++;
+{
+  // handoff --since 형식 오류 → fail
+  const tmpE = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-sincee-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpE, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  const r = cp.spawnSync(process.execPath, [CLI, 'handoff', '--include', tmpE, '--since', 'banana'], { encoding: 'utf8', timeout: 15000, cwd: os.tmpdir() });
+  const ok = r.status !== 0 && /형식 오류/.test(r.stdout + r.stderr);
+  console.log(ok ? '✓ B(1.9.18) handoff --since 형식 오류 → exit≠0' : '✗ handoff --since 오류 검증 실패');
+  if (!ok) failed++;
+}
+
+total++;
+{
+  // reuse-map --strict-elements: 같은 함수명 다른 capability 감지
+  const tmpA = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-strict-a-'));
+  const tmpB = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-strict-b-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpA, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpB, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  // 같은 함수 escapeHtml을 다른 capability 이름으로 등록
+  fs.appendFileSync(path.join(tmpA, '.harness/reuse-map.md'), '| HtmlEscape | src/util.js (escapeHtml) | util | XSS 방지 |\n');
+  fs.appendFileSync(path.join(tmpB, '.harness/reuse-map.md'), '| EscapeHtml | src/build.js (escapeHtml) | util | 마크업 이스케이프 |\n');
+  // 기본 모드 → 정확 중복 0
+  const r1 = cp.spawnSync(process.execPath, [CLI, 'reuse-map', '--include', `${tmpA},${tmpB}`], { encoding: 'utf8', timeout: 15000, cwd: os.tmpdir() });
+  const okDefault = r1.status === 0 && /정확 중복 capability/.test(r1.stdout) && /\(없음\)/.test(r1.stdout);
+  // --strict-elements → 잠재 중복 1건
+  const r2 = cp.spawnSync(process.execPath, [CLI, 'reuse-map', '--include', `${tmpA},${tmpB}`, '--strict-elements'], { encoding: 'utf8', timeout: 15000, cwd: os.tmpdir() });
+  const okStrict = r2.status === 0 && /잠재 중복/.test(r2.stdout) && /escapeHtml/.test(r2.stdout) && /HtmlEscape/.test(r2.stdout) && /EscapeHtml/.test(r2.stdout);
+  // JSON
+  const r3 = cp.spawnSync(process.execPath, [CLI, 'reuse-map', '--include', `${tmpA},${tmpB}`, '--strict-elements', '--json'], { encoding: 'utf8', timeout: 15000, cwd: os.tmpdir() });
+  let parsed = null;
+  try { parsed = JSON.parse(r3.stdout); } catch {}
+  const okJson = r3.status === 0 && parsed && Array.isArray(parsed.fuzzyDuplicates) && parsed.fuzzyDuplicates.length === 1 && parsed.fuzzyDuplicates[0].functionName === 'escapehtml';
+  const ok = okDefault && okStrict && okJson;
+  console.log(ok ? '✓ B(1.9.18) reuse-map --strict-elements 잠재 중복 감지' : `✗ strict-elements 실패 (default=${okDefault} strict=${okStrict} json=${okJson})`);
+  if (!ok) { failed++; console.log(r2.stdout.slice(0, 500)); }
+}
+
+total++;
+{
+  // reuse-map depends-on: notes 컬럼에서 의존 추출
+  const tmpA = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-deps-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpA, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  fs.appendFileSync(path.join(tmpA, '.harness/reuse-map.md'),
+    '| EscapeHtml | src/build.js (escapeHtml) | util | XSS 방지 |\n' +
+    '| RssFeed | src/build.js (buildFeed) | util | RSS 2.0 (depends-on: EscapeHtml) |\n');
+  const r = cp.spawnSync(process.execPath, [CLI, 'reuse-map', '--include', tmpA], { encoding: 'utf8', timeout: 15000, cwd: os.tmpdir() });
+  const ok = r.status === 0 && /의존 관계 \(depends-on, 1개 엣지\)/.test(r.stdout) && /RssFeed.*─→.*EscapeHtml/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.18) reuse-map depends-on 엣지 추출' : '✗ depends-on 실패');
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 500)); }
+}
+
+total++;
+{
+  // verify-claim: 파일 존재 + 테스트 카운트 검증
+  const tmpV = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-vc-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpV, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  // 실제 src 파일 + 테스트 파일 생성 (5개 check)
+  fs.mkdirSync(path.join(tmpV, 'src'), { recursive: true });
+  fs.mkdirSync(path.join(tmpV, 'tests'), { recursive: true });
+  fs.writeFileSync(path.join(tmpV, 'src/myMod.js'), 'module.exports = {};\n');
+  fs.writeFileSync(path.join(tmpV, 'tests/test.js'), 'check(1); check(2); check(3); check(4); check(5);\n');
+  // T-row를 evidence와 함께 추가
+  fs.appendFileSync(path.join(tmpV, '.harness/progress-tracker.md'),
+    '| T-0099 | done | 신모듈 | src/myMod.js + tests/test.js (5/5 통과) | next | 2026-05-14 |\n');
+  // 정상: 파일 존재 + 테스트 5개
+  const r = cp.spawnSync(process.execPath, [CLI, 'verify-claim', 'T-0099', '--path', tmpV], { encoding: 'utf8', timeout: 15000 });
+  const okPass = r.status === 0 && /✓ src\/myMod\.js/.test(r.stdout) && /✓ tests\/test\.js/.test(r.stdout) && /pass \(실측 ≥ 주장\)/.test(r.stdout);
+  // 파일 없는 케이스 → exit ≠ 0
+  fs.unlinkSync(path.join(tmpV, 'src/myMod.js'));
+  const r2 = cp.spawnSync(process.execPath, [CLI, 'verify-claim', 'T-0099', '--path', tmpV], { encoding: 'utf8', timeout: 15000 });
+  const okFail = r2.status !== 0 && /✗ src\/myMod\.js/.test(r2.stdout) && /FAIL/.test(r2.stdout);
+  // JSON
+  const r3 = cp.spawnSync(process.execPath, [CLI, 'verify-claim', 'T-0099', '--path', tmpV, '--json'], { encoding: 'utf8', timeout: 15000 });
+  let parsed = null;
+  try { parsed = JSON.parse(r3.stdout); } catch {}
+  const okJson = parsed && parsed.taskId === 'T-0099' && parsed.verdict && parsed.verdict.filesAllExist === false;
+  const ok = okPass && okFail && okJson;
+  console.log(ok ? '✓ B(1.9.18) verify-claim 파일/테스트 검증 + exit code + JSON' : `✗ verify-claim 실패 (pass=${okPass} fail=${okFail} json=${okJson})`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+// 1.9.19 회귀: verify-claim --run-tests + --strict-elements same-file 구분
+total++;
+{
+  // verify-claim --run-tests: npm test 자동 실행 + 주장 vs 실행 결과 대조
+  const tmpR = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-rt-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpR, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  // 최소 npm 프로젝트 + 단순 tests/test.js (5/5 pass)
+  fs.writeFileSync(path.join(tmpR, 'package.json'), JSON.stringify({
+    name: 'rt-fixture', version: '0.0.1', scripts: { test: 'node tests/test.js' }
+  }));
+  fs.mkdirSync(path.join(tmpR, 'src'), { recursive: true });
+  fs.mkdirSync(path.join(tmpR, 'tests'), { recursive: true });
+  fs.writeFileSync(path.join(tmpR, 'src/mod.js'), 'module.exports={};\n');
+  // 5 check 호출 + "5/5 passed" 직접 출력 (간단한 fixture)
+  fs.writeFileSync(path.join(tmpR, 'tests/test.js'),
+    "let p=0;function check(c){if(c)p++;}check(1);check(1);check(1);check(1);check(1);console.log(p+'/5 passed');if(p!==5)process.exit(1);\n");
+  fs.appendFileSync(path.join(tmpR, '.harness/progress-tracker.md'),
+    '| T-0050 | done | rt 작업 | src/mod.js + tests/test.js (5/5 통과) | next | 2026-05-14 |\n');
+  const r = cp.spawnSync(process.execPath, [CLI, 'verify-claim', 'T-0050', '--path', tmpR, '--run-tests'], { encoding: 'utf8', timeout: 60000 });
+  const ok = r.status === 0
+    && /npm test 실행 \(--run-tests\)/.test(r.stdout)
+    && /실행 결과: 5\/5 passed/.test(r.stdout)
+    && /주장 vs 실행: ✓ 일치/.test(r.stdout)
+    && /npm test 실행: ✓ all passed/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.19) verify-claim --run-tests: npm test 실행 + 주장 일치' : '✗ --run-tests 실패');
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 600)); }
+}
+
+total++;
+{
+  // --run-tests 실패 케이스: 5/5 주장 vs 실제 3/5 실행 → 불일치 + exit 1
+  const tmpF = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-rtf-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpF, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  fs.writeFileSync(path.join(tmpF, 'package.json'), JSON.stringify({ name: 'rtf', version: '0.0.1', scripts: { test: 'node tests/test.js' } }));
+  fs.mkdirSync(path.join(tmpF, 'src'), { recursive: true });
+  fs.mkdirSync(path.join(tmpF, 'tests'), { recursive: true });
+  fs.writeFileSync(path.join(tmpF, 'src/mod.js'), 'module.exports={};\n');
+  fs.writeFileSync(path.join(tmpF, 'tests/test.js'),
+    "console.log('3/5 passed'); process.exit(1);\n");
+  fs.appendFileSync(path.join(tmpF, '.harness/progress-tracker.md'),
+    '| T-0051 | done | 거짓 | src/mod.js + tests/test.js (5/5 통과) | next | 2026-05-14 |\n');
+  const r = cp.spawnSync(process.execPath, [CLI, 'verify-claim', 'T-0051', '--path', tmpF, '--run-tests'], { encoding: 'utf8', timeout: 60000 });
+  const ok = r.status !== 0
+    && /불일치/.test(r.stdout)
+    && /npm test 실행: ✗ FAIL/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.19) verify-claim --run-tests: 주장/실행 불일치 → exit≠0' : '✗ --run-tests 불일치 검증 실패');
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 600)); }
+}
+
+total++;
+{
+  // --strict-elements: same-file ⚠ vs diff-file ℹ 구분
+  const tmpA = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-strict2-a-'));
+  const tmpB = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-strict2-b-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpA, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpB, '--yes', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  // 같은 파일 + 같은 함수 (다른 capability 이름) — 진짜 중복 가능
+  fs.appendFileSync(path.join(tmpA, '.harness/reuse-map.md'),
+    '| FormatX | src/util.js (format) | util | A |\n');
+  fs.appendFileSync(path.join(tmpB, '.harness/reuse-map.md'),
+    '| FormatY | src/util.js (format) | util | B |\n');
+  // 다른 파일 + 같은 함수 — 의도 분리 가능
+  fs.appendFileSync(path.join(tmpA, '.harness/reuse-map.md'),
+    '| Stats1 | src/memo.js (stats) | util | A |\n');
+  fs.appendFileSync(path.join(tmpB, '.harness/reuse-map.md'),
+    '| Stats2 | bin/cli.js (stats) | command | B |\n');
+  const r = cp.spawnSync(process.execPath, [CLI, 'reuse-map', '--include', `${tmpA},${tmpB}`, '--strict-elements'], { encoding: 'utf8', timeout: 15000, cwd: os.tmpdir() });
+  const ok = r.status === 0
+    && /⚠ 진짜 중복 가능/.test(r.stdout)
+    && /ℹ 의도 분리 가능/.test(r.stdout)
+    && /같은 파일 \+ 같은 함수: 1건/.test(r.stdout)
+    && /다른 파일 \+ 같은 함수: 1건/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.19) --strict-elements: same-file ⚠ vs diff-file ℹ 구분' : '✗ strict-elements 분류 실패');
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 600)); }
+}
+
 // 1.9.15 회귀: brainstorm 라인번호 / --all-apps / --include
 total++;
 {