leerness 1.9.419 → 1.9.420

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 1.9.420 — 2026-06-07 — 무거움 점진 해소: reviewRequestCmd → lib/review-request.js 모듈화 (UR-0025/UR-0125)
+
+**🪶 `bin/leerness.js`(21k줄/1.3MB) 무거움 점진 해소 — `review-request` 핸들러(277줄)를 lib/ 로 DI 분리.**
+
+### 배경
+실현가능성 조사(3-에이전트)에서 무거움=MODERATE, 큰 핸들러 점진 추출 권장. 후보별 외부 의존 footprint 측정 결과 **reviewRequestCmd(285줄, 의존 최소)**가 최저 위험 → 첫 추출 대상으로 선정(안정성 우선).
+
+### 변경
+- `lib/review-request.js` 신설(288줄): `reviewRequestCmd(root, request, deps)` — io 프리미티브는 `./io`, `cp`/`path` 빌트인, harness 고유 의존(`has`·`harnessPath`·`_checkRequestConstraints`·`_recordRun`)은 **DI 주입**(기존 doctor/team/migrate/feature 패턴 동일).
+- `bin/leerness.js`: 277줄 함수 → **3줄 thin wrapper** 위임. **21,177 → 20,903줄(−274)**.
+- 동작/출력 **무변경**(텍스트·--json·빈입력 가드 동일).
+
+### 검증 (회귀 0)
+- **selftest 165→166 PASS** (모듈 존재 + DI 위임 + 인라인 제거 + estimatedType/recommendedSteps 동작).
+- **E2E 419→420 PASS**.
+
+### 무거움 진행 (UR-0125, 다음 라운드)
+다음 추출 후보(의존 footprint 순): audit(~9) → driftCheck(~13) → healthCmd(~24) → handoff(1434줄, 최대/최고결합). 라운드마다 1개씩 안전 추출.
+
 ## 1.9.419 — 2026-06-07 — 엔트리 파일명 변경: bin/harness.js → bin/leerness.js (네이밍 일관성, UR-0126)
 
 **📛 패키지 엔트리 파일명을 `bin/harness.js` → `bin/leerness.js` 로 변경 — 명령어(`leerness`)와 파일명 일치.**

package/README.md

@@ -3,7 +3,7 @@
 > **AI 코딩 에이전트의 거짓 완료·중복·망각·충돌을 막아주는 검수·기억·협업 CLI 하네스.**
 > **A CLI harness that stops AI coding agents from faking completion, duplicating work, forgetting context, and colliding.**
 
