leerness 1.9.11 → 1.9.16

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.11';
+const VERSION = '1.9.16';
 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']);
   const a = process.argv.slice(2);
   for (let i = 0; i < a.length; i++) {
     const x = a[i];
@@ -198,7 +198,7 @@ function coreFiles(root, lang = 'ko', selectedSkills = []) {
   const project = detectProjectName(root);
   const skillRows = Object.entries(skillCatalog).map(([k, v]) => `| ${k} | ${v.displayNameKo} | ${v.capabilities.join(', ')} | ${v.lastUpdated} | ${v.verification} |`).join('\n');
   return {
-    'AGENTS.md': `${MARK}\n# Leerness Agent Instructions\n\n## Mandatory read order (session start)\n1. .harness/context-routing.md\n2. .harness/session-handoff.md\n3. .harness/current-state.md\n4. .harness/plan.md\n5. .harness/progress-tracker.md\n6. .harness/guideline.md\n7. .harness/protected-files.md\n8. .harness/writeback-policy.md\n9. .harness/anti-lazy-work-policy.md\n10. **.harness/rules.md** (사용자 정의 영구 룰 — 매 세션 반드시 따름)\n\n## Required behavior\n- 작업 시작 시 \`leerness handoff .\`를 실행해 컨텍스트를 적재합니다 (handoff가 active rules를 자동 출력).\n- 작업 분류는 \`leerness route <task-type>\`로 확인합니다 (planning, feature, bugfix, refactor, research, consistency, release, migration, session-start, session-close, harness-maintenance).\n- 보호 파일/관리 섹션을 삭제하지 않습니다. 머지·아카이브·deprecated 표시를 사용합니다.\n- 의미 있는 변경 후 progress-tracker, current-state, task-log, session-handoff를 갱신합니다.\n- 완료 선언 전 \`leerness check .\` 또는 \`leerness lazy detect .\`로 자기검증합니다.\n- 변경 전 secret/encoding 가드: \`leerness scan secrets .\`, \`leerness encoding check .\`.\n- 같은 기능 중복 생성 전 design-system.md, consistency-policy.md, reuse-map.md를 확인합니다.\n- 매 세션 종료 시 \`leerness session close .\`로 9개 카테고리(완료/진행중/미완료/예정/대기/보류/차단/드랍/검증) + **활성 룰 검증 결과**를 보고합니다.\n- 업데이트는 \`leerness update --check\` (감지) → \`leerness update --yes\` (자동 마이그레이션).\n\n## 자연어 룰 처리 (1.9.8)\n사용자가 자연어로 영구 룰을 요청하면 즉시 leerness rule 명령으로 등록합니다.\n\n| 사용자 발화 (자연어) | 즉시 실행할 명령 |\n|---|---|\n| "매 업데이트마다 버전 bump해줘" | \`leerness rule add "버전을 patch로 bump" --trigger every-update\` |\n| "매 커밋마다 패치노트 추가해줘" | \`leerness rule add "패치노트 추가" --trigger every-commit\` |\n| "세션 종료마다 배포해줘" | \`leerness rule add "배포 (release publish)" --trigger session-close\` |\n| "X 룰 중지/그만/끄기" | \`leerness rule pause <ID>\` (해당 룰 ID는 list로 확인) |\n| "X 룰 제거/삭제" | \`leerness rule remove <ID>\` |\n| "모든 룰 중지" | \`leerness rule stop\` |\n| "룰 다시 켜줘" | \`leerness rule resume-all\` 또는 \`leerness rule resume <ID>\` |\n\n룰을 등록한 후 사용자에게 등록 결과(ID + trigger + 설명)를 보고하고, 그 이후 매 세션마다 자동 적용합니다. 사용자가 "중지" 또는 "제거"를 명시적으로 말하기 전까지는 룰을 비활성화하지 않습니다.\n\n## 룰 자동 적용 (1.9.8)\nleerness가 자동 검증 가능한 trigger:\n- **every-update / version bump 키워드 룰**: package.json의 version이 갱신됐는지 검사 (handoff/session close가 baseline 캐시와 비교).\n- **CHANGELOG / 패치노트 키워드 룰**: CHANGELOG.md의 mtime이 갱신됐는지 검사.\n- **test / 테스트 / verify 키워드 룰**: review-evidence.md에 오늘 verify-code 흔적이 있는지 검사.\n- **배포 / publish / push 키워드 룰**: 자동 검증 불가 → 사용자에게 release publish 명령을 안내.\n\n자동 검증 가능한 룰의 실행은 \`leerness release bump\`, \`leerness release note "..."\`, \`leerness release publish\`를 사용해 자동화합니다.\n`,
+    'AGENTS.md': `${MARK}\n# Leerness Agent Instructions\n\n## Mandatory read order (session start)\n1. .harness/context-routing.md\n2. .harness/session-handoff.md\n3. .harness/current-state.md\n4. .harness/plan.md\n5. .harness/progress-tracker.md\n6. .harness/guideline.md\n7. .harness/protected-files.md\n8. .harness/writeback-policy.md\n9. .harness/anti-lazy-work-policy.md\n10. **.harness/rules.md** (사용자 정의 영구 룰 — 매 세션 반드시 따름)\n\n## Required behavior\n- 작업 시작 시 \`leerness handoff .\`를 실행해 컨텍스트를 적재합니다 (handoff가 active rules를 자동 출력).\n- 작업 분류는 \`leerness route <task-type>\`로 확인합니다 (planning, feature, bugfix, refactor, research, consistency, release, migration, session-start, session-close, harness-maintenance).\n- 보호 파일/관리 섹션을 삭제하지 않습니다. 머지·아카이브·deprecated 표시를 사용합니다.\n- 의미 있는 변경 후 progress-tracker, current-state, task-log, session-handoff를 갱신합니다.\n- 완료 선언 전 \`leerness check .\` 또는 \`leerness lazy detect .\`로 자기검증합니다.\n- 변경 전 secret/encoding 가드: \`leerness scan secrets .\`, \`leerness encoding check .\`.\n- 같은 기능 중복 생성 전 design-system.md, consistency-policy.md, reuse-map.md를 확인합니다.\n- 매 세션 종료 시 \`leerness session close .\`로 9개 카테고리(완료/진행중/미완료/예정/대기/보류/차단/드랍/검증) + **활성 룰 검증 결과**를 보고합니다.\n- 업데이트는 \`leerness update --check\` (감지) → \`leerness update --yes\` (자동 마이그레이션).\n\n## 자연어 회고/통찰/브레인스토밍 (1.9.13)\n사용자가 자연어로 회고/통찰/브레인스토밍을 요청하면 즉시 leerness 명령으로 호출합니다.\n\n| 사용자 발화 (자연어) | 즉시 실행할 명령 |\n|---|---|\n| "회고해줘 / 돌아보자 / 정리해줘" | \`leerness retro\` |\n| "최근 N일 회고" | \`leerness retro --days N\` |\n| "통계 / 누적 지표 / insights" | \`leerness insights\` |\n| "X에 대해 브레인스토밍 / X 관련 자료 / X 시작 전 검토" | \`leerness brainstorm "X"\` |\n\nsession close가 매번 자동으로 한 줄 요약을 출력하고, 5세션마다 자동 깊은 회고를 실행합니다. 사용자가 명시 요청 시 즉시 호출.\n\n## 자연어 룰 처리 (1.9.8)\n사용자가 자연어로 영구 룰을 요청하면 즉시 leerness rule 명령으로 등록합니다.\n\n| 사용자 발화 (자연어) | 즉시 실행할 명령 |\n|---|---|\n| "매 업데이트마다 버전 bump해줘" | \`leerness rule add "버전을 patch로 bump" --trigger every-update\` |\n| "매 커밋마다 패치노트 추가해줘" | \`leerness rule add "패치노트 추가" --trigger every-commit\` |\n| "세션 종료마다 배포해줘" | \`leerness rule add "배포 (release publish)" --trigger session-close\` |\n| "X 룰 중지/그만/끄기" | \`leerness rule pause <ID>\` (해당 룰 ID는 list로 확인) |\n| "X 룰 제거/삭제" | \`leerness rule remove <ID>\` |\n| "모든 룰 중지" | \`leerness rule stop\` |\n| "룰 다시 켜줘" | \`leerness rule resume-all\` 또는 \`leerness rule resume <ID>\` |\n\n룰을 등록한 후 사용자에게 등록 결과(ID + trigger + 설명)를 보고하고, 그 이후 매 세션마다 자동 적용합니다. 사용자가 "중지" 또는 "제거"를 명시적으로 말하기 전까지는 룰을 비활성화하지 않습니다.\n\n## 룰 자동 적용 (1.9.8)\nleerness가 자동 검증 가능한 trigger:\n- **every-update / version bump 키워드 룰**: package.json의 version이 갱신됐는지 검사 (handoff/session close가 baseline 캐시와 비교).\n- **CHANGELOG / 패치노트 키워드 룰**: CHANGELOG.md의 mtime이 갱신됐는지 검사.\n- **test / 테스트 / verify 키워드 룰**: review-evidence.md에 오늘 verify-code 흔적이 있는지 검사.\n- **배포 / publish / push 키워드 룰**: 자동 검증 불가 → 사용자에게 release publish 명령을 안내.\n\n자동 검증 가능한 룰의 실행은 \`leerness release bump\`, \`leerness release note "..."\`, \`leerness release publish\`를 사용해 자동화합니다.\n`,
     'CLAUDE.md': `${MARK}\n# Claude Code Instructions\n\nFollow AGENTS.md. Always run \`leerness handoff .\` at the start and \`leerness session close .\` before ending a session.\n\nProtected files must not be deleted. Read .harness/anti-lazy-work-policy.md before claiming completion.\n\n## 자연어 영구 룰 (1.9.8)\n사용자가 "매 X마다 Y를 해줘" 같은 자연어 룰을 말하면 즉시 \`leerness rule add "Y" --trigger every-X\`로 등록하세요. 등록된 룰은 매 세션 \`handoff\`가 자동 출력하고, \`session close\`가 자동 검증해 보고합니다. 사용자가 "중지" / "그만" / "끄기"를 명시할 때만 \`rule pause/remove\`를 호출합니다.\n\n자세한 매핑은 AGENTS.md의 "자연어 룰 처리" 표를 참고하세요.\n`,
     '.cursor/rules/leerness.mdc': `${MARK}\n---\nalwaysApply: true\n---\nFollow AGENTS.md and .harness/context-routing.md.\nRun: \`leerness handoff .\` at session start.\nRun: \`leerness session close .\` at session end.\nPreserve Leerness protected files.\n`,
     '.github/copilot-instructions.md': `${MARK}\n# Copilot Instructions\n\nUse AGENTS.md and .harness/ as project memory.\nDo not remove protected Leerness files.\nBefore completion, ensure plan.md, progress-tracker.md, current-state.md, session-handoff.md are updated.\n`,
@@ -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`),
@@ -458,6 +458,10 @@ async function install(root, opts = {}) {
     if (!has('--no-auto-update')) {
       try { autoUpdateInstall(root); } catch (e) { warn('auto-update hook install skipped: ' + (e && e.message)); }
     }
+    // 1.9.12: install 직후 첫 roadmap.html 자동 생성
+    if (!has('--no-auto-roadmap')) {
+      try { _autoRoadmap(root, 'install'); } catch (e) { warn('auto-roadmap 실패: ' + (e && e.message)); }
+    }
   }
 }
 
@@ -689,6 +693,7 @@ function planAdd(root, text) {
   const tid = nextId(root, 'T');
   upsertProgress(root, { id: tid, status, request: text, evidence: `plan:${id}`, nextAction: arg('--next', '다음 액션 작성') });
   ok(`plan added: ${id} → progress: ${tid}`);
+  _autoRoadmap(absRoot(root), 'data-change');
 }
 function planDrop(root, text) {
   const id = nextId(root, 'D');
@@ -725,6 +730,7 @@ function taskAdd(root, text) {
   const id = nextId(root, 'T');
   upsertProgress(root, { id, status: arg('--status','requested'), request: text, evidence: arg('--evidence','user-request'), nextAction: arg('--next','다음 액션 작성') });
   ok(`task added: ${id}`);
+  _autoRoadmap(absRoot(root), 'data-change');
 }
 function taskUpdate(root, id) {
   if (!id) return fail('id required (e.g., task update T-0001 --status in-progress)');
@@ -737,11 +743,13 @@ function taskUpdate(root, id) {
   if (arg('--note')) patch.request = arg('--note');
   upsertProgress(root, patch);
   ok(`task updated: ${id}`);
+  _autoRoadmap(absRoot(root), 'data-change');
 }
 function taskDrop(root, id) {
   if (!id) return fail('id required');
   upsertProgress(root, { id, status: 'dropped', evidence: arg('--reason','사용자 요청으로 제외'), nextAction: '없음' });
   ok(`task dropped: ${id}`);
+  _autoRoadmap(absRoot(root), 'data-change');
 }
 
 // 1.9.6: 옛 link 손실 row를 plan.md milestone과 자동 매칭 제안/복구.
@@ -1269,6 +1277,45 @@ function sessionClose(root) {
   log('\n## Required final response sections');
   log('- 완료 작업\n- 진행 중 작업\n- 미완료/예정/대기/보류/차단/드랍 작업\n- 검증 결과\n- 추천 방향\n- 다음 정확한 작업\n- ⚡ 활성 룰별 검증 결과');
   ok(`session-handoff.md and current-state.md updated`);
+  // 1.9.12: session close 끝에 roadmap.html 자동 갱신
+  _autoRoadmap(root, 'session-close');
+  // 1.9.13: 세션 카운터 + 자동 한 줄 요약 + 5세션마다 깊은 회고
+  try {
+    const sc = readSessionCounter(root);
+    sc.count = (sc.count || 0) + 1;
+    sc.lastCloseAt = now();
+    writeSessionCounter(root, sc);
+    const agg = _retroAggregate(root);
+    log(`\n## 📈 진행 요약 (session #${sc.count})`);
+    log(`  ${_retroOneLine(agg)}`);
+    if (sc.count % 5 === 0) {
+      log(`\n## 🔄 ${sc.count}세션 마일스톤 — 자동 회고 (5세션마다)`);
+      retroCmd(root);
+      sc.lastDeepRetroAt = now();
+      writeSessionCounter(root, sc);
+    } else {
+      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));
+  }
 }
 
 function readmeCmd(root) { syncReadme(absRoot(root)); }
