leerness 1.9.13 → 1.9.18

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.13';
+const VERSION = '1.9.18';
 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']);
+  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];
@@ -218,7 +218,7 @@ function coreFiles(root, lang = 'ko', selectedSkills = []) {
     '.harness/protected-files.md': fm('protected-files', ['파일 삭제/정리/마이그레이션 전'], ['보호 대상 변경'], `# Protected Files\n\nAI agents must not delete or reset these files without explicit user approval.\n\n- .harness/\n- .harness/skills/\n- .harness/library/\n- AGENTS.md\n- CLAUDE.md\n- .cursor/rules/leerness.mdc\n- .github/copilot-instructions.md\n- .claude/commands/\n- .claude/skills/\n- README.md Leerness managed section\n\nUse merge, archive, or deprecated markers instead of deletion.\n`),
     '.harness/architecture.md': fm('architecture', ['기능 구현','리팩토링','마이그레이션'], ['구조 변경'], `# Architecture\n\n## Overview\n- 실제 구조를 기록하세요.\n\n## Data Flow\n-\n\n## External Dependencies\n-\n`),
     '.harness/context-map.md': fm('context-map', ['관련 파일 탐색','기능 구현 전'], ['파일 구조 변경'], `# Context Map\n\n| Area | Files | Notes |\n|---|---|---|\n| App | src/** | 실제 경로로 업데이트 |\n| Tests | tests/** | 검증 경로 |\n`),
-    '.harness/decisions.md': fm('decisions', ['설계 결정 확인'], ['중요 결정 발생'], `# Decisions\n\n## Template\n### ${today()} — Decision\n- Decision:\n- Reason:\n- Alternatives:\n- Impact:\n`),
+    '.harness/decisions.md': fm('decisions', ['설계 결정 확인'], ['중요 결정 발생'], `# Decisions\n\n## Template (예시 — 실제 결정은 아래 코드블록 밖에 추가)\n\n\`\`\`md\n### ${today()} — Decision 제목\n- Decision:\n- Reason:\n- Alternatives:\n- Impact:\n\`\`\`\n`),
     '.harness/task-log.md': fm('task-log', ['작업 이력 확인'], ['모든 의미 있는 작업 후'], `# Task Log\n\n## ${today()}\n- Leerness v${VERSION} initialized.\n`),
     '.harness/guardrails.md': fm('guardrails', ['모든 작업 전','보안/권한/리팩토링 전'], ['금지 규칙 변경'], `# Guardrails\n\n- 토큰/키/비밀번호를 저장하지 않습니다. 환경변수 이름만 기록합니다.\n- 요청 없는 대규모 리팩토링을 하지 않습니다 (5개 이상 파일 변경 시 사용자 사전 승인).\n- API/DB/환경변수 변경은 영향 범위를 task-log에 기록합니다.\n- Leerness 보호 파일/관리 섹션을 삭제하지 않습니다.\n- 한글 인코딩은 BOM 없는 UTF-8을 유지합니다.\n- destructive Git 작업(\`git reset --hard\`, \`git push --force\` 등)은 사용자 명시 승인 후에만 수행합니다.\n`),
     '.harness/design-system.md': fm('design-system', ['UI 변경','컴포넌트 추가','designguide 병합'], ['디자인 기준 변경','재사용 패턴 발견'], `# Design System\n\n## Canonical File\n이 파일은 designguide.md, design-guide.md와 같은 디자인 가이드의 기준 파일입니다.\n\n## Tokens\n| Token | Value | Notes |\n|---|---|---|\n| color.primary | (실제 값으로 업데이트) | |\n| color.surface | | |\n| spacing.unit | | |\n| typography.body | | |\n\n## Reusable Patterns\n| Pattern | Where | Reuse Rule |\n|---|---|---|\n`),
@@ -1200,6 +1200,359 @@ 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: --strict-elements 결과
+  if (strictElements) {
+    log('');
+    log(`## 🔍 잠재 중복 (--strict-elements: 함수명 동일 / capability 이름 다름)`);
+    if (!funcDupes.length) log('  (없음) — 동일 함수명을 다른 capability로 등록한 경우 없음');
+    else {
+      for (const [fn, occ] of funcDupes) {
+        log(`  - 함수 "${fn}()" — ${occ.length}건 (이름 다름)`);
+        for (const o of occ) log(`    · ${o.project}/${o.entry.capability}: ${o.entry.element}`);
+      }
+      log('');
+      log(`  💡 같은 함수를 다른 capability 이름으로 부르고 있을 가능성. 명명 통일 검토.`);
+    }
+  }
+
+  // 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;
+    }
+  }
+
+  if (has('--json')) {
+    log(JSON.stringify({
+      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
+      }
+    }, null, 2));
+    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 등)`);
+  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 (!allFilesOk || !testOk) {
+    log('');
+    log(`  ⚠ evidence 주장과 실제가 일치하지 않음 — task 상태 재검토 권장`);
+    return process.exit(1);
+  }
+  log('');
+  log(`  ✓ evidence 주장이 실제 파일·테스트와 일치`);
+}
+
 function sessionClose(root) {
   root = absRoot(root);
   const rows = readProgressRows(root);
@@ -1297,6 +1650,22 @@ function sessionClose(root) {
       const left = 5 - (sc.count % 5);
       log(`  💡 ${left}세션 후 자동 깊은 회고 — \`leerness retro\`로 즉시 실행 가능`);
     }