-[![npm](https://img.shields.io/badge/npm-leerness-blue)](https://www.npmjs.com/package/leerness) [![version](https://img.shields.io/badge/version-1.9.419-green)]() [![tests](https://img.shields.io/badge/e2e-357%2F357-success)]() [![selftest](https://img.shields.io/badge/selftest-165-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-85-brightgreen)]() [![providers](https://img.shields.io/badge/AI_providers-10-brightgreen)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
+[![npm](https://img.shields.io/badge/npm-leerness-blue)](https://www.npmjs.com/package/leerness) [![version](https://img.shields.io/badge/version-1.9.420-green)]() [![tests](https://img.shields.io/badge/e2e-357%2F357-success)]() [![selftest](https://img.shields.io/badge/selftest-166-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-85-brightgreen)]() [![providers](https://img.shields.io/badge/AI_providers-10-brightgreen)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
 
 ```
   ╔══════════════════════════════════════════════════════════════╗
@@ -471,7 +471,7 @@ MIT — © leerness contributors
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.9.419 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.9.420 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### 정체성 — AI 에이전트 운영 레이어 (UR-0030)
 
@@ -525,7 +525,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.9.419는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **85개 도구**를 노출:
+Leerness v1.9.420는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **85개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -546,7 +546,7 @@ Leerness v1.9.419는 stdio JSON-RPC MCP server를 내장합니다 — Claude Cod
 `<<autonomous-loop-dynamic>>` 신호만 보내면 AI가:
 1) 다음 라운드 후보 선정 → 2) 코드 변경 → 3) stress-v* 신규 작성 + 누적 회귀 → 4) e2e 219/219 → 5) npm pack + git tag + GitHub release → 6) main 자동 push (1.9.140+) → 7) session close → 8) 다음 라운드 예약.
 
-현재 누적: **70 라운드 (1.9.40 → 1.9.419)** · 매 라운드 GitHub release/태그 생성 · _reports/는 비공개 보존.
+현재 누적: **70 라운드 (1.9.40 → 1.9.420)** · 매 라운드 GitHub release/태그 생성 · _reports/는 비공개 보존.
 
 ### 성능 가이드 (1.9.140 측정)
 
@@ -584,6 +584,6 @@ leerness release pack --close --auto-main-push
 - `.harness/session-handoff.md`: 다음 세션 인수인계 (자동 작성)
 - `.harness/lessons.md` / `decisions.md` / `rules.md`: 영구 메모리 (5 surface)
 
-Last synced by Leerness v1.9.419: 2026-06-07
+Last synced by Leerness v1.9.420: 2026-06-07
 <!-- leerness:project-readme:end -->
 

package/bin/leerness.js

@@ -31,7 +31,7 @@ const { _evidenceQuality, _parseEvidenceStats, _shellGuardAnalyze, _claimFileInG
 // 1.9.295 (UR-0025 4단계): 정적 데이터 카탈로그 모듈 분리 (비파괴, require-based).
 const { CAPABILITY_SURFACE, POWERFUL_COMMANDS, ADAPTERS, REUSE_CATEGORIES, REUSE_CHECKLIST, _DEFAULT_PLATFORM_CONSTRAINTS, _DEFAULT_DOMAIN_CATALOG, _LSP_LANG_PATTERNS, OPTIMISM_PATTERNS, BUILT_IN_PERSONAS, STRINGS, BUILTIN_CATALOG, ROADMAP_STATUS_LABEL, ROADMAP_STATUS_COLOR, SECRET_PATTERNS, MERGE_OVERWRITE_FILES, MINIMAL_SKIP_KEYS, REQUIRED_WORKSPACE_FILES, KEYWORD_STOPWORDS, SKILL_CATALOG_PRESETS } = require('../lib/catalogs');  // 1.9.344/368/369 (UR-0025): catalog 분리 (MERGE_OVERWRITE_FILES/MINIMAL_SKIP_KEYS 포함)
 
-const VERSION = '1.9.419';
+const VERSION = '1.9.420';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -3073,6 +3073,27 @@ function _selfTestCases() {
     } },
     { name: '9라운드 (UR-0119/0120): team review(메인 검수) — _composeTeamPlan reviewStep + handoff 검수필요 + team add 와이어 (1.9.414)', run: () => { const m = require('../lib/pure-utils'); const on = m._composeTeamPlan({ id: 't', members: ['a', 'b'], personas: ['security'] }, '점검'); const off = m._composeTeamPlan({ id: 't', members: ['a'], review: false }, '점검'); const planOk = on.review === true && !!on.reviewStep && on.reviewStep.suggestedCommand.includes('verify-claim') && off.review === false && !off.reviewStep; const rem = m._teamHandoffReminders([{ id: 'r', schedule: 'every-session', status: 'active', members: ['a'], review: true }]); const remOk = rem.length === 1 && rem[0].includes('검수필요'); const teamSrc = read(path.join(path.dirname(__filename), '..', 'lib', 'team.js')); const wired = teamSrc.includes("review: !has('--no-review')") && teamSrc.includes('메인 검수 (필수)'); return planOk && remOk && wired; } },
     { name: '파일명 변경 (UR-0126): bin 파일=leerness.js + package.json bin/main 일치 (1.9.419)', run: () => { const okName = path.basename(__filename) === 'leerness.js'; let pkg; try { pkg = require('../package.json'); } catch { return false; } const okBin = pkg && pkg.bin && pkg.bin.leerness === 'bin/leerness.js' && pkg.main === 'bin/leerness.js'; return okName && okBin; } },
+    { name: 'UR-0025 큰핸들러 모듈화 5번째: reviewRequestCmd → lib/review-request.js + DI 위임 + 동작 (1.9.420)', run: () => {
+      const m = require('../lib/review-request');
+      const expOk = typeof m.reviewRequestCmd === 'function';
+      const src = read(__filename);
+      const delegated = src.includes("require('../lib/review-request')") && src.includes('_reviewRequest.reviewRequestCmd(root, request,');
+      const modSrc = read(path.join(path.dirname(__filename), '..', 'lib', 'review-request.js'));
+      // thin wrapper 는 같은 시그니처를 유지하므로(시그니처 부재로 판정 X), 본문 고유 마커(routeKw)가 lib 로 이동했는지로 검증.
+      const bodyMarker = 'const route' + 'Kw = {';  // split-literal: 자기참조(이 케이스 코드가 src 에 포함) 회피
+      const movedToLib = modSrc.includes("require('./io')") && modSrc.includes('estimatedType') && modSrc.includes('harnessPath') && modSrc.includes(bodyMarker) && !src.includes(bodyMarker);
+      let behavOk = false;
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), '__leerness_rr_'));
+      const _w = process.stdout.write; let out = '';
+      try {
+        fs.mkdirSync(path.join(tmp, '.harness'), { recursive: true });
+        process.stdout.write = s => { out += s; return true; };
+        // harnessPath 를 존재하지 않는 경로로 → 내부 brainstorm spawn 즉시 실패(무부작용). estimatedType/steps 는 spawn 이전 계산이라 검증 가능.
+        m.reviewRequestCmd(tmp, '결제 기능 추가 구현', { has: () => true, harnessPath: path.join(tmp, '__nope.js'), _checkRequestConstraints: () => ({ matched: [], suggestions: [] }), _recordRun: () => {} });
+      } catch {} finally { process.stdout.write = _w; try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {} }
+      try { const j = JSON.parse(out); behavOk = j.estimatedType === 'feature' && Array.isArray(j.recommendedSteps) && j.recommendedSteps.length === 5; } catch {}
+      return expOk && delegated && movedToLib && behavOk;
+    } },
     { name: 'VERSION 형식 (x.y.z)', run: () => /^\d+\.\d+\.\d+$/.test(VERSION) }
   ];
 }
@@ -20418,283 +20439,9 @@ function lspCmd(root, sub, ...args) {
 //
 //   REPL: :review <request> (1.9.175 slash 패턴)
 //   MCP : leerness_review_request (외부 AI 직접 호출)
-function reviewRequestCmd(root, request) {
-  root = absRoot(root || process.cwd());
-  if (!request || !String(request).trim()) {
-    return fail('leerness review-request "<request>" — 사용자 요청 텍스트 필요');
-  }
-  const t0 = Date.now();
-  const text = String(request).trim();
-
-  // 1) 작업 유형 추정 (route 기반 키워드 매핑)
-  const lower = text.toLowerCase();
-  const routeKw = {
-    bugfix:      ['버그', '오류', '에러', '수정', '고쳐', '실패', 'fix', 'bug', 'error'],
-    refactor:    ['리팩토', '재구성', '정리', '개선', 'refactor', 'cleanup'],
-    feature:     ['추가', '구현', '만들', '새', '기능', 'add', 'implement', 'feature', 'create', 'new'],
-    research:    ['조사', '분석', '비교', '검토', '연구', 'research', 'analyze', 'compare', 'investigate'],
-    planning:    ['계획', '설계', '로드맵', 'plan', 'design', 'architecture', 'roadmap'],
-    release:     ['배포', '릴리즈', '버전', 'release', 'deploy', 'publish'],
-    consistency: ['일관성', '통합', '동기화', '맞춰', 'consistency', 'sync', 'align']
-  };
-  let estimatedType = 'feature';  // default
-  let maxScore = 0;
-  for (const [type, kws] of Object.entries(routeKw)) {
-    const score = kws.filter(k => lower.includes(k)).length;
-    if (score > maxScore) { maxScore = score; estimatedType = type; }
-  }
-
-  // 2) 기존 자원 회수 — brainstorm spawn (모든 surface 통합 회수)
-  const conflictHints = [];  // ⚠ 같은 키워드 + 실패/오류 패턴
-  const reuseCandidates = []; // 🔁 기존 skill / reuse-map / decision 후보
-  const lessonsRecall = [];   // 🧠 과거 lesson
-  const planConflicts = [];   // 📋 진행 중 milestone과 충돌 가능
-
-  // brainstorm 호출 (1.9.13~) — JSON 결과 회수
-  try {
-    const r = cp.spawnSync(process.execPath, [__filename, 'brainstorm', text, '--path', root, '--json'], {
-      encoding: 'utf8', timeout: 12000,
-      env: { ...process.env, LEERNESS_INTERNAL: '1', LEERNESS_NO_BANNER: '1', LEERNESS_NO_PROMPT: '1', LEERNESS_NO_DRIFT_CHECK: '1' }
-    });
-    if (r.stdout) {
-      const j = JSON.parse(r.stdout);
-      const hits = j.hits || {};
-      // decisions — 과거 결정 후보
-      (hits.decisions || []).slice(0, 5).forEach(d => {
-        lessonsRecall.push({ kind: 'decision', title: d.title, line: d.line, preview: (d.preview || '').slice(0, 100) });
-      });
-      // lessons — 과거 교훈 (특히 실패 키워드)
-      (hits.lessons || []).slice(0, 5).forEach(l => {
-        const preview = (l.text || l.preview || '').slice(0, 100);
-        const isFailure = /실패|오류|에러|fail|error|bug|문제|warning/i.test(preview);
-        if (isFailure) {
-          conflictHints.push({ kind: 'lesson-failure', preview, tags: l.tags });
-        } else {
-          lessonsRecall.push({ kind: 'lesson', preview, tags: l.tags });
-        }
-      });
-      // skills — 기존 skill 후보
-      (hits.skills || []).slice(0, 3).forEach(s => {
-        reuseCandidates.push({ kind: 'skill', id: s.id, displayNameKo: s.displayNameKo, capabilities: s.capabilities });
-      });
-      // tasks — 진행 중 task 충돌
-      (hits.tasks || []).slice(0, 3).forEach(tsk => {
-        if (tsk.status && /in-progress|진행/.test(String(tsk.status))) {
-          conflictHints.push({ kind: 'task-in-progress', id: tsk.id, title: tsk.title });
-        }
-      });
-      // plan milestones — 진행 중 milestone
-      (hits.planMilestones || []).slice(0, 3).forEach(m => {
-        if (m.status && /in-progress|진행/.test(String(m.status))) {
-          planConflicts.push({ kind: 'milestone-in-progress', id: m.id, title: m.title });
-        }
-      });
-      // taskLogFails — 과거 같은 키워드 실패 흔적
-      (hits.taskLogFails || []).slice(0, 3).forEach(f => {
-        conflictHints.push({ kind: 'task-log-failure', preview: (f.preview || f.text || '').slice(0, 100) });
-      });
-    }
-  } catch {}
-
-  // 3) reuse-map 매칭 — 기존 capability 등록 후보
-  try {
-    const reusePath = path.join(root, '.harness/reuse-map.md');
-    if (exists(reusePath)) {
-      const reuseLines = read(reusePath).split('\n');
-      const tokens = lower.split(/\s+/).filter(t => t.length >= 3);
-      for (const line of reuseLines) {
-        if (!/^\| /.test(line)) continue;  // 테이블 row만
-        const ll = line.toLowerCase();
-        const matched = tokens.filter(t => ll.includes(t)).length;
-        if (matched > 0) {
-          const cols = line.split('|').map(s => s.trim());
-          if (cols[1]) {
-            reuseCandidates.push({ kind: 'reuse-map', capability: cols[1], where: cols[2] || '', note: cols[3] || '' });
-          }
-        }
-      }
-    }
-  } catch {}
-
-  // 4) feature_graph — 같은 영역 변경 가능성
-  const featureConflicts = [];
-  try {
-    const fgPath = path.join(root, '.harness/feature_graph.md');
-    if (exists(fgPath)) {
-      const fg = read(fgPath);
-      const tokens = lower.split(/\s+/).filter(t => t.length >= 4);
-      // F-XXXX 노드 라인 추출
-      const nodeBlocks = fg.split(/\n### /);
-      for (const blk of nodeBlocks.slice(1)) {
-        const bl = blk.toLowerCase();
-        const matched = tokens.filter(t => bl.includes(t)).length;
-        if (matched > 0) {
-          const titleMatch = blk.match(/^([^\n]+)/);
-          const idMatch = blk.match(/F-\d+/);
-          if (titleMatch && idMatch) {
-            featureConflicts.push({ kind: 'feature', id: idMatch[0], title: titleMatch[1].trim() });
-          }
-        }
-      }
-    }
-  } catch {}
-
-  // 5) 권장 단계 (작업 유형별)
-  const recommendedSteps = {
-    feature: [
-      '1) leerness reuse-check "<기능>" — 외부 OSS 빌드 vs 재사용 판단 (1.9.285)',
-      '2) leerness reuse find "<핵심 capability>" — 내부 중복 구현 사전 차단',
-      '3) leerness plan add "<milestone>" — 진행 추적',
-      '4) leerness contract verify SPEC.md src/<mod>.js — 사양 ↔ 구현 일치 검증',
-      '5) verify-claim --run-tests 로 evidence 의무화'
-    ],
-    bugfix: [
-      '1) leerness brainstorm "<버그 키워드>" — 과거 같은 영역 lesson 회수',
-      '2) leerness verify-claim T-XXX --strict-claims — 낙관적 표시 사전 감지',
-      '3) verify-code --run-tests — 재현 + fix 검증',
-      '4) leerness lesson save "<root cause>" — 같은 실수 재발 차단'
-    ],
-    refactor: [
-      '1) leerness reuse-map — 영향 범위 파악',
-      '2) leerness impact <file> — 강한/약한 참조 분리',
-      '3) leerness contract verify — 외부 인터페이스 보존 확인',
-      '4) verify-code --run-tests + 회귀 테스트'
-    ],
-    research: [
-      '1) leerness brainstorm "<주제>" — 누적 컨텍스트 회수',
-      '2) leerness lessons --query "<주제>" — 과거 같은 영역 결정',
-      '3) leerness review <file> --persona research — 깊이 검토',
-      '4) leerness decision add "<결론>" — 회수 가능하게 영구화'
-    ],
-    planning: [
-      '1) leerness plan add "<milestone>" — 분해 시작',
-      '2) leerness reuse-map — 기존 자원 인벤토리',
-      '3) leerness agents recommend planning — sub-agent 분배',
-      '4) leerness session close — 결정 영구화'
-    ],
-    release: [
-      '1) leerness health — production-ready 확인',
-      '2) leerness audit + verify-code — 보안 + 검수',
-      '3) leerness release bump + note + publish'
-    ],
-    consistency: [
-      '1) leerness audit — design/reuse/handoff 일관성 검사',
-      '2) leerness consistency check — 잠재 일관성 위반',
-      '3) leerness drift check --auto-fix — 자동 회복'
-    ]
-  }[estimatedType] || [];
-
-  // 6) 효율 제안 (적용 가능한 sub-agent + skill)
-  const efficiencyHints = [];
-  if (reuseCandidates.length > 0) {
-    efficiencyHints.push(`🔁 기존 자원 ${reuseCandidates.length}건 발견 — 신규 구현 전 재사용 검토 권장`);
-  }
-  if (conflictHints.length > 0) {
-    efficiencyHints.push(`⚠ 충돌 신호 ${conflictHints.length}건 — 과거 실패 lesson / 진행 중 task 확인 필요`);
-  }
-  if (planConflicts.length > 0) {
-    efficiencyHints.push(`📋 진행 중 milestone ${planConflicts.length}건과 영역 겹침 가능 — plan 정렬 권장`);
-  }
-  if (featureConflicts.length > 0) {
-    efficiencyHints.push(`🕸 Feature Graph ${featureConflicts.length}건 영역 겹침 — 의존성 사전 확인`);
-  }
-  // 다중 에이전트 분배 추천
-  if (estimatedType === 'feature' || estimatedType === 'planning') {
-    efficiencyHints.push(`👥 leerness agents recommend ${estimatedType} — 작업 유형별 sub-agent 매핑 활용 가능`);
-  }
-  if (efficiencyHints.length === 0) {
-    efficiencyHints.push('✨ 충돌 신호 없음 — 즉시 진행 안전');
-  }
-
-  // 6.5) 1.9.208: 플랫폼/API 제약 사전 체크 — 사용자 명시 ("호출속도 초당 5회" 같은 규정 사전 확인)
-  let constraintsCheck = { matched: [], suggestions: [] };
-  try {
-    constraintsCheck = _checkRequestConstraints(root, text);
-    if (constraintsCheck.matched.length > 0) {
-      efficiencyHints.push(`⚠ 플랫폼 제약 ${constraintsCheck.matched.length}건 — leerness constraints check 로 상세 확인`);
-    }
-  } catch {}
-
-  // 7) proceed 권장 (충돌 critical 시 false)
-  const proceed = conflictHints.length < 3 && planConflicts.length === 0;
-
-  const dt = Date.now() - t0;
-  const out = {
-    request: text,
-    estimatedType,
-    conflicts: conflictHints,
-    reuseCandidates,
-    lessonsRecall,
-    planConflicts,
-    featureConflicts,
-    recommendedSteps,
-    efficiencyHints,
-    platformConstraints: constraintsCheck.matched,
-    constraintSuggestions: constraintsCheck.suggestions,
-    proceed,
-    proceedReason: proceed ? '안전 — 충돌 신호 < 3 + plan 충돌 0' : '⚠ 충돌 critical — 사용자 확인 후 진행',
-    durationMs: dt
-  };
-
-  try { _recordRun(root, { kind: 'review_request', estimatedType, conflicts: conflictHints.length, reuse: reuseCandidates.length, durationMs: dt, ok: true }); } catch {}
-
-  if (has('--json')) {
-    log(JSON.stringify(out, null, 2));
-    return;
-  }
-
-  log(`# leerness review-request (1.9.176 사전 검토)`);
-  log(`요청: "${text.slice(0, 200)}${text.length > 200 ? '…' : ''}"`);
-  log(`추정 작업 유형: ${estimatedType}`);
-  log('');
-  if (conflictHints.length) {
-    log(`## ⚠ 충돌 신호 (${conflictHints.length})`);
-    conflictHints.slice(0, 5).forEach(c => log(`  - [${c.kind}] ${c.title || c.id || ''} ${c.preview || ''}`.trim()));
-    log('');
-  }
-  if (reuseCandidates.length) {
-    log(`## 🔁 재사용 후보 (${reuseCandidates.length}) — 신규 구현 전 검토`);
-    reuseCandidates.slice(0, 5).forEach(r => {
-      if (r.kind === 'skill') log(`  - [skill] ${r.id}${r.displayNameKo ? ' · ' + r.displayNameKo : ''}`);
-      else if (r.kind === 'reuse-map') log(`  - [reuse] ${r.capability} @ ${r.where}`);
-    });
-    log('');
-  }
-  if (lessonsRecall.length) {
-    log(`## 🧠 과거 컨텍스트 (${lessonsRecall.length}) — 관련 결정/교훈`);
-    lessonsRecall.slice(0, 3).forEach(l => log(`  - [${l.kind}] ${l.title || l.preview}`));
-    log('');
-  }
-  if (planConflicts.length || featureConflicts.length) {
-    log(`## 📋 진행 중 영역 (${planConflicts.length + featureConflicts.length})`);
-    planConflicts.forEach(m => log(`  - [milestone] ${m.id}: ${m.title}`));
-    featureConflicts.slice(0, 5).forEach(f => log(`  - [feature] ${f.id}: ${f.title}`));
-    log('');
-  }
-  log(`## 💡 효율 제안`);
-  efficiencyHints.forEach(h => log(`  ${h}`));
-  log('');
-  // 1.9.208: 플랫폼/API 제약 사전 노출 (사용자 명시)
-  if (constraintsCheck.matched.length > 0) {
-    log(`## 🚦 플랫폼/API 제약 사전 체크 (${constraintsCheck.matched.length})`);
-    for (const m of constraintsCheck.matched) {
-      log(`  - 📦 ${m.platform}  (docs: ${m.docs || '-'})`);
-      for (const c of (m.constraints || []).slice(0, 3)) {
-        log(`     • [${c.kind}] ${c.detail}`);
-      }
-    }
-    log(`  → leerness constraints check "${text.slice(0, 40)}…" 로 상세 확인`);
-    log('');
-  }
-  if (recommendedSteps.length) {
-    log(`## 📍 권장 단계 (${estimatedType})`);
-    recommendedSteps.forEach(s => log(`  ${s}`));
-    log('');
-  }
-  log(`## ▶ 진행 권장: ${proceed ? '✓ 진행 안전' : '⚠ 사용자 확인 필요'}`);
-  log(`   사유: ${out.proceedReason}`);
-  log(`   분석 소요: ${dt}ms`);
-}
+const _reviewRequest = require('../lib/review-request');
+// 1.9.420 (UR-0125 큰 핸들러 모듈화 5번째): reviewRequestCmd → lib/review-request.js (DI 위임, thin wrapper)
+function reviewRequestCmd(root, request) { return _reviewRequest.reviewRequestCmd(root, request, { has, harnessPath: __filename, _checkRequestConstraints, _recordRun }); }
 
 // 1.9.164: leerness which — 진단 도구 (구버전 충돌 / npx 캐시 / PATH 충돌 해결)
 //   사용자가 "최신 버전 작동 안 함" 의심 시: 실제 실행 중인 leerness 의 경로 / 버전 / npm 캐시 / PATH 후보 표시.

package/lib/review-request.js

@@ -0,0 +1,288 @@
+// lib/review-request.js — review-request 핸들러 (UR-0125 큰 핸들러 모듈화, 1.9.420)
+//   bin/leerness.js 에서 reviewRequestCmd(277줄) 분리. DI: harness 고유 의존(has · harnessPath · _checkRequestConstraints · _recordRun) 주입.
+//   io 프리미티브는 ./io, cp/path 는 빌트인. 동작/출력 무변경(thin wrapper 위임).
+'use strict';
+const cp = require('child_process');
+const path = require('path');
+const { absRoot, exists, read, log, fail } = require('./io');
+
+function reviewRequestCmd(root, request, deps = {}) {
+  const { has, harnessPath, _checkRequestConstraints, _recordRun } = deps;
+  root = absRoot(root || process.cwd());
+  if (!request || !String(request).trim()) {
+    return fail('leerness review-request "<request>" — 사용자 요청 텍스트 필요');
+  }
+  const t0 = Date.now();
+  const text = String(request).trim();
+
+  // 1) 작업 유형 추정 (route 기반 키워드 매핑)
+  const lower = text.toLowerCase();
+  const routeKw = {
+    bugfix:      ['버그', '오류', '에러', '수정', '고쳐', '실패', 'fix', 'bug', 'error'],
+    refactor:    ['리팩토', '재구성', '정리', '개선', 'refactor', 'cleanup'],
+    feature:     ['추가', '구현', '만들', '새', '기능', 'add', 'implement', 'feature', 'create', 'new'],
+    research:    ['조사', '분석', '비교', '검토', '연구', 'research', 'analyze', 'compare', 'investigate'],
+    planning:    ['계획', '설계', '로드맵', 'plan', 'design', 'architecture', 'roadmap'],
+    release:     ['배포', '릴리즈', '버전', 'release', 'deploy', 'publish'],
+    consistency: ['일관성', '통합', '동기화', '맞춰', 'consistency', 'sync', 'align']
+  };
+  let estimatedType = 'feature';  // default
+  let maxScore = 0;
+  for (const [type, kws] of Object.entries(routeKw)) {
+    const score = kws.filter(k => lower.includes(k)).length;
+    if (score > maxScore) { maxScore = score; estimatedType = type; }
+  }
+
+  // 2) 기존 자원 회수 — brainstorm spawn (모든 surface 통합 회수)
+  const conflictHints = [];  // ⚠ 같은 키워드 + 실패/오류 패턴
+  const reuseCandidates = []; // 🔁 기존 skill / reuse-map / decision 후보
+  const lessonsRecall = [];   // 🧠 과거 lesson
+  const planConflicts = [];   // 📋 진행 중 milestone과 충돌 가능
+
+  // brainstorm 호출 (1.9.13~) — JSON 결과 회수
+  try {
+    const r = cp.spawnSync(process.execPath, [harnessPath, 'brainstorm', text, '--path', root, '--json'], {
+      encoding: 'utf8', timeout: 12000,
+      env: { ...process.env, LEERNESS_INTERNAL: '1', LEERNESS_NO_BANNER: '1', LEERNESS_NO_PROMPT: '1', LEERNESS_NO_DRIFT_CHECK: '1' }
+    });
+    if (r.stdout) {
+      const j = JSON.parse(r.stdout);
+      const hits = j.hits || {};
+      // decisions — 과거 결정 후보
+      (hits.decisions || []).slice(0, 5).forEach(d => {
+        lessonsRecall.push({ kind: 'decision', title: d.title, line: d.line, preview: (d.preview || '').slice(0, 100) });
+      });
+      // lessons — 과거 교훈 (특히 실패 키워드)
+      (hits.lessons || []).slice(0, 5).forEach(l => {
+        const preview = (l.text || l.preview || '').slice(0, 100);
+        const isFailure = /실패|오류|에러|fail|error|bug|문제|warning/i.test(preview);
+        if (isFailure) {
+          conflictHints.push({ kind: 'lesson-failure', preview, tags: l.tags });
+        } else {
+          lessonsRecall.push({ kind: 'lesson', preview, tags: l.tags });
+        }
+      });
+      // skills — 기존 skill 후보
+      (hits.skills || []).slice(0, 3).forEach(s => {
+        reuseCandidates.push({ kind: 'skill', id: s.id, displayNameKo: s.displayNameKo, capabilities: s.capabilities });
+      });
+      // tasks — 진행 중 task 충돌
+      (hits.tasks || []).slice(0, 3).forEach(tsk => {
+        if (tsk.status && /in-progress|진행/.test(String(tsk.status))) {
+          conflictHints.push({ kind: 'task-in-progress', id: tsk.id, title: tsk.title });
+        }
+      });
+      // plan milestones — 진행 중 milestone
+      (hits.planMilestones || []).slice(0, 3).forEach(m => {
+        if (m.status && /in-progress|진행/.test(String(m.status))) {
+          planConflicts.push({ kind: 'milestone-in-progress', id: m.id, title: m.title });
+        }
+      });
+      // taskLogFails — 과거 같은 키워드 실패 흔적
+      (hits.taskLogFails || []).slice(0, 3).forEach(f => {
+        conflictHints.push({ kind: 'task-log-failure', preview: (f.preview || f.text || '').slice(0, 100) });
+      });
+    }
+  } catch {}
+
+  // 3) reuse-map 매칭 — 기존 capability 등록 후보
+  try {
+    const reusePath = path.join(root, '.harness/reuse-map.md');
+    if (exists(reusePath)) {
+      const reuseLines = read(reusePath).split('\n');
+      const tokens = lower.split(/\s+/).filter(t => t.length >= 3);
+      for (const line of reuseLines) {
+        if (!/^\| /.test(line)) continue;  // 테이블 row만
+        const ll = line.toLowerCase();
+        const matched = tokens.filter(t => ll.includes(t)).length;
+        if (matched > 0) {
+          const cols = line.split('|').map(s => s.trim());
+          if (cols[1]) {
+            reuseCandidates.push({ kind: 'reuse-map', capability: cols[1], where: cols[2] || '', note: cols[3] || '' });
+          }
+        }
+      }
+    }
+  } catch {}
+
+  // 4) feature_graph — 같은 영역 변경 가능성
+  const featureConflicts = [];
+  try {
+    const fgPath = path.join(root, '.harness/feature_graph.md');
+    if (exists(fgPath)) {
+      const fg = read(fgPath);
+      const tokens = lower.split(/\s+/).filter(t => t.length >= 4);
+      // F-XXXX 노드 라인 추출
+      const nodeBlocks = fg.split(/\n### /);
+      for (const blk of nodeBlocks.slice(1)) {
+        const bl = blk.toLowerCase();
+        const matched = tokens.filter(t => bl.includes(t)).length;
+        if (matched > 0) {
+          const titleMatch = blk.match(/^([^\n]+)/);
+          const idMatch = blk.match(/F-\d+/);
+          if (titleMatch && idMatch) {
+            featureConflicts.push({ kind: 'feature', id: idMatch[0], title: titleMatch[1].trim() });
+          }
+        }
+      }
+    }
+  } catch {}
+
+  // 5) 권장 단계 (작업 유형별)
+  const recommendedSteps = {
+    feature: [
+      '1) leerness reuse-check "<기능>" — 외부 OSS 빌드 vs 재사용 판단 (1.9.285)',
+      '2) leerness reuse find "<핵심 capability>" — 내부 중복 구현 사전 차단',
+      '3) leerness plan add "<milestone>" — 진행 추적',
+      '4) leerness contract verify SPEC.md src/<mod>.js — 사양 ↔ 구현 일치 검증',
+      '5) verify-claim --run-tests 로 evidence 의무화'
+    ],
+    bugfix: [
+      '1) leerness brainstorm "<버그 키워드>" — 과거 같은 영역 lesson 회수',
+      '2) leerness verify-claim T-XXX --strict-claims — 낙관적 표시 사전 감지',
+      '3) verify-code --run-tests — 재현 + fix 검증',
+      '4) leerness lesson save "<root cause>" — 같은 실수 재발 차단'
+    ],
+    refactor: [
+      '1) leerness reuse-map — 영향 범위 파악',
+      '2) leerness impact <file> — 강한/약한 참조 분리',
+      '3) leerness contract verify — 외부 인터페이스 보존 확인',
+      '4) verify-code --run-tests + 회귀 테스트'
+    ],
+    research: [
+      '1) leerness brainstorm "<주제>" — 누적 컨텍스트 회수',
+      '2) leerness lessons --query "<주제>" — 과거 같은 영역 결정',
+      '3) leerness review <file> --persona research — 깊이 검토',
+      '4) leerness decision add "<결론>" — 회수 가능하게 영구화'
+    ],
+    planning: [
+      '1) leerness plan add "<milestone>" — 분해 시작',
+      '2) leerness reuse-map — 기존 자원 인벤토리',
+      '3) leerness agents recommend planning — sub-agent 분배',
+      '4) leerness session close — 결정 영구화'
+    ],
+    release: [
+      '1) leerness health — production-ready 확인',
+      '2) leerness audit + verify-code — 보안 + 검수',
+      '3) leerness release bump + note + publish'
+    ],
+    consistency: [
+      '1) leerness audit — design/reuse/handoff 일관성 검사',
+      '2) leerness consistency check — 잠재 일관성 위반',
+      '3) leerness drift check --auto-fix — 자동 회복'
+    ]
+  }[estimatedType] || [];
+
+  // 6) 효율 제안 (적용 가능한 sub-agent + skill)
+  const efficiencyHints = [];
+  if (reuseCandidates.length > 0) {
+    efficiencyHints.push(`🔁 기존 자원 ${reuseCandidates.length}건 발견 — 신규 구현 전 재사용 검토 권장`);
+  }
+  if (conflictHints.length > 0) {
+    efficiencyHints.push(`⚠ 충돌 신호 ${conflictHints.length}건 — 과거 실패 lesson / 진행 중 task 확인 필요`);
+  }
+  if (planConflicts.length > 0) {
+    efficiencyHints.push(`📋 진행 중 milestone ${planConflicts.length}건과 영역 겹침 가능 — plan 정렬 권장`);
+  }
+  if (featureConflicts.length > 0) {
+    efficiencyHints.push(`🕸 Feature Graph ${featureConflicts.length}건 영역 겹침 — 의존성 사전 확인`);
+  }
+  // 다중 에이전트 분배 추천
+  if (estimatedType === 'feature' || estimatedType === 'planning') {
+    efficiencyHints.push(`👥 leerness agents recommend ${estimatedType} — 작업 유형별 sub-agent 매핑 활용 가능`);
+  }
+  if (efficiencyHints.length === 0) {
+    efficiencyHints.push('✨ 충돌 신호 없음 — 즉시 진행 안전');
+  }
+
+  // 6.5) 1.9.208: 플랫폼/API 제약 사전 체크 — 사용자 명시 ("호출속도 초당 5회" 같은 규정 사전 확인)
+  let constraintsCheck = { matched: [], suggestions: [] };
+  try {
+    constraintsCheck = _checkRequestConstraints(root, text);
+    if (constraintsCheck.matched.length > 0) {
+      efficiencyHints.push(`⚠ 플랫폼 제약 ${constraintsCheck.matched.length}건 — leerness constraints check 로 상세 확인`);
+    }
+  } catch {}
+
+  // 7) proceed 권장 (충돌 critical 시 false)
+  const proceed = conflictHints.length < 3 && planConflicts.length === 0;
+
+  const dt = Date.now() - t0;
+  const out = {
+    request: text,
+    estimatedType,
+    conflicts: conflictHints,
+    reuseCandidates,
+    lessonsRecall,
+    planConflicts,
+    featureConflicts,
+    recommendedSteps,
+    efficiencyHints,
+    platformConstraints: constraintsCheck.matched,
+    constraintSuggestions: constraintsCheck.suggestions,
+    proceed,
+    proceedReason: proceed ? '안전 — 충돌 신호 < 3 + plan 충돌 0' : '⚠ 충돌 critical — 사용자 확인 후 진행',
+    durationMs: dt
+  };
+
+  try { _recordRun(root, { kind: 'review_request', estimatedType, conflicts: conflictHints.length, reuse: reuseCandidates.length, durationMs: dt, ok: true }); } catch {}
+
+  if (has('--json')) {
+    log(JSON.stringify(out, null, 2));
+    return;
+  }
+
+  log(`# leerness review-request (1.9.176 사전 검토)`);
+  log(`요청: "${text.slice(0, 200)}${text.length > 200 ? '…' : ''}"`);
+  log(`추정 작업 유형: ${estimatedType}`);
+  log('');
+  if (conflictHints.length) {
+    log(`## ⚠ 충돌 신호 (${conflictHints.length})`);
+    conflictHints.slice(0, 5).forEach(c => log(`  - [${c.kind}] ${c.title || c.id || ''} ${c.preview || ''}`.trim()));
+    log('');
+  }
+  if (reuseCandidates.length) {
+    log(`## 🔁 재사용 후보 (${reuseCandidates.length}) — 신규 구현 전 검토`);
+    reuseCandidates.slice(0, 5).forEach(r => {
+      if (r.kind === 'skill') log(`  - [skill] ${r.id}${r.displayNameKo ? ' · ' + r.displayNameKo : ''}`);
+      else if (r.kind === 'reuse-map') log(`  - [reuse] ${r.capability} @ ${r.where}`);
+    });
+    log('');
+  }
+  if (lessonsRecall.length) {
+    log(`## 🧠 과거 컨텍스트 (${lessonsRecall.length}) — 관련 결정/교훈`);
+    lessonsRecall.slice(0, 3).forEach(l => log(`  - [${l.kind}] ${l.title || l.preview}`));
+    log('');
+  }
+  if (planConflicts.length || featureConflicts.length) {
+    log(`## 📋 진행 중 영역 (${planConflicts.length + featureConflicts.length})`);
+    planConflicts.forEach(m => log(`  - [milestone] ${m.id}: ${m.title}`));
+    featureConflicts.slice(0, 5).forEach(f => log(`  - [feature] ${f.id}: ${f.title}`));
+    log('');
+  }
+  log(`## 💡 효율 제안`);
+  efficiencyHints.forEach(h => log(`  ${h}`));
+  log('');
+  // 1.9.208: 플랫폼/API 제약 사전 노출 (사용자 명시)
+  if (constraintsCheck.matched.length > 0) {
+    log(`## 🚦 플랫폼/API 제약 사전 체크 (${constraintsCheck.matched.length})`);
+    for (const m of constraintsCheck.matched) {
+      log(`  - 📦 ${m.platform}  (docs: ${m.docs || '-'})`);
+      for (const c of (m.constraints || []).slice(0, 3)) {
+        log(`     • [${c.kind}] ${c.detail}`);
+      }
+    }
+    log(`  → leerness constraints check "${text.slice(0, 40)}…" 로 상세 확인`);
+    log('');
+  }
+  if (recommendedSteps.length) {
+    log(`## 📍 권장 단계 (${estimatedType})`);
+    recommendedSteps.forEach(s => log(`  ${s}`));
+    log('');
+  }
+  log(`## ▶ 진행 권장: ${proceed ? '✓ 진행 안전' : '⚠ 사용자 확인 필요'}`);
+  log(`   사유: ${out.proceedReason}`);
+  log(`   분석 소요: ${dt}ms`);
+}
+
+module.exports = { reviewRequestCmd };

package/package.json

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