leerness 1.9.35 → 1.9.37

package/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Changelog
 
+## 1.9.37 — 2026-05-18
+
+**메인 에이전트의 "leerness 점점 안 쓰는" drift 현상 자동 감지·경고**.
+
+### 배경
+실 워크스페이스 분석 결과: 라운드가 길어질수록 메인 에이전트가 `session close` / `task add` 등을 점점 잊는 패턴 발견.
+- session-handoff.md 4.6일 stale
+- task-log.md 4.6일 stale
+- progress-tracker T-row 3일간 0건 업데이트
+- 신규 sub-app 4개에 task 0건 등록
+
+→ **drift score 100/200 (🔴 critical) 등급**. 사용자 우려 사실 확인.
+
+### Added
+
+- **`leerness drift check [path]`** 신규 명령:
+  - 4개 신호 측정: session-handoff.md, current-state.md, progress-tracker.md, task-log.md의 staleness
+  - 추가 신호: `_apps/*` 중 task 0건인 sub-project 수
+  - 가중치 합계 → 4단계 레벨 (🟢 healthy / 🟠 attention / 🟡 warning / 🔴 critical)
+  - 임계 0/20/50/100. 점수 ≥100 시 exit 1 (CI 친화)
+  - `--json` 출력 지원
+  - 권장 조치 자동 안내 (`session close` / `audit --fix` / `task add`)
+- **`handoff` 자동 drift 경고** — handoff 호출 시 빠른 inline check (전체 `drift check` 안 호출). session-handoff/progress-tracker 중 하나라도 2일 이상 stale이면 노랑색 경고 + 권장 명령 안내.
+- **스킵 옵션**: `--no-drift-check` 플래그 + `LEERNESS_NO_DRIFT_CHECK=1` 환경변수
+
+### 실측 (이번 라운드)
+- 실 워크스페이스: drift 100/200 (critical) → `session close` 1회 후 30/200 (attention)
+- e2e: 170/170 PASS (1.9.36 166 + 신규 4)
+
+### 정책
+- ✅ drift 경고는 *알림만* — 자동 실행 금지 (사용자/메인이 명시적 선택)
+- ✅ 빠른 inline check (handoff) vs 상세 보고 (`drift check`) 분리
+- ✅ CI 친화: `--no-drift-check` 또는 env로 끄기 가능
+
+## 1.9.36 — 2026-05-18
+
+**외부 AI CLI 오케스트레이션 강화: dispatch 안전 모드 + agents bench + 작업 유형 추천 + stress test에서 발견한 2 BUG 즉시 수정**.
+
+### Added
+
+- **`leerness agents bench "<task>" [--write] [--timeout N]`** — 활성/설치된 모든 ready CLI에 같은 task를 동시 호출. 결과: 시간/exit/응답길이/마지막 라인 비교 매트릭스 + 🏆 가장 빠른 CLI 자동 표시. `--json` 출력 지원.
+- **`agents dispatch`에 `--write` 모드 추가** — 기본은 read-only (안전). `--write` 명시 시 각 CLI에 위험 플래그 자동 첨부:
+  - claude → `--print --dangerously-skip-permissions`
+  - codex → `exec --skip-git-repo-check --dangerously-bypass-approvals-and-sandbox`
+  - gemini → `-p --yolo`
+- **`_recommendAgent()` 작업 유형 기반 CLI 추천** — task 키워드 분석:
+  - 번역/요약/분석/review → **claude** (1.7× 빠름)
+  - 아키텍처/리팩터/복잡 → **codex** (가장 상세)
+  - 생성/작성/수정/구현 → **gemini --yolo** (직접 수정 정확)
+  - ready 체크 전에 출력 → 비활성이어도 추천 안내
+- **`dispatch` 출력에 CLI별 안내 추가** — codex의 POSIX path 변환 차이, gemini의 yolo 위험성 등.
+
+### Fixed (stress test에서 발견된 진짜 BUG)
+
+- 🔴 **`contract verify` require() side-effect 제거** — `require(implFile)`가 스크립트 본문 실행 → 18초 소요 + 임의 코드 실행 위험. **정적 소스 분석** (`module.exports = {...}` / `exports.foo =` 패턴 grep)으로 교체. 18,245ms → **705ms (25.9× 빠름)** + 보안 위험 제거.
+- 🟡 **`reuse autodetect` 디렉토리 제한 해제** — `src/`만 스캔 → **src/, bin/, lib/, app/ 4개 디렉토리** 스캔. require → 정적 분석.
+
+### Verified
+- 신규 프로젝트 `_apps/leerness-stress` 생성 + 31개 leerness 명령 자동 호출 stress test
+- 결과: 28 PASS / 3 의도된 BUG 감지 (false positive 0건)
+- e2e: 166/166 PASS (1.9.35 161 + 신규 5)
+
 ## 1.9.35 — 2026-05-17
 
 **파이프라인 메타-감사에서 도출된 5개 개선 사항 통합**.

package/README.md

@@ -2,7 +2,7 @@
 
 > **AI 에이전트 검수·다중 협업 CLI 하네스** — 거짓 완료 차단, 멀티 에이전트 오케스트레이션, 사양 ↔ 구현 일치 검증, 워크스페이스 통합 가시성. **한국어 우선**.
 