+    // 1.9.16: 워크스페이스 안내 (다른 leerness 프로젝트가 있으면)
+    try {
+      const wsCands = [path.resolve(root, '_apps'), path.resolve(root, '..', '_apps')];
+      let wsCount = 0;
+      for (const base of wsCands) {
+        if (!exists(base)) continue;
+        try { if (!fs.statSync(base).isDirectory()) continue; } catch { continue; }
+        for (const e of fs.readdirSync(base)) {
+          try {
+            const p = path.join(base, e);
+            if (fs.statSync(p).isDirectory() && exists(path.join(p, '.harness')) && p !== root) wsCount++;
+          } catch {}
+        }
+      }
+      if (wsCount > 0) log(`  🌐 워크스페이스에 ${wsCount}개 다른 leerness 프로젝트 — \`leerness retro --all-apps\`로 통합 회고`);
+    } catch {}
   } catch (e) {
     warn('retro 요약 실패: ' + (e && e.message ? e.message : e));
   }
@@ -1356,6 +1725,15 @@ function readSessionCounter(root) {
 }
 function writeSessionCounter(root, c) { writeUtf8(sessionCounterPath(root), JSON.stringify(c, null, 2) + '\n'); }
 
+// 1.9.14 A/D: 결정 블록 추출 — 코드 블록 안의 ### + Template 제외
+function _extractDecisionBlocks(text) {
+  // 줄 시작의 ```부터 줄 시작의 ```까지를 코드블록으로 인식 (인라인 백틱 무시)
+  const cleaned = String(text || '').replace(/^```[^\n]*\n[\s\S]*?\n```\s*$/gm, '');
+  return cleaned.split(/\n(?=### )/).filter(b =>
+    b.startsWith('### ') && !/^### (Template|템플릿)\b/.test(b.trim())
+  );
+}
+
 function _retroAggregate(root) {
   root = absRoot(root);
   const rows = readProgressRows(root);
@@ -1369,8 +1747,8 @@ function _retroAggregate(root) {
   for (const s of STATUSES) statusCounts[s] = 0;
   for (const r of rows) if (statusCounts[r.status] != null) statusCounts[r.status]++;
 
-  // 2) 결정 블록 수
-  const decisionBlocks = decisions.split(/\n(?=### )/).filter(b => b.startsWith('### '));
+  // 2) 결정 블록 수 (1.9.14: 코드블록/Template 제외)
+  const decisionBlocks = _extractDecisionBlocks(decisions);
   // recent decisions (날짜로 정렬 시 가장 최근)
   const recentDecisions = decisionBlocks.slice(-5).map(b => {
     const t = (b.match(/^### (.+)$/m) || [, ''])[1];
@@ -1412,9 +1790,10 @@ function _retroAggregate(root) {
   const activeRules = rules.filter(r => r.status === 'active');
   const verifiedRules = rules.filter(r => r.lastVerified && r.lastVerified !== '-');
 
-  // 7) 최근 in-progress / incomplete (우선 권장)
-  const focusNext = rows.filter(r => r.status === 'in-progress')
-    .concat(rows.filter(r => ['incomplete', 'blocked', 'waiting', 'on-hold'].includes(r.status)));
+  // 7) 다음 우선 작업 — 우선순위: in-progress > blocked/waiting/on-hold/incomplete > planned/requested (1.9.14 C)
+  const _priority = { 'in-progress': 0, 'blocked': 1, 'waiting': 1, 'on-hold': 1, 'incomplete': 1, 'planned': 2, 'requested': 2 };
+  const focusNext = rows.filter(r => _priority[r.status] != null)
+    .sort((a, b) => (_priority[a.status] || 9) - (_priority[b.status] || 9));
 
   return {
     statusCounts,
@@ -1456,11 +1835,49 @@ function _retroOneLine(agg) {
   return parts.join(' · ');
 }
 
+// 1.9.15: --all-apps / --include 경로 모음
+function _collectWorkspacePaths(rootBase) {
+  const set = new Set();
+  if (exists(path.join(rootBase, '.harness'))) set.add(rootBase);
+  if (has('--all-apps')) {
+    const baseCandidates = [path.resolve(rootBase, '_apps'), path.resolve(rootBase, '..', '_apps')];
+    for (const base of baseCandidates) {
+      if (!exists(base)) continue;
+      let st; try { st = fs.statSync(base); } catch { continue; }
+      if (!st.isDirectory()) continue;
+      for (const e of fs.readdirSync(base)) {
+        const p = path.join(base, e);
+        try {
+          if (fs.statSync(p).isDirectory() && exists(path.join(p, '.harness'))) set.add(p);
+        } catch {}
+      }
+    }
+  }
+  const include = arg('--include', null);
+  if (include) {
+    for (const p of String(include).split(',')) {
+      const abs = path.resolve(p.trim());
+      if (exists(path.join(abs, '.harness'))) set.add(abs);
+      else warn(`--include 무시: ${abs} (.harness 없음)`);
+    }
+  }
+  return Array.from(set);
+}
+
 function retroCmd(root) {
   root = absRoot(root);
+  // 1.9.15: --all-apps / --include 통합 모드
+  if (has('--all-apps') || arg('--include', null)) {
+    return _retroWorkspace(root);
+  }
   const days = parseInt(arg('--days', '7'), 10);
   const cutoff = new Date(Date.now() - days * 86400 * 1000).toISOString().slice(0, 10);
   const agg = _retroAggregate(root);
+  // 1.9.16: --json
+  if (has('--json')) {
+    log(JSON.stringify({ project: path.basename(root), days, cutoff, summary: _retroOneLine(agg), data: agg }, null, 2));
+    return;
+  }
   log(`# 회고 (retro) — 최근 ${days}일 (since ${cutoff})`);
   log(`\n📈 한 줄 요약: ${_retroOneLine(agg)}`);
 
@@ -1506,9 +1923,66 @@ function retroCmd(root) {
   log(`  4. \`leerness brainstorm <주제>\`로 누적 데이터 기반 컨텍스트 적재`);
 }
 
+// 1.9.15: 워크스페이스 통합 retro (다수 프로젝트 묶음 회고)
+function _retroWorkspace(rootBase) {
+  const paths = _collectWorkspacePaths(rootBase);
+  if (!paths.length) return fail('대상 프로젝트 없음. --include <path1,path2> 또는 --all-apps 사용 필요.');
+  // 1.9.16: --json
+  if (has('--json')) {
+    const projects = paths.map(p => {
+      const a = _retroAggregate(p);
+      return { project: path.basename(p), path: p, summary: _retroOneLine(a), data: a };
+    });
+    const totals = projects.reduce((t, p) => ({
+      tasks: t.tasks + p.data.totalTasks, done: t.done + p.data.doneCount,
+      decisions: t.decisions + p.data.decisionBlocks, skills: t.skills + p.data.skillUsage.length,
+      usage: t.usage + p.data.totalSkillUsage, opts: t.opts + p.data.totalOptimizations,
+      activeRules: t.activeRules + p.data.activeRules, pass: t.pass + p.data.passSignals, fix: t.fix + p.data.fixSignals
+    }), { tasks: 0, done: 0, decisions: 0, skills: 0, usage: 0, opts: 0, activeRules: 0, pass: 0, fix: 0 });
+    log(JSON.stringify({ projects, totals, projectCount: paths.length }, null, 2));
+    return;
+  }
+  log(`# Cross-project retro — ${paths.length}개 프로젝트`);
+  const totals = { tasks: 0, done: 0, decisions: 0, skills: 0, totalSkillUsage: 0, totalOpts: 0, activeRules: 0, fixSig: 0, passSig: 0 };
+  for (const p of paths) {
+    const agg = _retroAggregate(p);
+    const name = path.basename(p);
+    log(`\n## ${name}`);
+    log(`  📈 ${_retroOneLine(agg)}`);
+    const f = agg.focusNext[0];
+    log(`  🎯 다음 우선: ${f ? `${f.id} [${f.status}] ${f.request.slice(0, 50)}` : '(없음)'}`);
+    log(`  📚 top 스킬: ${agg.skillUsage.length ? agg.skillUsage[0].id + ' (' + agg.skillUsage[0].count + '회)' : '(없음)'}`);
+    totals.tasks += agg.totalTasks;
+    totals.done += agg.doneCount;
+    totals.decisions += agg.decisionBlocks;
+    totals.skills += agg.skillUsage.length;
+    totals.totalSkillUsage += agg.totalSkillUsage;
+    totals.totalOpts += agg.totalOptimizations;
+    totals.activeRules += agg.activeRules;
+    totals.fixSig += agg.fixSignals;
+    totals.passSig += agg.passSignals;
+  }
+  log(`\n## 📊 워크스페이스 총합 (${paths.length} 프로젝트)`);
+  log(`  - 누적 task: ${totals.tasks}${totals.tasks ? ` (done ${totals.done} = ${Math.round(totals.done / totals.tasks * 100)}%)` : ''}`);
+  log(`  - 누적 결정: ${totals.decisions}건`);
+  log(`  - 스킬: ${totals.skills}종 / 사용 ${totals.totalSkillUsage}회 / 최적화 ${totals.totalOpts}건`);
+  log(`  - 활성 룰: ${totals.activeRules}건`);
+  log(`  - 시그널: pass ${totals.passSig} · fix ${totals.fixSig}${totals.passSig + totals.fixSig > 0 ? ` (비율 ${totals.fixSig ? (totals.passSig / totals.fixSig).toFixed(2) : '∞'})` : ''}`);
+}
+
 function insightsCmd(root) {
   root = absRoot(root);
+  // 1.9.15: --all-apps / --include 통합 모드
+  if (has('--all-apps') || arg('--include', null)) {
+    return _insightsWorkspace(root);
+  }
   const agg = _retroAggregate(root);
+  // 1.9.16: --json
+  if (has('--json')) {
+    const sc = readSessionCounter(root);
+    log(JSON.stringify({ project: path.basename(root), sessionCount: sc.count, lastCloseAt: sc.lastCloseAt, data: agg }, null, 2));
+    return;
+  }
   const sc = readSessionCounter(root);
   log(`# Insights — 누적 통계`);
   log(`\n## 📊 핵심 지표`);
@@ -1543,22 +2017,182 @@ function insightsCmd(root) {
   if (agg.statusCounts.blocked > 0) log(`  - blocked 작업 ${agg.statusCounts.blocked}건 — \`leerness lessons --query "blocked"\`로 과거 패턴 회수`);
 }
 
+function _insightsWorkspace(rootBase) {
+  const paths = _collectWorkspacePaths(rootBase);
+  if (!paths.length) return fail('대상 프로젝트 없음. --include 또는 --all-apps 사용.');
+  // 1.9.16: --json
+  if (has('--json')) {
+    const projects = paths.map(p => ({ project: path.basename(p), path: p, data: _retroAggregate(p) }));
+    log(JSON.stringify({ projects, projectCount: paths.length }, null, 2));
+    return;
+  }
+  log(`# Workspace Insights — ${paths.length}개 프로젝트`);
+  log(`\n| Project | Task | Done % | Decisions | Skills | Usage | Opts | Pass/Fix |`);
+  log(`|---|---|---|---|---|---|---|---|`);
+  const totals = { tasks: 0, done: 0, decisions: 0, skills: 0, usage: 0, opts: 0, pass: 0, fix: 0 };
+  for (const p of paths) {
+    const a = _retroAggregate(p);
+    const donePct = a.totalTasks ? Math.round(a.doneCount / a.totalTasks * 100) : 0;
+    const pf = a.fixSignals ? (a.passSignals / a.fixSignals).toFixed(1) : '∞';
+    log(`| ${path.basename(p)} | ${a.totalTasks} | ${donePct}% | ${a.decisionBlocks} | ${a.skillUsage.length} | ${a.totalSkillUsage} | ${a.totalOptimizations} | ${a.passSignals}/${a.fixSignals} (${pf}) |`);
+    totals.tasks += a.totalTasks; totals.done += a.doneCount; totals.decisions += a.decisionBlocks;
+    totals.skills += a.skillUsage.length; totals.usage += a.totalSkillUsage; totals.opts += a.totalOptimizations;
+    totals.pass += a.passSignals; totals.fix += a.fixSignals;
+  }
+  const tpf = totals.fix ? (totals.pass / totals.fix).toFixed(1) : '∞';
+  const tDonePct = totals.tasks ? Math.round(totals.done / totals.tasks * 100) : 0;
+  log(`| **TOTAL** | **${totals.tasks}** | **${tDonePct}%** | **${totals.decisions}** | **${totals.skills}** | **${totals.usage}** | **${totals.opts}** | **${totals.pass}/${totals.fix} (${tpf})** |`);
+  log(`\n## 📈 평가`);
+  if (totals.pass > totals.fix * 3) log(`  - 안정성: 우수 (pass÷fix = ${tpf})`);
+  else if (totals.pass > totals.fix) log(`  - 안정성: 보통 (pass÷fix = ${tpf})`);
+  else if (totals.fix > 0) log(`  - 안정성: 주의 (fix가 pass보다 많음) — verify-code 자동화 검토`);
+  if (totals.opts === 0) log(`  - 최적화 누적 없음 — \`leerness skill optimize\` 활용 권장`);
+}
+
+// 1.9.16: brainstorm 핵심 로직 분리 — 단일 프로젝트 결과 반환
+function _brainstormFor(root, topic) {
+  function _escUnicode(s) { return String(s).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&'); }
+  const tokens = String(topic).split(/\s+/).filter(t => t.length >= 2);
+  const wordRes = tokens.map(t => new RegExp(`(?<![\\p{L}\\p{N}_])${_escUnicode(t)}(?![\\p{L}\\p{N}_])`, 'iu'));
+  function matches(text) { return wordRes.every(re => re.test(text)); }
+  const hits = { decisions: [], skills: [], tasks: [], rules: [], evidence: [], lessons: [] };
+  const dec = exists(decisionsPath(root)) ? read(decisionsPath(root)) : '';
+  const decLines = dec.split('\n');
+  for (const b of _extractDecisionBlocks(dec)) {
+    if (matches(b)) {
+      const t = (b.match(/^### (.+)$/m) || [, ''])[1];
+      const lineIdx = decLines.findIndex(line => line === `### ${t}`);
+      const lineNo = lineIdx >= 0 ? lineIdx + 1 : 0;
+      hits.decisions.push({ title: t, preview: b.slice(0, 200).replace(/\n+/g, ' '), line: lineNo });
+    }
+  }
+  const skillsDir = path.join(root, '.harness/skills');
+  if (exists(skillsDir)) {
+    for (const id of fs.readdirSync(skillsDir)) {
+      const f = path.join(skillsDir, id, 'skill.json');
+      if (!exists(f)) continue;
+      try {
+        const s = JSON.parse(read(f));
+        if (matches(JSON.stringify(s))) hits.skills.push({ id, displayNameKo: s.displayNameKo, capabilities: s.capabilities, usage: s.usage });
+      } catch {}
+    }
+  }
+  const rows = readProgressRows(root);
+  const progressText = exists(progressPath(root)) ? read(progressPath(root)) : '';
+  for (const r of rows) {
+    const fields = [];
+    if (matches(r.request)) fields.push('request');
+    if (matches(r.evidence)) fields.push('evidence');
+    if (matches(r.nextAction)) fields.push('nextAction');
+    if (fields.length) {
+      const idx = progressText.indexOf(`| ${r.id} |`);
+      const lineNo = idx >= 0 ? progressText.slice(0, idx).split('\n').length : 0;
+      hits.tasks.push({ ...r, _fields: fields, line: lineNo });
+    }
+  }
+  if (exists(rulesPath(root))) {
+    const rulesText = read(rulesPath(root));
+    for (const r of readRules(root)) {
+      if (matches(r.rule)) {
+        const idx = rulesText.indexOf(`| ${r.id} |`);
+        const lineNo = idx >= 0 ? rulesText.slice(0, idx).split('\n').length : 0;
+        hits.rules.push({ ...r, line: lineNo });
+      }
+    }
+  }
+  const ev = exists(evidencePath(root)) ? read(evidencePath(root)) : '';
+  for (const block of ev.split(/\n(?=## )/)) {
+    if (!block.startsWith('## ')) continue;
+    if (matches(block)) {
+      const t = (block.match(/^## (.+)$/m) || [, ''])[1];
+      const idx = ev.indexOf(block);
+      const lineNo = idx >= 0 ? ev.slice(0, idx).split('\n').length : 0;
+      hits.evidence.push({ title: t.trim(), preview: block.slice(0, 200).replace(/\n+/g, ' '), line: lineNo });
+      if (/✗|fail|롤백|incomplete|버그/i.test(block)) hits.lessons.push({ title: t.trim(), line: lineNo });
+    }
+  }
+  return hits;
+}
+
+function _brainstormTotal(h) { return h.decisions.length + h.skills.length + h.tasks.length + h.rules.length + h.evidence.length; }
+
+// 1.9.16: 워크스페이스 통합 brainstorm
+function _brainstormWorkspace(rootBase, topic) {
+  const paths = _collectWorkspacePaths(rootBase);
+  if (!paths.length) return fail('대상 프로젝트 없음. --include 또는 --all-apps 사용.');
+  if (has('--json')) {
+    const result = paths.map(p => ({ project: path.basename(p), path: p, hits: _brainstormFor(p, topic) }));
+    log(JSON.stringify({ topic, projects: result, total: result.reduce((a, b) => a + _brainstormTotal(b.hits), 0) }, null, 2));
+    return;
+  }
+  log(`# Cross-project Brainstorm — "${topic}" — ${paths.length}개 프로젝트`);
+  let grandTotal = 0;
+  for (const p of paths) {
+    const h = _brainstormFor(p, topic);
+    const n = _brainstormTotal(h);
+    grandTotal += n;
+    if (n === 0) continue;
+    log(`\n## ${path.basename(p)} (${n}건)`);
+    if (h.decisions.length) {
+      log(`  🧠 결정 (${h.decisions.length})`);
+      h.decisions.slice(0, 3).forEach(d => log(`    - decisions.md:${d.line || '?'} — ${d.title}`));
+    }
+    if (h.skills.length) {
+      log(`  📚 스킬 (${h.skills.length})`);
+      h.skills.slice(0, 3).forEach(s => log(`    - ${s.id} (${s.displayNameKo}) · 사용 ${s.usage?.count || 0}회`));
+    }
+    if (h.tasks.length) {
+      log(`  📌 task (${h.tasks.length})`);
+      h.tasks.slice(0, 3).forEach(t => log(`    - progress-tracker.md:${t.line || '?'} — ${t.id} [${t.status}] ${t.request.slice(0, 50)} (matched: ${t._fields.join('+')})`));
+    }
+    if (h.rules.length) {
+      log(`  ⚡ 룰 (${h.rules.length})`);
+      h.rules.slice(0, 3).forEach(r => log(`    - rules.md:${r.line || '?'} — ${r.id} [${r.trigger}]`));
+    }
+    if (h.evidence.length) {
+      log(`  🧪 evidence (${h.evidence.length})`);
+      h.evidence.slice(0, 3).forEach(e => log(`    - review-evidence.md:${e.line || '?'} — ${e.title}`));
+    }
+    if (h.lessons.length) {
+      log(`  ⚠ 과거 실패/롤백 (${h.lessons.length})`);
+    }
+  }
+  log(`\n## 📊 워크스페이스 총합: ${grandTotal}건 매치 (${paths.length} 프로젝트)`);
+  if (grandTotal === 0) log(`  ⓘ 어느 프로젝트에서도 "${topic}" 관련 자원 없음 — 새 영역. 첫 결정/스킬을 기록하면 다음 brainstorm이 풍부해짐.`);
+}
+
 function brainstormCmd(root, topic) {
   root = absRoot(root);
   if (!topic) return fail('topic required (e.g., brainstorm "API rate limit")');
+  // 1.9.16: --all-apps / --include 통합 모드
+  if (has('--all-apps') || arg('--include', null)) {
+    return _brainstormWorkspace(root, topic);
+  }
+  // 1.9.16: --json 단일 프로젝트
+  if (has('--json')) {
+    const h = _brainstormFor(root, topic);
+    log(JSON.stringify({ topic, project: path.basename(root), hits: h, total: _brainstormTotal(h) }, null, 2));
+    return;
+  }
   log(`# Brainstorm — "${topic}"`);
   log(`\n누적된 leerness 데이터에서 주제 관련 자원을 회수합니다.`);
 
-  const re = new RegExp(escapeRegex(topic), 'i');
+  // 1.9.14 B: 토큰 기반 매칭 — unicode word boundary. unicode 모드에서 하이픈은 escape 불필요.
+  function _escUnicode(s) { return String(s).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&'); }
+  const tokens = String(topic).split(/\s+/).filter(t => t.length >= 2);
+  const wordRes = tokens.map(t => new RegExp(`(?<![\\p{L}\\p{N}_])${_escUnicode(t)}(?![\\p{L}\\p{N}_])`, 'iu'));
+  function matches(text) { return wordRes.every(re => re.test(text)); }
   const hits = { decisions: [], skills: [], tasks: [], rules: [], evidence: [], lessons: [] };
 
-  // decisions
+  // decisions (1.9.14: 코드블록/Template 제외, 1.9.15: 라인 번호)
   const dec = exists(decisionsPath(root)) ? read(decisionsPath(root)) : '';
-  for (const b of dec.split(/\n(?=### )/)) {
-    if (!b.startsWith('### ')) continue;
-    if (re.test(b)) {
+  const decLines = dec.split('\n');
+  for (const b of _extractDecisionBlocks(dec)) {
+    if (matches(b)) {
       const t = (b.match(/^### (.+)$/m) || [, ''])[1];
-      hits.decisions.push({ title: t, preview: b.slice(0, 200).replace(/\n+/g, ' ') });
+      const lineIdx = decLines.findIndex(line => line === `### ${t}`);
+      const lineNo = lineIdx >= 0 ? lineIdx + 1 : 0;
+      hits.decisions.push({ title: t, preview: b.slice(0, 200).replace(/\n+/g, ' '), line: lineNo });
     }
   }
   // skills
@@ -1570,54 +2204,75 @@ function brainstormCmd(root, topic) {
       try {
         const s = JSON.parse(read(f));
         const text = JSON.stringify(s);
-        if (re.test(text)) hits.skills.push({ id, displayNameKo: s.displayNameKo, capabilities: s.capabilities, usage: s.usage });
+        if (matches(text)) hits.skills.push({ id, displayNameKo: s.displayNameKo, capabilities: s.capabilities, usage: s.usage });
       } catch {}
     }
   }
-  // tasks
+  // tasks (1.9.14: token 매칭, 1.9.15: 매치 필드 + 라인 번호)
   const rows = readProgressRows(root);
-  for (const r of rows) if (re.test(r.request) || re.test(r.evidence) || re.test(r.nextAction)) hits.tasks.push(r);
-  // rules
+  const progressText = exists(progressPath(root)) ? read(progressPath(root)) : '';
+  for (const r of rows) {
+    const fields = [];
+    if (matches(r.request)) fields.push('request');
+    if (matches(r.evidence)) fields.push('evidence');
+    if (matches(r.nextAction)) fields.push('nextAction');
+    if (fields.length) {
+      const idx = progressText.indexOf(`| ${r.id} |`);
+      const lineNo = idx >= 0 ? progressText.slice(0, idx).split('\n').length : 0;
+      hits.tasks.push({ ...r, _fields: fields, line: lineNo });
+    }
+  }
+  // rules (1.9.15: 라인 번호)
   if (exists(rulesPath(root))) {
-    for (const r of readRules(root)) if (re.test(r.rule)) hits.rules.push(r);
+    const rulesText = read(rulesPath(root));
+    for (const r of readRules(root)) {
+      if (matches(r.rule)) {
+        const idx = rulesText.indexOf(`| ${r.id} |`);
+        const lineNo = idx >= 0 ? rulesText.slice(0, idx).split('\n').length : 0;
+        hits.rules.push({ ...r, line: lineNo });
+      }
+    }
   }
-  // evidence — lessons 키워드 (fail/롤백/incomplete) 동반
+  // evidence — lessons 키워드 (fail/롤백/incomplete) 동반 (1.9.15: 라인 번호)
   const ev = exists(evidencePath(root)) ? read(evidencePath(root)) : '';
   for (const block of ev.split(/\n(?=## )/)) {
     if (!block.startsWith('## ')) continue;
-    if (re.test(block)) {
+    if (matches(block)) {
       const t = (block.match(/^## (.+)$/m) || [, ''])[1];
-      hits.evidence.push({ title: t.trim(), preview: block.slice(0, 200).replace(/\n+/g, ' ') });
-      if (/✗|fail|롤백|incomplete|버그/i.test(block)) hits.lessons.push({ title: t.trim() });
+      const idx = ev.indexOf(block);
+      const lineNo = idx >= 0 ? ev.slice(0, idx).split('\n').length : 0;
+      hits.evidence.push({ title: t.trim(), preview: block.slice(0, 200).replace(/\n+/g, ' '), line: lineNo });
+      if (/✗|fail|롤백|incomplete|버그/i.test(block)) hits.lessons.push({ title: t.trim(), line: lineNo });
     }
   }
 
   const total = hits.decisions.length + hits.skills.length + hits.tasks.length + hits.rules.length + hits.evidence.length;
   log(`\n📦 총 ${total}건 발견 (decisions ${hits.decisions.length} · skills ${hits.skills.length} · tasks ${hits.tasks.length} · rules ${hits.rules.length} · evidence ${hits.evidence.length})`);
 
+  // 1.9.15: 모든 출력에 출처 파일:라인 표시
   if (hits.decisions.length) {
     log(`\n## 🧠 관련 결정 (${hits.decisions.length})`);
-    hits.decisions.slice(0, 5).forEach(d => log(`  - ${d.title}`));
+    hits.decisions.slice(0, 5).forEach(d => log(`  - .harness/decisions.md:${d.line || '?'} — ${d.title}`));
   }
   if (hits.skills.length) {
     log(`\n## 📚 관련 스킬 (${hits.skills.length}) — 시작 전 \`skill info <id>\` 권장`);
-    hits.skills.forEach(s => log(`  - ${s.id} (${s.displayNameKo}) · 사용 ${s.usage?.count || 0}회 · cap ${(s.capabilities || []).length}`));
+    hits.skills.forEach(s => log(`  - .harness/skills/${s.id}/skill.json — ${s.id} (${s.displayNameKo}) · 사용 ${s.usage?.count || 0}회 · cap ${(s.capabilities || []).length}`));
   }
   if (hits.tasks.length) {
     log(`\n## 📌 관련 과거 task (${hits.tasks.length})`);
-    hits.tasks.slice(0, 5).forEach(t => log(`  - ${t.id} [${t.status}] ${t.request}`));
+    hits.tasks.slice(0, 5).forEach(t => log(`  - .harness/progress-tracker.md:${t.line || '?'} — ${t.id} [${t.status}] ${t.request} (matched: ${t._fields.join('+')})`));
   }
   if (hits.rules.length) {
     log(`\n## ⚡ 관련 룰 (${hits.rules.length})`);
-    hits.rules.forEach(r => log(`  - ${r.id} [${r.trigger}] ${r.rule}`));
+    hits.rules.forEach(r => log(`  - .harness/rules.md:${r.line || '?'} — ${r.id} [${r.trigger}] ${r.rule}`));
   }
   if (hits.evidence.length) {
     log(`\n## 🧪 관련 검증 기록 (${hits.evidence.length})`);
-    hits.evidence.slice(0, 5).forEach(e => log(`  - ${e.title}`));
+    hits.evidence.slice(0, 5).forEach(e => log(`  - .harness/review-evidence.md:${e.line || '?'} — ${e.title}`));
   }
   if (hits.lessons.length) {
     log(`\n## ⚠ 같은 주제 과거 실패/롤백 (${hits.lessons.length}) — 같은 실수 방지`);
-    hits.lessons.slice(0, 5).forEach(l => log(`  - ${l.title}`));
+    hits.lessons.slice(0, 5).forEach(l => log(`  - .harness/review-evidence.md:${l.line || '?'} — ${l.title}`));
   }
 
   log(`\n## 💡 시작 전 권장 액션`);
@@ -2434,9 +3089,8 @@ function lessonsCmd(root) {
   const tlog = exists(taskLogPath(root)) ? read(taskLogPath(root)) : '';
   const handoff = exists(handoffPath(root)) ? read(handoffPath(root)) : '';
   const lessons = [];
-  // decisions: ### 블록 전체
-  for (const block of decisions.split(/\n(?=### )/)) {
-    if (!block.startsWith('### ')) continue;
+  // decisions: ### 블록 전체 (1.9.14: 코드블록/Template 제외)
+  for (const block of _extractDecisionBlocks(decisions)) {
     const m = block.match(/^### (.+)$/m);
     if (!m) continue;
     lessons.push({ source: 'decisions.md', title: m[1].trim(), block });
@@ -2894,10 +3548,10 @@ 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
-  leerness retro [path] [--days 7]           # 회고 (1.9.13) — 작업/스킬/결정/검증 시간 추세 + 권장
-  leerness insights [path]                   # 누적 통계 (1.9.13) — 핵심 지표 + 안정성
-  leerness brainstorm "<주제>"             # 브레인스토밍 (1.9.13) — 누적 자원 회수 + 시작 컨텍스트
+  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 .] [--json]    # 1.9.18 progress evidence 자동 검증\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)
   leerness roadmap [path] [--out file.html]  # 좌→우 수평 트리 + 상하 중앙정렬 + 화이트보드 (1.9.11)
   leerness roadmap auto on|off|status [--on-every-change] [--out file.html]  # 자동 갱신 (1.9.12, install/session-close 기본 ON)
   leerness verify-code [path] [--build]      # npm test/lint/typecheck 자동 실행 + evidence 자동 기록 (1.9.7)
@@ -2927,7 +3581,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') });