@@ -1317,6 +1364,571 @@ function gate(root) {
   else ok('all gates passed');
 }
 
+// ===== 1.9.13: Retrospective / Insights / Brainstorming =====
+function sessionCounterPath(root) { return path.join(root, '.harness/cache/session-counter.json'); }
+function readSessionCounter(root) {
+  if (!exists(sessionCounterPath(root))) return { count: 0, lastCloseAt: null, lastDeepRetroAt: null };
+  try { return JSON.parse(read(sessionCounterPath(root))); } catch { return { count: 0, lastCloseAt: null, lastDeepRetroAt: null }; }
+}
+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);
+  const decisions = exists(decisionsPath(root)) ? read(decisionsPath(root)) : '';
+  const tlog = exists(taskLogPath(root)) ? read(taskLogPath(root)) : '';
+  const evidence = exists(evidencePath(root)) ? read(evidencePath(root)) : '';
+  const handoff = exists(handoffPath(root)) ? read(handoffPath(root)) : '';
+
+  // 1) 작업 상태 분포
+  const statusCounts = {};
+  for (const s of STATUSES) statusCounts[s] = 0;
+  for (const r of rows) if (statusCounts[r.status] != null) statusCounts[r.status]++;
+
+  // 2) 결정 블록 수 (1.9.14: 코드블록/Template 제외)
+  const decisionBlocks = _extractDecisionBlocks(decisions);
+  // recent decisions (날짜로 정렬 시 가장 최근)
+  const recentDecisions = decisionBlocks.slice(-5).map(b => {
+    const t = (b.match(/^### (.+)$/m) || [, ''])[1];
+    return { title: t.trim(), block: b.slice(0, 200) };
+  }).reverse();
+
+  // 3) 스킬 활용
+  const skillsDir = path.join(root, '.harness/skills');
+  const skillUsage = [];
+  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));
+        skillUsage.push({
+          id,
+          displayNameKo: s.displayNameKo || id,
+          count: s.usage?.count || 0,
+          lastUsed: s.usage?.lastUsed || null,
+          optimizations: (s.optimizations || []).length,
+          capabilities: (s.capabilities || []).length
+        });
+      } catch {}
+    }
+  }
+  skillUsage.sort((a, b) => (b.count - a.count) || (b.optimizations - a.optimizations));
+
+  // 4) 검증 시간 추세 — review-evidence.md에서 "exit=0 (Nms)" 또는 "(Nms)" 패턴
+  const durations = [];
+  for (const m of evidence.matchAll(/exit=\d+\s*\((\d+)ms\)/g)) durations.push(parseInt(m[1], 10));
+
+  // 5) 실패→성공 시그널 — task-log/evidence/decisions에서 "롤백" / "fail" / "재발" / "fix" / "수정" 등의 동시 등장 카운트
+  const fixSignals = (tlog + evidence + decisions).match(/\b(fix|fixed|수정|롤백|재발|incomplete|bug)\b/gi) || [];
+  const passSignals = (tlog + evidence + decisions).match(/(?:✓|pass(?:ed)?|통과|completed|done)/gi) || [];
+
+  // 6) 룰 활용
+  const rules = exists(rulesPath(root)) ? readRules(root) : [];
+  const activeRules = rules.filter(r => r.status === 'active');
+  const verifiedRules = rules.filter(r => r.lastVerified && r.lastVerified !== '-');
+
+  // 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,
+    rows,
+    totalTasks: rows.length,
+    doneCount: statusCounts.done,
+    decisionBlocks: decisionBlocks.length,
+    recentDecisions,
+    skillUsage,
+    totalSkillUsage: skillUsage.reduce((a, b) => a + b.count, 0),
+    totalOptimizations: skillUsage.reduce((a, b) => a + b.optimizations, 0),
+    durations,
+    fixSignals: fixSignals.length,
+    passSignals: passSignals.length,
+    activeRules: activeRules.length,
+    verifiedRules: verifiedRules.length,
+    focusNext
+  };
+}
+
+function _retroOneLine(agg) {
+  const parts = [];
+  const done = agg.statusCounts.done;
+  const total = agg.totalTasks;
+  if (total) parts.push(`완료 ${done}/${total} (${Math.round(done / total * 100)}%)`);
+  if (agg.totalSkillUsage) parts.push(`스킬 ${agg.skillUsage.length}종 / 사용 ${agg.totalSkillUsage}회 / 최적화 ${agg.totalOptimizations}건`);
+  if (agg.activeRules) parts.push(`룰 ${agg.activeRules}건 활성 (${agg.verifiedRules} 검증됨)`);
+  if (agg.durations.length >= 4) {
+    const mid = Math.floor(agg.durations.length / 2);
+    const a = agg.durations.slice(0, mid).reduce((x, y) => x + y, 0) / mid;
+    const b = agg.durations.slice(mid).reduce((x, y) => x + y, 0) / (agg.durations.length - mid);
+    if (a > 0) {
+      const delta = ((b - a) / a) * 100;
+      const sign = delta > 0 ? '+' : '';
+      parts.push(`검증 ${Math.round(a)}ms→${Math.round(b)}ms (${sign}${delta.toFixed(1)}%)`);
+    }
+  }
+  parts.push(`결정 ${agg.decisionBlocks}건 누적`);
+  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)}`);
+
+  log(`\n## 작업 상태 분포`);
+  for (const s of STATUSES) if (agg.statusCounts[s]) log(`  - ${s}: ${agg.statusCounts[s]}`);
+
+  log(`\n## 🎯 다음 우선 작업 (top 5)`);
+  if (!agg.focusNext.length) log('  (없음 — 새 plan add 권장)');
+  else agg.focusNext.slice(0, 5).forEach(r => log(`  - ${r.id} [${r.status}] ${r.request} → ${r.nextAction}`));
+
+  log(`\n## 📚 스킬 활용 추세 (top 5)`);
+  if (!agg.skillUsage.length) log('  (등록된 스킬 없음)');
+  else agg.skillUsage.slice(0, 5).forEach(s => log(`  - ${s.id}: 사용 ${s.count}회, 최적화 ${s.optimizations}건, capabilities ${s.capabilities}개${s.lastUsed ? ' · 마지막 ' + s.lastUsed.slice(0, 10) : ''}`));
+
+  log(`\n## 🧠 최근 결정 (top 5)`);
+  if (!agg.recentDecisions.length) log('  (없음)');
+  else agg.recentDecisions.slice(0, 5).forEach(d => log(`  - ${d.title}`));
+
+  if (agg.durations.length >= 4) {
+    const mid = Math.floor(agg.durations.length / 2);
+    const a = agg.durations.slice(0, mid).reduce((x, y) => x + y, 0) / mid;
+    const b = agg.durations.slice(mid).reduce((x, y) => x + y, 0) / (agg.durations.length - mid);
+    const delta = ((b - a) / a) * 100;
+    log(`\n## ⏱ 검증 시간 추세 (review-evidence)`);
+    log(`  - 전반부 평균: ${Math.round(a)}ms`);
+    log(`  - 후반부 평균: ${Math.round(b)}ms`);
+    log(`  - 변화: ${delta > 0 ? '+' : ''}${delta.toFixed(1)}% ${delta < 0 ? '🚀 빨라짐' : delta > 10 ? '⚠ 느려짐' : ''}`);
+  }
+
+  log(`\n## ⚡ 활성 룰 / 검증 비율`);
+  log(`  - 활성 ${agg.activeRules}건 · 검증됨 ${agg.verifiedRules}건 (${agg.activeRules ? Math.round(agg.verifiedRules / agg.activeRules * 100) : 0}%)`);
+
+  log(`\n## 🔁 fix/pass 시그널`);
+  log(`  - fix 시그널 (롤백/수정/bug/incomplete): ${agg.fixSignals}회`);
+  log(`  - pass 시그널 (통과/✓/completed): ${agg.passSignals}회`);
+  if (agg.passSignals > agg.fixSignals * 2) log('  - 평가: 안정적 (pass >> fix)');
+  else if (agg.fixSignals > agg.passSignals) log('  - 평가: 디버그 비중 높음 — verify-code 자동화 검토');
+
+  log(`\n## 💡 권장 다음 단계`);
+  if (agg.focusNext.length) log(`  1. ${agg.focusNext[0].id} (${agg.focusNext[0].status}): ${agg.focusNext[0].nextAction}`);
+  if (agg.skillUsage.length && agg.skillUsage[0].count > 0) log(`  2. 가장 활발한 스킬 "${agg.skillUsage[0].id}"의 패턴을 다른 작업에 재사용 가능`);
+  if (agg.totalOptimizations > 0) log(`  3. 누적된 최적화 ${agg.totalOptimizations}건을 새 작업의 시작 전 참고 (\`leerness skill info <id>\`)`);
+  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## 📊 핵심 지표`);
+  log(`  - 누적 task: ${agg.totalTasks} (done ${agg.doneCount}, in-progress ${agg.statusCounts['in-progress']}, planned ${agg.statusCounts.planned})`);
+  log(`  - 누적 결정 (decisions.md): ${agg.decisionBlocks}건`);
+  log(`  - 누적 스킬: ${agg.skillUsage.length}종`);
+  log(`  - 총 스킬 사용: ${agg.totalSkillUsage}회`);
+  log(`  - 총 최적화 누적: ${agg.totalOptimizations}건`);
+  log(`  - 활성 룰: ${agg.activeRules}건 (검증 ${agg.verifiedRules}건)`);
+  log(`  - session close 횟수: ${sc.count}회${sc.lastCloseAt ? ' (마지막: ' + sc.lastCloseAt.slice(0, 16) + ')' : ''}`);
+
+  if (agg.skillUsage.length) {
+    log(`\n## 🏆 가장 활용도 높은 스킬 (top 5)`);
+    agg.skillUsage.slice(0, 5).forEach((s, i) => log(`  ${i + 1}. ${s.id} (${s.displayNameKo}) — 사용 ${s.count}회, 최적화 ${s.optimizations}건`));
+  }
+
+  if (agg.durations.length) {
+    const total = agg.durations.reduce((a, b) => a + b, 0);
+    log(`\n## ⏱ 검증 시간 (verify-code)`);
+    log(`  - 실행: ${agg.durations.length}회 / 총 ${total}ms / 평균 ${Math.round(total / agg.durations.length)}ms`);
+    log(`  - 최소 ${Math.min(...agg.durations)}ms / 최대 ${Math.max(...agg.durations)}ms`);
+  }
+
+  log(`\n## 🔁 안정성 지표`);
+  log(`  - pass 시그널: ${agg.passSignals} · fix 시그널: ${agg.fixSignals}`);
+  const ratio = agg.fixSignals > 0 ? (agg.passSignals / agg.fixSignals).toFixed(2) : '∞';
+  log(`  - pass/fix 비율: ${ratio}${ratio === '∞' || parseFloat(ratio) > 3 ? ' (안정)' : parseFloat(ratio) < 1 ? ' (디버그 위주)' : ' (보통)'}`);
+
+  log(`\n## 📈 권장`);
+  if (agg.totalOptimizations === 0) log(`  - 스킬에 최적화 누적 없음 — \`leerness skill optimize <id> --before --after\`로 더 나은 방법 기록`);
+  if (sc.count >= 5 && sc.count % 5 === 0) log(`  - 5세션마다 자동 깊은 회고가 예정되어 있습니다 — session close가 자동 호출`);
+  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 데이터에서 주제 관련 자원을 회수합니다.`);
+
+  // 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 (1.9.14: 코드블록/Template 제외, 1.9.15: 라인 번호)
+  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 });
+    }
+  }
+  // skills
+  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));
+        const text = JSON.stringify(s);
+        if (matches(text)) hits.skills.push({ id, displayNameKo: s.displayNameKo, capabilities: s.capabilities, usage: s.usage });
+      } catch {}
+    }
+  }
+  // tasks (1.9.14: token 매칭, 1.9.15: 매치 필드 + 라인 번호)
+  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 });
+    }
+  }
+  // rules (1.9.15: 라인 번호)
+  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 });
+      }
+    }
+  }
+  // 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 (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 });
+    }
+  }
+
+  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(`  - .harness/decisions.md:${d.line || '?'} — ${d.title}`));
+  }
+  if (hits.skills.length) {
+    log(`\n## 📚 관련 스킬 (${hits.skills.length}) — 시작 전 \`skill info <id>\` 권장`);
+    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(`  - .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(`  - .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(`  - .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(`  - .harness/review-evidence.md:${l.line || '?'} — ${l.title}`));
+  }
+
+  log(`\n## 💡 시작 전 권장 액션`);
+  log(`  1. 위 자원을 모두 검토 후 plan add 또는 task add로 새 작업 등록`);
+  log(`  2. 가장 비슷한 과거 스킬을 \`leerness skill use <id>\`로 활성화`);
+  log(`  3. 작업 종료 시 새로 발견한 패턴을 \`skill optimize\`로 누적`);
+  if (!total) log(`  ⓘ 관련 자원 없음 — 새로운 영역. 첫 결정/스킬을 기록하면 다음 brainstorm이 더 풍부해짐.`);
+}
+
 // ===== 1.9.11: Roadmap (project-roadmap-generator 통합) =====
 const ROADMAP_STATUS_LABEL = { done: '완료', 'in-progress': '진행', 'on-hold': '보류', waiting: '검토', incomplete: '미완료', planned: '예정', blocked: '오류', dropped: '취소', skill: '스킬', rule: '룰', meta: '프로젝트' };
 const ROADMAP_STATUS_COLOR = { done: '#16a34a', 'in-progress': '#2563eb', 'on-hold': '#6b7280', waiting: '#eab308', incomplete: '#f97316', planned: '#94a3b8', blocked: '#dc2626', dropped: '#9ca3af', skill: '#8b5cf6', rule: '#06b6d4', meta: '#0f172a' };
@@ -1605,6 +2217,62 @@ function roadmapCmd(root) {
   log(`  milestones: ${data.milestones.length} · tasks: ${data.tasks.length} (done ${data.tasks.filter(t => t.status === 'done').length}) · skills: ${data.skills.length} · active rules: ${data.rules.filter(r => r.status === 'active').length} · tokens: ${Object.keys(data.designTokens).length + Object.keys(data.cssVariables).length}`);
 }
 
+// 1.9.12: auto roadmap (install / session-close / 옵트인 data-change 트리거)
+function _autoRoadmapConfigPath(root) { return path.join(root, '.harness/cache/auto-roadmap.json'); }
+function _autoRoadmapConfig(root) {
+  const f = _autoRoadmapConfigPath(root);
+  const def = { enabled: true, onEveryChange: false, outFile: null };
+  if (!exists(f)) return def;
+  try { return Object.assign(def, JSON.parse(read(f))); } catch { return def; }
+}
+function _saveAutoRoadmapConfig(root, cfg) {
+  writeUtf8(_autoRoadmapConfigPath(root), JSON.stringify(cfg, null, 2) + '\n');
+}
+function _autoRoadmap(root, trigger) {
+  try {
+    if (process.env.LEERNESS_NO_AUTO_ROADMAP === '1') return false;
+    if (!exists(path.join(root, '.harness'))) return false;
+    const cfg = _autoRoadmapConfig(root);
+    if (!cfg.enabled) return false;
+    if (trigger === 'data-change' && !cfg.onEveryChange) return false;
+    const outFile = path.resolve(cfg.outFile || path.join(root, 'roadmap.html'));
+    const data = _roadmapData(root);
+    writeUtf8(outFile, _roadmapHTML(data));
+    log(`✓ roadmap.html 자동 갱신 (${trigger}) — ${rel(root, outFile)}`);
+    return true;
+  } catch (e) {
+    warn('roadmap 자동 갱신 실패: ' + (e && e.message ? e.message : e));
+    return false;
+  }
+}
+
+function roadmapAutoCmd(root, sub) {
+  root = absRoot(root);
+  if (!exists(path.join(root, '.harness'))) return fail(`leerness 미설치: ${root}/.harness 없음`);
+  const cfg = _autoRoadmapConfig(root);
+  if (sub === 'on') {
+    cfg.enabled = true;
+    if (has('--on-every-change')) cfg.onEveryChange = true;
+    if (has('--no-on-every-change')) cfg.onEveryChange = false;
+    if (arg('--out', null)) cfg.outFile = arg('--out', null);
+    _saveAutoRoadmapConfig(root, cfg);
+    ok(`auto-roadmap 활성화 (onEveryChange: ${cfg.onEveryChange}, outFile: ${cfg.outFile || './roadmap.html'})`);
+  } else if (sub === 'off') {
+    cfg.enabled = false;
+    _saveAutoRoadmapConfig(root, cfg);
+    ok('auto-roadmap 비활성화 — session close 시 갱신 안 됨');
+  } else {
+    log(`# auto-roadmap status`);
+    log(`enabled: ${cfg.enabled}`);
+    log(`onEveryChange: ${cfg.onEveryChange}`);
+    log(`outFile: ${cfg.outFile || './roadmap.html'}`);
+    log(`\n트리거:`);
+    log(`  install      : ${cfg.enabled ? '✓ 자동 생성' : '✗ 비활성'}`);
+    log(`  session-close: ${cfg.enabled ? '✓ 자동 갱신' : '✗ 비활성'}`);
+    log(`  data-change  : ${cfg.enabled && cfg.onEveryChange ? '✓ 즉시 갱신 (모든 task/plan/rule/skill 변경)' : '✗ 옵트인 필요 (--on-every-change)'}`);
+  }
+}
+
 // ===== 1.9.8: User Rules (자연어 등록 + 매 세션 자동 노출/검증) =====
 function rulesPath(root) { return path.join(root, '.harness/rules.md'); }
 function rulesArchivePath(root) { return path.join(root, '.harness/rules.archive.md'); }
@@ -1683,6 +2351,7 @@ function ruleAdd(root, description) {
   rules.push({ id, trigger, rule: description, added: today(), status: 'active', lastVerified: '-' });
   writeRules(root, rules);
   ok(`rule added: ${id} [${trigger}] ${description}`);
+  _autoRoadmap(root, 'data-change');
 }
 
 function ruleList(root) {
@@ -1716,6 +2385,7 @@ function rulePause(root, id) {
   r.status = 'paused';
   writeRules(root, rules);
   ok(`rule paused: ${id}`);
+  _autoRoadmap(root, 'data-change');
 }
 
 function ruleResume(root, id) {
@@ -1727,6 +2397,7 @@ function ruleResume(root, id) {
   r.status = 'active';
   writeRules(root, rules);
   ok(`rule resumed: ${id}`);
+  _autoRoadmap(root, 'data-change');
 }
 
 function ruleStop(root) {
@@ -2065,9 +2736,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 });
@@ -2265,7 +2935,10 @@ function uiConsistency(root) {
   ok(`등록된 디자인 토큰: ${Object.keys(tokens).length}개`);
   const findings = [];
   for (const f of walkCode(root)) {
-    if (rel(root, f).startsWith('.harness/')) continue;
+    const r = rel(root, f);
+    if (r.startsWith('.harness/')) continue;
+    // 1.9.12: leerness가 자동 생성하는 roadmap.html은 ui consistency 검사 대상 아님
+    if (r === 'roadmap.html' || /\/roadmap\.html$/.test(r)) continue;
     if (!/\.(css|scss|sass|less|html|jsx|tsx|vue|svelte|js|ts)$/i.test(f)) continue;
     let text; try { text = read(f); } catch { continue; }
     const hexes = [...text.matchAll(/#[0-9a-fA-F]{3,8}\b/g)];
@@ -2523,7 +3196,11 @@ 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] [--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)
   leerness lessons [--query <키>] [--limit N]  # 과거 결정/실수 자동 회수 (1.9.7)
   leerness lazy detect [path] [--auto-track] # --auto-track으로 새 TODO를 progress에 자동 등록 (1.9.7)
@@ -2572,6 +3249,10 @@ async function main() {
   if (cmd === 'gate')                               return gate(args[1] || process.cwd());
   if (cmd === 'verify-code')                        return verifyCodeCmd(args[1] || process.cwd());
   if (cmd === 'lessons')                            return lessonsCmd(arg('--path', process.cwd()));
+  if (cmd === 'retro')                              return retroCmd(args[1] || process.cwd());
+  if (cmd === 'insights')                           return insightsCmd(args[1] || process.cwd());
+  if (cmd === 'brainstorm')                         return brainstormCmd(arg('--path', process.cwd()), args.slice(1).filter(x => !x.startsWith('-')).join(' '));
+  if (cmd === 'roadmap' && args[1] === 'auto')      return roadmapAutoCmd(arg('--path', process.cwd()), args[2]);
   if (cmd === 'roadmap')                            return roadmapCmd(args[1] || process.cwd());
   if (cmd === 'rule' && args[1] === 'add')          return ruleAdd(arg('--path', process.cwd()), args.slice(2).filter(x => !x.startsWith('-')).join(' '));
   if (cmd === 'rule' && args[1] === 'list')         return ruleList(arg('--path', process.cwd()));