-[![npm](https://img.shields.io/badge/npm-leerness-blue)](https://www.npmjs.com/package/leerness) [![version](https://img.shields.io/badge/version-1.9.35-green)]() [![tests](https://img.shields.io/badge/e2e-161%2F161-success)]() [![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.37-green)]() [![tests](https://img.shields.io/badge/e2e-170%2F170-success)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
 
 > Claude Code · Cursor · Copilot · Codex · Gemini CLI — 어떤 AI 에이전트로 코드를 짜든, leerness는 **"진짜로 했나? 중복 아닌가? 합의된 사양인가?"** 를 자동으로 검수합니다.
 
@@ -42,6 +42,7 @@ AI 에이전트(Claude Code, Cursor, Copilot, Codex, Gemini CLI 등)는 **빠르
 | 🚨 신규 모듈의 capability가 reuse-map에 등록 안 됨 | **`leerness reuse autodetect`** — `module.exports` 스캔 + 자동 등록 (1.9.35) |
 | 🚨 신규 디렉토리에서 sub-agent가 컨텍스트 없이 작업 시작 | `handoff` 호출 시 **.harness 부재 자동 경고** (1.9.35) |
 | 🚨 audit warning이 쌓이지만 수동 fix가 번거로움 | **`audit --fix`** — session-handoff/current-state 자동 갱신 (1.9.35) |
+| 🚨 **프로젝트가 길어질수록 메인 에이전트가 leerness를 점점 안 씀** (메타파일 stale, session close 누락) | **`leerness drift check`** — 4개 신호로 staleness 측정 + handoff 시 자동 경고 (1.9.37) |
 
 ---
 
@@ -275,9 +276,10 @@ leerness deps <capability> --run-tests         # 영향 추적 + 자동 회귀
 leerness setup-agents .                        # 인터랙티브 활성화 + 자동 설치
 leerness agents list                           # 4 CLI 상태표
 leerness agents quota                          # 사용량 추정
-leerness agents dispatch "<task>" --to gemini  # 명령 생성 (안전 규칙 포함)
-leerness contract verify <spec.md> <impl.js>   # 1.9.35 명세 ↔ 구현 일치 검사
-leerness reuse autodetect [path] [--apply]    # 1.9.35 capability 자동 등록
+leerness agents dispatch "<task>" --to gemini --write  # 1.9.36 --write: --yolo 자동 첨부
+leerness agents bench "<task>" [--timeout N]   # 1.9.36 ready CLI 모두 병렬 호출 + 비교표
+leerness contract verify <spec.md> <impl.js>   # 1.9.35/36 명세 ↔ 구현 일치 검사 (정적 분석)
+leerness reuse autodetect [path] [--apply]    # 1.9.35/36 capability 자동 등록 (src/bin/lib/app)
 leerness audit . --fix                          # 1.9.35 누락 메타 자동 갱신
 ```
 
@@ -470,6 +472,8 @@ npm test     # = node ./scripts/e2e.js
 
 ## 📜 변경 이력 (최근)
 
+- **1.9.37** — `leerness drift check` — 라운드가 길어질수록 메인 에이전트가 leerness를 점점 안 쓰는 현상 자동 감지. handoff 시 자동 경고 + 4단계 레벨 (healthy/attention/warning/critical) + 권장 조치 안내. 실 워크스페이스에서 4.6일 stale, drift 100/200 (critical) 발견 → session close 1회로 30/200 (attention) 회복 실증.
+- **1.9.36** — 외부 AI CLI 오케스트레이션 강화: `agents bench` (3 CLI 동시 비교) + `dispatch --write` 자동 권장 플래그 + 작업 유형 키워드 추천. stress test에서 발견한 `contract verify` require() side-effect (보안 위험 + 25× 속도 회복) 즉시 수정.
 - **1.9.35** — 파이프라인 메타-감사에서 도출된 5개 개선 통합: `contract verify` · `reuse autodetect` · `audit --fix` · `handoff` init 부재 경고 · `agents dispatch` 안전 규칙 안내.
 - **1.9.34** — 방향키/스페이스 인터랙티브 multi-select (`_selectOne`/`_selectMany`) + 256색 그라데이션 배너 + 3단계 sub-agent 오케스트레이션 검증 (2.2× 효율 실측).
 - **1.9.33** — `_warnIfStale()` — `npx leerness init` 시 옛 버전 자동 경고 + 해결 안내.

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.35';
+const VERSION = '1.9.37';
 const MARK = '<!-- leerness:managed -->';
 const README_START = '<!-- leerness:project-readme:start -->';
 const README_END = '<!-- leerness:project-readme:end -->';
@@ -1432,6 +1432,38 @@ function handoffCmd(root) {
   if (has('--all-apps') || arg('--include', null)) {
     return _handoffWorkspace(absRoot(root));
   }
+  // 1.9.37: drift 자동 경고 (메인 에이전트가 leerness를 점점 안 쓰는 현상 감지)
+  const absR0 = absRoot(root || process.cwd());
+  if (exists(path.join(absR0, '.harness')) && !has('--no-drift-check') && process.env.LEERNESS_NO_DRIFT_CHECK !== '1') {
+    try {
+      const isTty = process.stdout && process.stdout.isTTY;
+      const yel = s => isTty ? `\x1b[33m${s}\x1b[0m` : s;
+      const red = s => isTty ? `\x1b[31m${s}\x1b[0m` : s;
+      const dim = s => isTty ? `\x1b[2m${s}\x1b[0m` : s;
+      // 간이 drift 계산 (전체 driftCheckCmd 호출 안 함 — 빠른 inline check)
+      const now = Date.now();
+      const shPath = handoffPath(absR0);
+      let shAge = null;
+      if (exists(shPath)) {
+        const m = read(shPath).match(/Last generated:\s*([\d\-T:.Z]+)/);
+        if (m) shAge = (now - new Date(m[1]).getTime()) / 86400000;
+      }
+      const rows = readProgressRows(absR0);
+      let ptAge = null;
+      if (rows.length) {
+        const dates = rows.map(r => (r.updated || '').match(/\d{4}-\d{2}-\d{2}/)).filter(Boolean).map(m => m[0]).sort();
+        if (dates.length) ptAge = (now - new Date(dates[dates.length - 1]).getTime()) / 86400000;
+      }
+      if ((shAge !== null && shAge > 2) || (ptAge !== null && ptAge > 2)) {
+        log('');
+        log(yel('  ⚠ leerness drift 감지 — 메타파일이 stale합니다'));
+        if (shAge !== null && shAge > 2) log(dim(`     session-handoff.md: ${shAge.toFixed(1)}일 stale`));
+        if (ptAge !== null && ptAge > 2) log(dim(`     progress-tracker:   ${ptAge.toFixed(1)}일 stale`));
+        log(dim(`     → 권장: ${red('leerness session close .')} 또는 ${red('leerness drift check .')} 로 상세 보기`));
+        log('');
+      }
+    } catch {}
+  }
   // 1.9.35 개선 #1: .harness 부재 시 즉시 경고 (자동 init 권장)
   // 사용자가 신규 디렉토리에서 handoff 호출 시 sub-agent 작업이 길을 잃지 않도록.
   const absR = absRoot(root || process.cwd());
@@ -2369,6 +2401,30 @@ const EXTERNAL_AGENTS = [
     installCmd: 'gh extension install github/gh-copilot', installHint: 'https://github.com/github/gh-copilot (gh CLI 선행 설치 필요)' }
 ];
 
+// 1.9.36: 작업 키워드 분석으로 최적 CLI 추천
+// \b는 ASCII word boundary만 인식 → 한글 키워드는 단순 substring 검사 사용.
+function _recommendAgent(task) {
+  if (!task || typeof task !== 'string') return { target: null, reason: '' };
+  const t = task.toLowerCase();
+  const hasAny = (keywords) => keywords.some(k => t.includes(k));
+  // 텍스트 분석/번역 → claude (가장 빠름, 1.7×)
+  if (hasAny(['translate', 'summary', 'explain', 'describe', 'analyze', 'review',
+              '번역', '요약', '설명', '분석', '리뷰'])) {
+    return { target: 'claude', reason: '텍스트 분석·요약·번역은 claude가 1.7× 빠름' };
+  }
+  // 깊은 코드 추론
+  if (hasAny(['architecture', 'design pattern', 'refactor', 'trace', 'complex', 'critical path',
+              '아키텍처', '리팩터', '복잡'])) {
+    return { target: 'codex', reason: '깊은 코드 추론은 codex가 가장 상세' };
+  }
+  // 파일 작성·수정·생성
+  if (hasAny(['create', 'write', 'generate', 'patch', 'fix', 'implement', 'edit',
+              '구현', '생성', '작성', '수정', '추가'])) {
+    return { target: 'gemini', reason: '워크스페이스 직접 수정은 gemini --yolo가 정확' };
+  }
+  return { target: null, reason: '' };
+}
+
 function _checkAgent(agent, opts = {}) {
   const enabled = process.env[agent.envFlag] === '1';
   // PATH 존재 확인 (which / where)
@@ -2806,32 +2862,51 @@ function agentsCmd(root, sub, ...args) {
     if (!target) { fail('--to <agent_id> 필요 (claude/codex/gemini/copilot)'); return process.exit(1); }
     const agentDef = EXTERNAL_AGENTS.find(a => a.id === target);
     if (!agentDef) { fail(`알 수 없는 agent: ${target}`); return process.exit(1); }
+    // 1.9.36: 작업 유형 키워드 분석 → 최적 CLI 추천 (ready 체크 전에 출력 — 비활성이어도 추천)
+    const recommendation = _recommendAgent(task);
+    const recommended = recommendation.target;
+    if (recommended && recommended !== target) {
+      log(`💡 추천: 이 작업은 ${recommended}가 더 적합 (${recommendation.reason})`);
+    }
     const status = _checkAgent(agentDef);
     if (status.status !== 'ready') {
       fail(`${target} 비활성 (${status.status}). 환경변수 ${agentDef.envFlag}=1 + CLI 설치 필요.`);
       return process.exit(1);
     }
+    // 1.9.36: --write 시 파일 수정 가능 권장 플래그 자동 첨부, 미명시 시 read-only 안전 모드
+    const writeMode = has('--write');
+    const readOnly = has('--readonly') || !writeMode;
     // 실제 호출은 안 함 — 프롬프트만 생성 (사용자가 명시적으로 실행)
-    log(`# leerness agents dispatch (1.9.30)`);
+    log(`# leerness agents dispatch (1.9.36)`);
     log(`대상: ${target} (${agentDef.bin})`);
     log(`상태: 🟢 ready, 버전 ${status.version || '?'}`);
+    log(`모드: ${writeMode ? '✏ write (파일 수정 가능)' : '🔒 read-only (분석 전용, 안전)'}`);
     log('');
     log(`## 실행 명령 (사용자가 복사해서 실행)`);
     log('');
+    const q = task.replace(/"/g, '\\"');
     if (target === 'claude') {
-      log(`claude "${task.replace(/"/g, '\\"')}"`);
+      const flags = writeMode ? '--print --dangerously-skip-permissions' : '--print';
+      log(`claude ${flags} "${q}"`);
+      if (writeMode) log(`# ⚠ --dangerously-skip-permissions: 도구 권한 자동 승인 (파일 수정 가능)`);
     } else if (target === 'codex') {
-      log(`codex exec "${task.replace(/"/g, '\\"')}"`);
+      const flags = writeMode ? 'exec --skip-git-repo-check --dangerously-bypass-approvals-and-sandbox' : 'exec --skip-git-repo-check';
+      log(`codex ${flags} "${q}"`);
+      log(`# ℹ codex는 PowerShell 경유 — POSIX /tmp 경로는 C:\\tmp\\로 해석됨`);
+      if (writeMode) log(`# ⚠ --dangerously-bypass-approvals-and-sandbox: sandbox 우회`);
     } else if (target === 'gemini') {
-      log(`gemini -p "${task.replace(/"/g, '\\"')}" --yolo   # ⚠ yolo는 워크스페이스 직접 수정 가능`);
+      const flags = writeMode ? '-p --yolo' : '-p';
+      log(`gemini ${flags} "${q}"`);
+      if (writeMode) log(`# ⚠ --yolo: 워크스페이스 파일 직접 수정 가능`);
     } else if (target === 'copilot') {
-      log(`gh copilot suggest "${task.replace(/"/g, '\\"')}"`);
+      log(`gh copilot suggest "${q}"`);
     }
     log('');
-    log(`## 정책 (1.9.30)`);
+    log(`## 정책 (1.9.36)`);
     log(`  - leerness는 외부 CLI를 자동 호출하지 않음 (사용자 명시적 실행)`);
     log(`  - 메인 에이전트(Claude)가 위 명령을 보고 sub-agent로 spawn 가능`);
     log(`  - quota 체크: \`leerness agents quota\` (1.9.31+)`);
+    log(`  - 동시 호출 시: \`leerness agents bench "<task>"\` (1.9.36)`);
     log('');
     log(`## 분배 시 안전 규칙 (1.9.35)`);
     log(`  - sub-agent 프롬프트에 "당신만 수정할 파일 경로"를 명시 (파일 경로 격리)`);
@@ -2841,6 +2916,85 @@ function agentsCmd(root, sub, ...args) {
     return;
   }
 
+  if (sub === 'bench') {
+    // 1.9.36: 같은 prompt를 ready CLI 모두에 동시 호출 + 시간/응답 길이/exit code 비교
+    const task = args.filter(x => !x.startsWith('-')).join(' ').trim() || arg('--task', null);
+    if (!task) { fail('bench "<task>" 필요'); return process.exit(1); }
+    const timeoutS = parseInt(arg('--timeout', '60'), 10);
+    const writeMode = has('--write');
+    const ready = EXTERNAL_AGENTS.map(a => ({ agent: a, status: _checkAgent(a) }))
+                                  .filter(x => x.status.status === 'ready');
+    if (!ready.length) {
+      fail('ready CLI 없음 — leerness setup-agents 또는 .env에 LEERNESS_ENABLE_X=1 설정 필요');
+      return process.exit(1);
+    }
+    log(`# leerness agents bench (1.9.36)`);
+    log(`task: ${task.slice(0, 80)}${task.length > 80 ? '…' : ''}`);
+    log(`참여 CLI: ${ready.map(r => r.agent.id).join(', ')} (${ready.length}개)`);
+    log(`타임아웃: ${timeoutS}s/CLI · 모드: ${writeMode ? 'write' : 'read-only'}`);
+    log('');
+    log('병렬 호출 중... (병렬 fork 후 wait)');
+    log('');
+    const results = [];
+    const promises = ready.map(({ agent, status }) => new Promise((resolve) => {
+      const t0 = Date.now();
+      let cmd, cmdArgs;
+      if (agent.id === 'claude') {
+        cmdArgs = writeMode ? ['--print', '--dangerously-skip-permissions', task] : ['--print', task];
+        cmd = 'claude';
+      } else if (agent.id === 'codex') {
+        cmdArgs = writeMode
+          ? ['exec', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', task]
+          : ['exec', '--skip-git-repo-check', task];
+        cmd = 'codex';
+      } else if (agent.id === 'gemini') {
+        cmdArgs = writeMode ? ['-p', task, '--yolo'] : ['-p', task];
+        cmd = 'gemini';
+      } else if (agent.id === 'copilot') {
+        cmdArgs = ['copilot', 'suggest', task];
+        cmd = 'gh';
+      }
+      const r = cp.spawn(cmd, cmdArgs, { shell: true });
+      let stdout = '', stderr = '';
+      r.stdout.on('data', d => { stdout += d; });
+      r.stderr.on('data', d => { stderr += d; });
+      const timer = setTimeout(() => { r.kill(); }, timeoutS * 1000);
+      r.on('close', (code) => {
+        clearTimeout(timer);
+        const elapsed = Date.now() - t0;
+        results.push({
+          id: agent.id, exit: code, elapsed,
+          stdout: stdout.trim().split('\n').slice(-3).join('\n'),
+          stderrLen: stderr.length,
+          ok: code === 0 && stdout.trim().length > 0
+        });
+        resolve();
+      });
+      r.on('error', (err) => {
+        clearTimeout(timer);
+        results.push({ id: agent.id, exit: -1, elapsed: Date.now() - t0, stdout: '', stderrLen: 0, error: err.message, ok: false });
+        resolve();
+      });
+    }));
+    return Promise.all(promises).then(() => {
+      if (has('--json')) { log(JSON.stringify({ task, results }, null, 2)); return; }
+      log(`| CLI | 시간 | exit | 응답 길이 | 마지막 라인 |`);
+      log(`|---|---:|---:|---:|---|`);
+      // sort by elapsed
+      results.sort((a, b) => a.elapsed - b.elapsed);
+      for (const r of results) {
+        const respLen = (r.stdout || '').length;
+        const last = (r.stdout || '').split('\n').pop().slice(0, 50);
+        log(`| ${r.id} | ${r.elapsed}ms | ${r.exit} | ${respLen} | ${last.replace(/\|/g, '\\|')} |`);
+      }
+      log('');
+      const okCount = results.filter(r => r.ok).length;
+      log(`결과: ${okCount}/${results.length} 성공`);
+      const fastest = results.filter(r => r.ok).sort((a, b) => a.elapsed - b.elapsed)[0];
+      if (fastest) log(`🏆 가장 빠름: ${fastest.id} (${fastest.elapsed}ms)`);
+    });
+  }
+
   if (sub === 'quota') {
     // 1.9.31: 각 CLI 사용량/쿼터 추정 + provider 대시보드 링크
     const results = [];
@@ -2903,7 +3057,7 @@ function agentsCmd(root, sub, ...args) {
     return;
   }
 
-  fail('사용법: leerness agents list|check|quota|dispatch "<task>" --to <id>');
+  fail('사용법: leerness agents list|check|quota|dispatch|bench [--write] "<task>" [--to <id>]');
   return process.exit(1);
 }
 
@@ -5096,6 +5250,122 @@ function viewworkInstall(root) {
   ok('claude .claude/settings.local.json updated (Stop hook adds a viewwork event)');
 }
 
+// 1.9.37: drift detection — 메타파일 staleness 측정으로 "leerness 점점 안 쓰는" 현상 감지
+function driftCheckCmd(root, opts = {}) {
+  root = absRoot(root || process.cwd());
+  const now = Date.now();
+  const _ageDays = (p) => {
+    if (!exists(p)) return null;
+    return (now - fs.statSync(p).mtimeMs) / 86400000;
+  };
+  // 각 메타파일의 마지막 갱신
+  const signals = [];
+  // 1. session-handoff.md - "Last generated" 라인 우선, 없으면 mtime
+  const shPath = handoffPath(root);
+  if (exists(shPath)) {
+    const txt = read(shPath);
+    const m = txt.match(/Last generated:\s*([\d\-T:.Z]+)/);
+    let ageDays;
+    if (m) {
+      ageDays = (now - new Date(m[1]).getTime()) / 86400000;
+    } else {
+      ageDays = _ageDays(shPath);
+    }
+    signals.push({ file: 'session-handoff.md', ageDays, threshold: 1, weight: 30, label: 'session close 누락' });
+  }
+  // 2. current-state.md - "Updated: YYYY-MM-DD" 라인
+  const csPath = currentStatePath(root);
+  if (exists(csPath)) {
+    const m = read(csPath).match(/Updated:\s*(\d{4}-\d{2}-\d{2})/);
+    const ageDays = m ? (now - new Date(m[1]).getTime()) / 86400000 : _ageDays(csPath);
+    signals.push({ file: 'current-state.md', ageDays, threshold: 2, weight: 20, label: 'current-state 갱신 없음' });
+  }
+  // 3. progress-tracker.md 마지막 row의 updated 컬럼
+  const rows = readProgressRows(root);
+  if (rows.length) {
+    const dates = rows.map(r => (r.updated || '').match(/\d{4}-\d{2}-\d{2}/)).filter(Boolean).map(m => m[0]);
+    if (dates.length) {
+      dates.sort();
+      const latest = dates[dates.length - 1];
+      const ageDays = (now - new Date(latest).getTime()) / 86400000;
+      signals.push({ file: 'progress-tracker.md', ageDays, threshold: 1, weight: 30, label: 'task update 없음' });
+    }
+  } else {
+    signals.push({ file: 'progress-tracker.md', ageDays: 999, threshold: 1, weight: 25, label: 'progress-tracker 비어있음' });
+  }
+  // 4. task-log.md 마지막 entry "## YYYY-MM-DD"
+  const tlPath = taskLogPath(root);
+  if (exists(tlPath)) {
+    const dates = Array.from(read(tlPath).matchAll(/^## (\d{4}-\d{2}-\d{2})/gm)).map(m => m[1]);
+    if (dates.length) {
+      dates.sort();
+      const latest = dates[dates.length - 1];
+      const ageDays = (now - new Date(latest).getTime()) / 86400000;
+      signals.push({ file: 'task-log.md', ageDays, threshold: 2, weight: 20, label: 'task-log 갱신 없음' });
+    }
+  }
+  // 점수 계산
+  let totalScore = 0;
+  const fired = [];
+  for (const s of signals) {
+    if (s.ageDays > s.threshold) {
+      totalScore += s.weight;
+      fired.push(s);
+    }
+  }
+  // 신규 _apps/* 에서 task 0건도 신호로
+  const appsDir = path.join(root, '_apps');
+  let appsZeroTask = [];
+  if (exists(appsDir)) {
+    for (const d of fs.readdirSync(appsDir)) {
+      const sub = path.join(appsDir, d);
+      if (!exists(path.join(sub, '.harness'))) continue;
+      const subRows = readProgressRows(sub);
+      if (!subRows.length) appsZeroTask.push(d);
+    }
+    if (appsZeroTask.length) {
+      const w = Math.min(50, appsZeroTask.length * 10);
+      totalScore += w;
+      fired.push({ file: `_apps/* (${appsZeroTask.length}개)`, ageDays: null, threshold: 0, weight: w, label: `task 0건 sub-app: ${appsZeroTask.slice(0, 3).join(', ')}${appsZeroTask.length > 3 ? '...' : ''}` });
+    }
+  }
+  // 레벨 판정
+  let level = '🟢 healthy';
+  if (totalScore >= 100) level = '🔴 critical';
+  else if (totalScore >= 50) level = '🟡 warning';
+  else if (totalScore >= 20) level = '🟠 attention';
+
+  if (has('--json')) {
+    log(JSON.stringify({ root, score: totalScore, level, signals, fired, appsZeroTask }, null, 2));
+    return;
+  }
+  log(`# leerness drift check (1.9.37)`);
+  log(`경로: ${root}`);
+  log('');
+  log(`상태: ${level}  ·  점수 ${totalScore}/200`);
+  log('');
+  log(`| 신호 | age | 임계 | 가중치 | 발화 |`);
+  log(`|---|---:|---:|---:|---|`);
+  for (const s of signals) {
+    const fire = s.ageDays > s.threshold ? '🔥' : '✓';
+    const age = s.ageDays === null ? '-' : `${s.ageDays.toFixed(1)}d`;
+    log(`| ${s.label} | ${age} | ${s.threshold}d | ${s.weight} | ${fire} |`);
+  }
+  if (appsZeroTask.length) {
+    log('');
+    log(`task 0건 sub-app (${appsZeroTask.length}개): ${appsZeroTask.join(', ')}`);
+  }
+  if (totalScore >= 50) {
+    log('');
+    log(`💡 권장 조치:`);
+    log(`  - 즉시: leerness session close .                (handoff/current-state 갱신)`);
+    log(`  - 또는: leerness audit . --fix                  (자동 갱신 가능 항목 적용)`);
+    log(`  - sub-app에 task 등록: cd _apps/X && leerness task add "..."`);
+    log(`  - 이 검사 끄기: --no-drift-check 또는 LEERNESS_NO_DRIFT_CHECK=1`);
+  }
+  if (level === '🔴 critical') process.exitCode = 1;
+}
+
 // 1.9.35 개선 #3: contract verify <spec.md> <impl.js>
 // 사양 문서(spec.md)에 명시된 함수 이름이 실제 module.exports에 모두 있는지 검사.
 // 사용 예: leerness contract verify TICK_SPEC.md src/format.js
@@ -5119,28 +5389,27 @@ function contractVerifyCmd(specPath, implPath) {
   for (const m of specText.matchAll(/`([A-Za-z_$][\w$]*)\s*\(/g)) fnSpec.add(m[1]);
   // 필드: tick.<name>
   for (const m of specText.matchAll(/tick\.([A-Za-z_$][\w$]*)/g)) fieldSpec.add(m[1]);
-  // impl require → exports 추출
-  let exports;
-  try {
-    // 캐시 우회: delete from cache
-    delete require.cache[implFile];
-    exports = require(implFile);
-  } catch (e) { fail(`impl 로드 실패: ${e.message}`); return process.exit(1); }
+  // 1.9.36 BUG-fix: require()는 side-effect 실행 위험 (CLI 스크립트는 require로 실행됨).
+  // 대신 정적 소스 분석 — module.exports = { foo, bar } / exports.foo = ... / module.exports.foo = ... 패턴 grep.
+  const implSrc = read(implFile);
   const implExports = new Set();
-  if (exports && typeof exports === 'object') {
-    for (const k of Object.keys(exports)) implExports.add(k);
+  // pattern 1: module.exports = { foo, bar, baz }
+  for (const m of implSrc.matchAll(/module\.exports\s*=\s*\{([^}]+)\}/g)) {
+    for (const k of m[1].split(',')) {
+      const name = k.replace(/:.*/, '').trim();
+      if (/^[A-Za-z_$][\w$]*$/.test(name)) implExports.add(name);
+    }
   }
-  // 검사: spec에 명시된 함수 중 impl에 없는 것
+  // pattern 2: exports.foo = / module.exports.foo =
+  for (const m of implSrc.matchAll(/(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=/g)) implExports.add(m[1]);
+  // pattern 3: function foo + module.exports에 포함되었는지는 위에서 처리됨
+  // 검사: spec에 명시된 함수 중 impl exports에 없는 것
   const missing = [];
   for (const fn of fnSpec) {
-    // common function name (typeof === 'function'인 export만 비교)
-    if (typeof exports[fn] === 'function') continue;
+    if (implExports.has(fn)) continue;
     // spec에 'function fnName('이 있지만 impl exports에 없으면 미구현
-    // 단, 헬퍼 함수(internal _)는 spec에 없을 수 있으니 단방향만
     if (specText.includes(`function ${fn}`) && !implExports.has(fn)) missing.push(fn);
   }
-  // 필드 검증: impl 소스 파일에 spec 필드명이 있는지 grep
-  const implSrc = read(implFile);
   const fieldMissing = [];
   for (const f of fieldSpec) {
     if (!new RegExp(`\\b${f}\\b`).test(implSrc)) fieldMissing.push(f);
@@ -5182,20 +5451,28 @@ function contractVerifyCmd(specPath, implPath) {
 // src/*.js의 module.exports를 스캔해서 reuse-map.md에 capability 후보 등록.
 function reuseAutodetectCmd(root) {
   root = absRoot(root || process.cwd());
-  const srcDir = path.join(root, 'src');
-  if (!exists(srcDir)) { fail(`src/ 디렉토리 없음: ${srcDir}`); return process.exit(1); }
-  const files = fs.readdirSync(srcDir).filter(f => f.endsWith('.js'));
+  // 1.9.36 BUG-fix: src/만이 아니라 bin/, lib/, app/도 스캔. require() 대신 정적 분석 (side-effect 차단).
+  const candidateDirs = ['src', 'bin', 'lib', 'app'].filter(d => exists(path.join(root, d)));
+  if (!candidateDirs.length) { fail(`스캔할 디렉토리 없음 (src/, bin/, lib/, app/ 중 하나 필요): ${root}`); return process.exit(1); }
   const found = [];
-  for (const f of files) {
-    const full = path.join(srcDir, f);
-    let mod;
-    try { delete require.cache[full]; mod = require(full); } catch { continue; }
-    if (!mod || typeof mod !== 'object') continue;
-    const exports = Object.keys(mod).filter(k => typeof mod[k] === 'function');
-    if (!exports.length) continue;
-    for (const e of exports) {
-      if (e.startsWith('_')) continue; // internal helpers 제외
-      found.push({ file: `src/${f}`, name: e });
+  for (const dir of candidateDirs) {
+    const files = fs.readdirSync(path.join(root, dir)).filter(f => f.endsWith('.js'));
+    for (const f of files) {
+      const full = path.join(root, dir, f);
+      const src = read(full);
+      // 정적 분석: module.exports = { foo, bar } / exports.foo = / module.exports.foo =
+      const names = new Set();
+      for (const m of src.matchAll(/module\.exports\s*=\s*\{([^}]+)\}/g)) {
+        for (const k of m[1].split(',')) {
+          const name = k.replace(/:.*/, '').trim();
+          if (/^[A-Za-z_$][\w$]*$/.test(name)) names.add(name);
+        }
+      }
+      for (const m of src.matchAll(/(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=/g)) names.add(m[1]);
+      for (const name of names) {
+        if (name.startsWith('_')) continue; // internal helpers 제외
+        found.push({ file: `${dir}/${f}`, name });
+      }
     }
   }
   if (has('--json')) {
@@ -5281,6 +5558,7 @@ async function main() {
   if (cmd === 'review') return reviewCmd(arg('--path', process.cwd()), args[1]);
   if (cmd === 'agents') return agentsCmd(arg('--path', process.cwd()), args[1], ...args.slice(2));
   if (cmd === 'contract' && args[1] === 'verify') return contractVerifyCmd(args[2], args[3]);
+  if (cmd === 'drift' && (args[1] === 'check' || !args[1])) return driftCheckCmd(args[2] || arg('--path', process.cwd()));
   if (cmd === 'reuse' && args[1] === 'autodetect') return reuseAutodetectCmd(args[2] || arg('--path', process.cwd()));
   if (cmd === 'setup-agents' || cmd === 'setup' && args[1] === 'agents') return await setupAgentsCmd(args[1] && args[1] !== 'agents' ? args[1] : (args[2] || process.cwd()));
   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; }

package/package.json

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

package/scripts/e2e.js

@@ -950,6 +950,133 @@ total++;
   if (!ok) { failed++; console.log(r.stdout.slice(0, 800)); }
 }
 
+// 1.9.37 회귀: drift detection
+total++;
+{
+  // drift check: 신규 init 직후 (메타파일은 fresh) → healthy 또는 attention
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-drift-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpC, '--yes', '--no-banner', '--no-stale-check', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  const r = cp.spawnSync(process.execPath, [CLI, 'drift', 'check', tmpC], { encoding: 'utf8', timeout: 15000 });
+  const ok = r.status === 0
+    && /leerness drift check \(1\.9\.37\)/.test(r.stdout)
+    && /(healthy|attention|warning)/.test(r.stdout);  // 막 init이라 critical은 안 됨
+  console.log(ok ? '✓ B(1.9.37) drift check: 신규 init → healthy/attention 등급' : `✗ drift check 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 500)); }
+}
+
+total++;
+{
+  // drift check --json: 점수/신호 구조 검증
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-drift2-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpC, '--yes', '--no-banner', '--no-stale-check', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  // 인공적으로 progress-tracker를 옛날 날짜로 만들기 어려우니 신호 갯수만 검증
+  const r = cp.spawnSync(process.execPath, [CLI, 'drift', 'check', tmpC, '--json'], { encoding: 'utf8', timeout: 15000 });
+  let parsed = null;
+  try { parsed = JSON.parse(r.stdout); } catch {}
+  const ok = parsed
+    && typeof parsed.score === 'number'
+    && typeof parsed.level === 'string'
+    && Array.isArray(parsed.signals)
+    && parsed.signals.length >= 3; // session-handoff/current-state/progress-tracker 최소
+  console.log(ok ? '✓ B(1.9.37) drift check --json: 점수/레벨/신호 구조' : `✗ drift --json 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 500)); }
+}
+
+total++;
+{
+  // handoff 자동 drift 경고 — 인공 stale 시뮬 (session-handoff.md의 Last generated를 옛 날짜로)
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-drift3-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpC, '--yes', '--no-banner', '--no-stale-check', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  // session-handoff.md에 옛 날짜 주입
+  const shPath = path.join(tmpC, '.harness', 'session-handoff.md');
+  if (fs.existsSync(shPath)) {
+    let body = fs.readFileSync(shPath, 'utf8');
+    const oldDate = new Date(Date.now() - 5 * 86400000).toISOString();
+    body = body.replace(/Last generated:.*/, `Last generated: ${oldDate}`);
+    if (!/Last generated:/.test(body)) body = `Last generated: ${oldDate}\n\n` + body;
+    fs.writeFileSync(shPath, body, 'utf8');
+  }
+  const r = cp.spawnSync(process.execPath, [CLI, 'handoff', tmpC, '--compact'], { encoding: 'utf8', timeout: 15000 });
+  const ok = /leerness drift 감지/.test(r.stdout) && /session close/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.37) handoff 자동 drift 경고: 5일 stale → 알림 표시' : `✗ handoff drift 경고 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 500)); }
+}
+
+total++;
+{
+  // LEERNESS_NO_DRIFT_CHECK=1: 자동 경고 스킵
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-drift4-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpC, '--yes', '--no-banner', '--no-stale-check', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  const shPath = path.join(tmpC, '.harness', 'session-handoff.md');
+  if (fs.existsSync(shPath)) {
+    const oldDate = new Date(Date.now() - 5 * 86400000).toISOString();
+    let body = fs.readFileSync(shPath, 'utf8');
+    body = body.replace(/Last generated:.*/, `Last generated: ${oldDate}`);
+    if (!/Last generated:/.test(body)) body = `Last generated: ${oldDate}\n\n` + body;
+    fs.writeFileSync(shPath, body, 'utf8');
+  }
+  const env = { ...process.env, LEERNESS_NO_DRIFT_CHECK: '1' };
+  const r = cp.spawnSync(process.execPath, [CLI, 'handoff', tmpC, '--compact'], { encoding: 'utf8', timeout: 15000, env });
+  const ok = !/leerness drift 감지/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.37) LEERNESS_NO_DRIFT_CHECK=1: 경고 스킵' : `✗ drift skip 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+// 1.9.36 회귀: dispatch 권장 플래그 + bench + 작업 유형 추천
+total++;
+{
+  // dispatch --write 시 gemini --yolo 자동 추가
+  const env = { ...process.env, LEERNESS_ENABLE_GEMINI: '1' };
+  const r = cp.spawnSync(process.execPath, [CLI, 'agents', 'dispatch', '코드 분석해서 요약', '--to', 'gemini', '--write'], { encoding: 'utf8', timeout: 15000, env });
+  // gemini가 ready면 명령 출력에 --yolo 포함, 비-ready면 거부 — 둘 다 OK
+  const ok = (r.status === 0 && /--yolo/.test(r.stdout) && /write \(파일 수정 가능\)/.test(r.stdout))
+          || (r.status !== 0 && /비활성|disabled|not-installed/.test(r.stdout));
+  console.log(ok ? '✓ B(1.9.36) dispatch --write: gemini --yolo 자동 첨부 또는 비활성 거부' : `✗ dispatch --write 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 500)); }
+}
+
+total++;
+{
+  // dispatch read-only (기본) — --yolo/--dangerously 같은 위험 플래그 없음
+  const env = { ...process.env, LEERNESS_ENABLE_CLAUDE: '1' };
+  const r = cp.spawnSync(process.execPath, [CLI, 'agents', 'dispatch', '번역해줘', '--to', 'claude'], { encoding: 'utf8', timeout: 15000, env });
+  // claude가 ready면 read-only 표시 + dangerously 플래그 없음
+  const ok = (r.status === 0 && /read-only/.test(r.stdout) && !/--dangerously-skip-permissions/.test(r.stdout))
+          || (r.status !== 0 && /비활성|disabled|not-installed/.test(r.stdout));
+  console.log(ok ? '✓ B(1.9.36) dispatch read-only 기본: 위험 플래그 미첨부 또는 비활성 거부' : `✗ dispatch read-only 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 500)); }
+}
+
+total++;
+{
+  // 작업 유형 추천 — 비활성 CLI에도 추천 메시지 우선 출력
+  const env = { ...process.env, LEERNESS_ENABLE_GEMINI: '0', LEERNESS_ENABLE_CLAUDE: '0' };
+  const r = cp.spawnSync(process.execPath, [CLI, 'agents', 'dispatch', '번역해줘 한국어를 영어로', '--to', 'gemini'], { encoding: 'utf8', timeout: 15000, env });
+  // 번역 → claude 추천. ready 체크 전에 추천 출력 → stdout에 "추천...claude" 포함
+  const ok = /추천.*claude/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.36) 작업 유형 추천: 번역→claude 추천 (비활성이어도 출력)' : `✗ 추천 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 500)); }
+}
+
+total++;
+{
+  // bench 명령: ready CLI 없을 때 거부
+  const env = { ...process.env, LEERNESS_ENABLE_CLAUDE: '0', LEERNESS_ENABLE_CODEX: '0', LEERNESS_ENABLE_GEMINI: '0', LEERNESS_ENABLE_COPILOT: '0' };
+  const r = cp.spawnSync(process.execPath, [CLI, 'agents', 'bench', 'test'], { encoding: 'utf8', timeout: 15000, env });
+  const ok = r.status !== 0 && /ready CLI 없음/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.36) agents bench: ready 없을 때 거부' : `✗ bench 거부 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 300)); }
+}
+
+total++;
+{
+  // 사용법 메시지에 bench 포함
+  const r = cp.spawnSync(process.execPath, [CLI, 'agents', 'unknown'], { encoding: 'utf8', timeout: 10000 });
+  const ok = r.status !== 0 && /bench/.test(r.stdout + r.stderr);
+  console.log(ok ? '✓ B(1.9.36) agents 사용법에 bench 명시' : `✗ usage bench 실패`);
+  if (!ok) { failed++; console.log((r.stdout + r.stderr).slice(0, 300)); }
+}
+
 // 1.9.35 회귀: 5개 신규 기능
 total++;
 {