leerness 1.9.208 → 1.9.210

package/CHANGELOG.md

@@ -1,5 +1,95 @@
 # Changelog
 
+## 1.9.210 — 2026-05-22
+
+**⚡ adaptive wakeup interval — 사용자 활동 기반 자동 조절 (사용자 명시).**
+
+### 사용자 명시
+> *"wakeup 30분등 긴 시간이 필요없다면 간격을 타이트하게 자동으로 조절하도록"*
+
+### 1. `.harness/wakeup-history.json` — fire 이력 누적
+- `_wakeupHistoryPath / _loadWakeupHistory / _writeWakeupHistory` — 파일 I/O
+- `_recordWakeupFire(root, kind)` — kind: 'auto' / 'user-trigger' / 'wakeup-miss'
+- 최근 50개 rotate
+
+### 2. `_computeAdaptiveInterval(root)` — 활동량 기반 권장 interval
+- 범위: **600s (10min) ~ 2700s (45min)**, default 1500s
+- 분석 차원:
+  - 최근 2시간 user-trigger 빈도 (3+ → 15min, 0 → 35min)
+  - 최근 5건 user-trigger 평균 gap (avg < 20min → 단축)
+  - pre-wake critical 신호 (1.9.209 통합) → 20min 단축
+- opt-out:
+  - env `LEERNESS_FIXED_INTERVAL=1500`
+  - `leerness wakeup-interval set 900` (override)
+
+### 3. `leerness wakeup-interval <get|set|auto|history|record>` CLI
+- `get` — 권장 interval + stats (--json)
+- `set <secs>` — override 설정
+- `auto` — override 해제 + 자동 계산 복귀
+- `history` — 최근 fire 이력 (--json)
+- `record <kind>` — fire 기록 (테스트/외부 통합용)
+
+### 4. 자동 단축 시나리오 검증
+- 신규 워크스페이스 idle → **35min**
+- user-trigger 3회/2h → **10min** (1500 → 600)
+- pre-wake critical + 활동 보통 → **20min**
+
+### 5. 누적 회귀 (1.9.200~209) — 모두 유지
+
+### 6. stress-v155 — 18/18 PASS
+- 1.9.210 (9) + 성능 (2) + 누적 회귀 (7)
+- 격리 tmp dir 라이프사이클 + override 토글 + rotate to 50
+- 성능: --version cold start avg 440ms · MCP 54 도구 421ms
+
+### 7. 자동 release (72 라운드 main-push streak · 33 라운드 npm publish streak)
+
+---
+
+## 1.9.209 — 2026-05-22
+
+**🔍 pre-wake sub-agent audit + 깨어남 직후 자동 노출 (사용자 명시).**
+
+### 사용자 명시
+> *"메인 에이전트가 슬립전에 서브에이전트를 호출해서 미비된 부분이 있는지, 충돌나는 부분이 있는지, 이전에 누락된 작업이 있는지 등등 여러부분을 탐색하면서 필요한 내용을 정리하고 메인 에이전트가 깨어났을때, 서브에이전트가 정리한 내용을 확인해보거나 하는 기능"*
+
+### 1. `.harness/pre-wake-report.json` — sleep 전 audit 누적
+- `_preWakeReportPath/_loadPreWakeReport/_writePreWakeReport` 파일 I/O 헬퍼
+- 최근 10개만 유지 (rotate)
+- 구조: `{ auditedAt, auditVersion, findings: {critical/warning/info}, summary }`
+
+### 2. `_runPreWakeAudit(root)` — sub-agent audit 6영역
+- **missing-user-requests** (1.9.207 통합) — task-log/plan/decisions 매칭 안 된 요청
+- **stale-user-requests** — 7일+ open 요청
+- **stale-in-progress** — 24h+ 진척 없는 task
+- **drift-handoff-stale** — session-handoff.md 5일+ stale
+- **wakeup-missed** — wakeup miss 감지 (1.9.205)
+- **next-action-pending** — next-action queue 대기
+- **auto-resume-plan-ready/stale** — 1.9.203 plan 상태
+
+### 3. `leerness pre-wake-audit` CLI
+- 기본: 새 audit 실행 + 저장
+- `--last` / `show` / `review` — 가장 최근 저장된 audit 표시
+- `--json` — JSON 출력
+
+### 4. handoff 자동 노출 (사용자 명시 "깨어났을때 확인")
+- 헤드라인 14번째 요소: `🔍 pre-wake NC/MW (ageMin)` — critical N건 + warning M건
+- 본문 자동 섹션: `## 🔍 직전 sleep pre-wake-audit (1.9.209, N분 전)`
+  · critical/warning 최대 3개씩 노출
+  · 4시간 이내 보고서만 (stale 자동 hide)
+- 헤드라인 라벨: `1.9.81/93/113/152/162/192/197/204/207/209`
+
+### 5. 누적 회귀 (1.9.200~208) — 모두 유지
+
+### 6. stress-v154 — 18/18 PASS
+- 1.9.209 (9) + 성능 (2) + 누적 회귀 (7)
+- 격리 tmp dir 라이프사이클 검증 (실행 → 저장 → --last → rotate to 10)
+- 6 findings kind 키워드 검증
+- 성능: --version cold start avg 517ms · MCP 54 도구 574ms
+
+### 7. 자동 release (71 라운드 main-push streak · 32 라운드 npm publish streak)
+
+---
+
 ## 1.9.208 — 2026-05-22
 
 **🚦 플랫폼/API 제약 사전 체크 (사용자 명시).**

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.208-green)]() [![tests](https://img.shields.io/badge/e2e-217%2F217-success)]() [![stress](https://img.shields.io/badge/stress--v153-18%2F18-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-54-brightgreen)]() [![rounds](https://img.shields.io/badge/autonomous--rounds-138-blueviolet)]() [![main-push](https://img.shields.io/badge/release--main--push-70_rounds-success)]() [![goal-matrix](https://img.shields.io/badge/목적_매트릭스-98%2F100_(5축)-brightgreen)]() [![constraints](https://img.shields.io/badge/constraints-API_사전체크_6plat-success)]() [![perf](https://img.shields.io/badge/cold_start-483ms-success)]() [![install](https://img.shields.io/badge/npm_i_leerness-즉시_사용_가능-success)]() [![sandbox](https://img.shields.io/badge/runCommandSafe-cwd_jail%2Benv_scrub-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.210-green)]() [![tests](https://img.shields.io/badge/e2e-217%2F217-success)]() [![stress](https://img.shields.io/badge/stress--v155-18%2F18-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-54-brightgreen)]() [![rounds](https://img.shields.io/badge/autonomous--rounds-140-blueviolet)]() [![main-push](https://img.shields.io/badge/release--main--push-72_rounds-success)]() [![goal-matrix](https://img.shields.io/badge/목적_매트릭스-98%2F100_(5축)-brightgreen)]() [![adaptive](https://img.shields.io/badge/wakeup-adaptive_10~45min-success)]() [![perf](https://img.shields.io/badge/cold_start-440ms-success)]() [![install](https://img.shields.io/badge/npm_i_leerness-즉시_사용_가능-success)]() [![sandbox](https://img.shields.io/badge/runCommandSafe-cwd_jail%2Benv_scrub-success)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
 
 ```
   ╔══════════════════════════════════════════════════════════════╗
@@ -12,9 +12,9 @@
   ║  ██║     ██╔══╝  ██╔══╝  ██╔══██╗██║╚██╗██║██╔══╝  ╚════██║  ║
   ║  ███████╗███████╗███████╗██║  ██║██║ ╚████║███████╗███████║  ║
   ║  ╚══════╝╚══════╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝╚══════╝╚══════╝  ║
-  ║  v1.9.208  AI Agent Reliability Harness + Sandbox            ║
+  ║  v1.9.210  AI Agent Reliability Harness + Sandbox            ║
   ║  verify · remember · orchestrate · audit · sandbox · drift   ║
-  ║  🚦 플랫폼/API 제약 사전 체크 6종 (사용자 명시)                      ║
+  ║  ⚡ adaptive wakeup 10~45min (활동 기반 자동) (사용자 명시)          ║
   ╚══════════════════════════════════════════════════════════════╝
 ```
 

package/bin/harness.js

@@ -7,7 +7,7 @@ const cp = require('child_process');
 const os = require('os');  // 1.9.178: _publishToNpm 에서 os.tmpdir() 사용 (전역 import)
 const readline = require('readline');
 
-const VERSION = '1.9.208';
+const VERSION = '1.9.210';
 
 // 1.9.184: DEP0190 (child_process shell: true) deprecation warning 억제 (사용자 명시).
 //   leerness 는 cross-platform PATH resolution 을 위해 shell: true 를 의도적으로 사용 (claude.cmd / ollama.cmd 등 Windows .cmd 처리).
@@ -2111,6 +2111,259 @@ function _checkRequestConstraints(root, text) {
   return { matched, suggestions, totalPlatforms: Object.keys(catalog.platforms).length };
 }
 
+// 1.9.209: pre-wake sub-agent audit (사용자 명시)
+//   "메인 에이전트가 슬립전에 서브에이전트를 호출해서 미비된 부분이 있는지, 충돌나는 부분이 있는지,
+//    이전에 누락된 작업이 있는지 등등 여러부분을 탐색하면서 필요한 내용을 정리하고
+//    메인 에이전트가 깨어났을때, 서브에이전트가 정리한 내용을 확인해보거나 하는 기능"
+//   .harness/pre-wake-report.json 에 sleep 전 audit 결과 누적 (최근 10개 유지) →
+//   다음 handoff 에서 자동 노출 → 깨어남 직후 메인 에이전트가 검토 가능
+//   audit 영역: 미답 요청 / 24h+ 무진척 task / drift 신호 / feature_graph 충돌 / 플랫폼 제약 누락
+function _preWakeReportPath(root) { return path.join(root, '.harness', 'pre-wake-report.json'); }
+function _loadPreWakeReport(root) {
+  try {
+    const fp = _preWakeReportPath(root);
+    if (!exists(fp)) return { reports: [] };
+    const j = JSON.parse(read(fp));
+    return { reports: Array.isArray(j.reports) ? j.reports : [] };
+  } catch { return { reports: [] }; }
+}
+function _writePreWakeReport(root, reports) {
+  try {
+    mkdirp(path.join(root, '.harness'));
+    writeUtf8(_preWakeReportPath(root), JSON.stringify({ reports, updatedAt: new Date().toISOString() }, null, 2));
+    return true;
+  } catch { return false; }
+}
+// 실제 audit 실행 — sub-agent 역할 (단일 프로세스에서 sync로 다양한 신호 수집)
+function _runPreWakeAudit(root) {
+  const audit = {
+    auditedAt: new Date().toISOString(),
+    auditVersion: VERSION,
+    findings: { critical: [], warning: [], info: [] }
+  };
+  // 1) 미답 사용자 요청 (1.9.207)
+  try {
+    const reqAudit = _auditUserRequests(root);
+    if (reqAudit.missing && reqAudit.missing.length > 0) {
+      audit.findings.critical.push({
+        kind: 'missing-user-requests',
+        count: reqAudit.missing.length,
+        detail: `${reqAudit.missing.length}건 사용자 요청이 task-log/plan/decisions 에 매칭 안 됨`,
+        items: reqAudit.missing.slice(0, 5).map(r => ({ id: r.id, text: r.text.slice(0, 80) }))
+      });
+    }
+    if (reqAudit.stale && reqAudit.stale.length > 0) {
+      audit.findings.warning.push({
+        kind: 'stale-user-requests',
+        count: reqAudit.stale.length,
+        detail: `${reqAudit.stale.length}건 사용자 요청이 7일+ open 상태`
+      });
+    }
+  } catch (e) { audit.findings.info.push({ kind: 'audit-error', area: 'user-requests', error: String(e.message || e) }); }
+
+  // 2) 24h+ 무진척 task — progress-tracker 검사
+  try {
+    const ptPath = path.join(root, '.harness', 'progress-tracker.md');
+    if (exists(ptPath)) {
+      const content = read(ptPath);
+      const stat = fs.statSync(ptPath);
+      const ageMin = Math.floor((Date.now() - stat.mtimeMs) / 60000);
+      // in-progress 태그가 있는데 24h+ 갱신 없음
+      const inProgressCount = (content.match(/status:\s*in-progress/gi) || []).length;
+      if (inProgressCount > 0 && ageMin > 24 * 60) {
+        audit.findings.warning.push({
+          kind: 'stale-in-progress',
+          count: inProgressCount,
+          detail: `${inProgressCount}건 in-progress task, ${Math.floor(ageMin/60)}h 갱신 없음`,
+          ageMin
+        });
+      }
+    }
+  } catch {}
+
+  // 3) drift 신호 — session-handoff/progress-tracker stale 검사
+  try {
+    const handoffPath = path.join(root, '.harness', 'session-handoff.md');
+    if (exists(handoffPath)) {
+      const stat = fs.statSync(handoffPath);
+      const ageDay = (Date.now() - stat.mtimeMs) / 86400000;
+      if (ageDay > 5) {
+        audit.findings.warning.push({
+          kind: 'drift-handoff-stale',
+          ageDay: Math.round(ageDay * 10) / 10,
+          detail: `session-handoff.md ${ageDay.toFixed(1)}일 stale — drift 위험`
+        });
+      }
+    }
+  } catch {}
+
+  // 4) 다음 라운드 plan 적용 가능 여부 (1.9.203)
+  try {
+    const plan = _loadAutoResumePlan(root);
+    if (!plan) {
+      audit.findings.info.push({ kind: 'no-auto-resume-plan', detail: 'auto-resume-plan.json 없음 — 다음 라운드 진입 시 manual context' });
+    } else if (plan.ageMin > 12 * 60) {
+      audit.findings.warning.push({ kind: 'auto-resume-plan-stale', detail: `plan ${plan.ageMin}분 전 작성 — outdated 가능` });
+    } else {
+      audit.findings.info.push({ kind: 'auto-resume-plan-ready', detail: `nextRoundVersion=${plan.nextRoundVersion}, focus=${(plan.focus||'').slice(0,50)}` });
+    }
+  } catch {}
+
+  // 5) Active wakeup 상태 (1.9.205)
+  try {
+    const wkStat = _analyzeWakeupStatus(root);
+    if (wkStat.hasWakeup && wkStat.kind === 'missed') {
+      audit.findings.critical.push({
+        kind: 'wakeup-missed',
+        deltaMin: wkStat.deltaMin,
+        detail: `wakeup ${wkStat.deltaMin}분 지남 — 다음 라운드 진입 늦음`
+      });
+    }
+  } catch {}
+
+  // 6) next-action queue 잔여 (1.9.201)
+  try {
+    const q = _loadNextActionQueue(root);
+    if (q && q.pending && q.pending.length > 0) {
+      audit.findings.info.push({
+        kind: 'next-action-pending',
+        count: q.pending.length,
+        detail: `${q.pending.length}건 next-action 대기 — leerness next-action take 로 즉시 처리`
+      });
+    }
+  } catch {}
+
+  // 7) 통합 요약
+  audit.summary = {
+    criticalCount: audit.findings.critical.length,
+    warningCount: audit.findings.warning.length,
+    infoCount: audit.findings.info.length,
+    needsAttention: audit.findings.critical.length > 0 || audit.findings.warning.length >= 2
+  };
+  return audit;
+}
+function _saveAndAppendPreWakeReport(root, audit) {
+  const state = _loadPreWakeReport(root);
+  state.reports.push(audit);
+  // 최근 10개만 유지
+  if (state.reports.length > 10) state.reports = state.reports.slice(-10);
+  _writePreWakeReport(root, state.reports);
+  return audit;
+}
+
+// 1.9.210: adaptive wakeup interval (사용자 명시)
+//   "wakeup 30분등 긴 시간이 필요없다면 간격을 타이트하게 자동으로 조절하도록"
+//   사용자 활동량 기반 권장 interval 계산 → ScheduleWakeup 시 자동 적용 (R-0001 룰 외 동적 보정)
+//   .harness/wakeup-history.json 에 fire 이력 누적 → 최근 N개 사이 평균 user-trigger gap 분석
+//   opt-out: LEERNESS_FIXED_INTERVAL=1 (env) 또는 leerness wakeup-interval set <secs>
+function _wakeupHistoryPath(root) { return path.join(root, '.harness', 'wakeup-history.json'); }
+function _loadWakeupHistory(root) {
+  try {
+    const fp = _wakeupHistoryPath(root);
+    if (!exists(fp)) return { fires: [], override: null };
+    const j = JSON.parse(read(fp));
+    return { fires: Array.isArray(j.fires) ? j.fires : [], override: j.override || null };
+  } catch { return { fires: [], override: null }; }
+}
+function _writeWakeupHistory(root, state) {
+  try {
+    mkdirp(path.join(root, '.harness'));
+    writeUtf8(_wakeupHistoryPath(root), JSON.stringify({ ...state, updatedAt: new Date().toISOString() }, null, 2));
+    return true;
+  } catch { return false; }
+}
+function _recordWakeupFire(root, kind) {
+  // kind: 'auto' (scheduled), 'user-trigger' (사용자 명시 다음라운드), 'wakeup-miss'
+  const state = _loadWakeupHistory(root);
+  state.fires.push({ at: new Date().toISOString(), kind: kind || 'auto' });
+  // 최근 50개만 유지
+  if (state.fires.length > 50) state.fires = state.fires.slice(-50);
+  _writeWakeupHistory(root, state);
+  return state;
+}
+// 권장 interval 계산 (sec)
+//   user-trigger 빈도 + pre-wake critical + 최근 평균 gap 기반
+//   범위: 600 (10min) ~ 2700 (45min)
+function _computeAdaptiveInterval(root) {
+  const DEFAULT = 1500; // 25min
+  const MIN = 600;      // 10min
+  const MAX = 2700;     // 45min
+
+  // 1) opt-out — env or override
+  if (process.env.LEERNESS_FIXED_INTERVAL && process.env.LEERNESS_FIXED_INTERVAL !== '0') {
+    const fixed = Number(process.env.LEERNESS_FIXED_INTERVAL);
+    if (!isNaN(fixed) && fixed >= 60) return { interval: fixed, reason: 'env LEERNESS_FIXED_INTERVAL', adaptive: false };
+    return { interval: DEFAULT, reason: 'env override (default)', adaptive: false };
+  }
+  const state = _loadWakeupHistory(root);
+  if (state.override && Number(state.override) >= 60) {
+    return { interval: Number(state.override), reason: 'wakeup-history.json override', adaptive: false };
+  }
+
+  // 2) 활동량 분석 — 최근 2시간 user-trigger 수
+  const now = Date.now();
+  const recent = state.fires.filter(f => (now - new Date(f.at).getTime()) < 2 * 60 * 60 * 1000);
+  const userTriggers = recent.filter(f => f.kind === 'user-trigger').length;
+  const totalRecent = recent.length;
+
+  // 3) 평균 user-trigger gap (분)
+  const userFires = state.fires.filter(f => f.kind === 'user-trigger').slice(-5);
+  let avgGapMin = null;
+  if (userFires.length >= 2) {
+    let totalGap = 0;
+    for (let i = 1; i < userFires.length; i++) {
+      totalGap += new Date(userFires[i].at).getTime() - new Date(userFires[i - 1].at).getTime();
+    }
+    avgGapMin = Math.floor((totalGap / (userFires.length - 1)) / 60000);
+  }
+
+  // 4) pre-wake critical signal (1.9.209)
+  let criticalSignal = false;
+  try {
+    const pw = _loadPreWakeReport(root);
+    if (pw.reports.length > 0) {
+      const latest = pw.reports[pw.reports.length - 1];
+      if (latest.summary && latest.summary.criticalCount > 0) criticalSignal = true;
+    }
+  } catch {}
+
+  // 5) 계산
+  let interval = DEFAULT;
+  const reasons = [];
+  if (userTriggers >= 3) {
+    interval = Math.max(MIN, 900); // 15min — 활발한 사용자 활동
+    reasons.push(`user-trigger ${userTriggers}회 (2h)`);
+  } else if (userTriggers === 0 && totalRecent <= 1) {
+    interval = Math.min(MAX, 2100); // 35min — 한산
+    reasons.push('user-trigger 없음 (2h)');
+  } else {
+    interval = DEFAULT;
+    reasons.push('default 25min');
+  }
+  // avgGap 기반 미세 조정
+  if (avgGapMin !== null && avgGapMin < 20) {
+    interval = Math.max(MIN, Math.min(interval, avgGapMin * 60));
+    reasons.push(`avg user gap ${avgGapMin}min`);
+  }
+  // critical 신호 시 짧게
+  if (criticalSignal && interval > 1200) {
+    interval = 1200; // 20min
+    reasons.push('pre-wake critical detected');
+  }
+
+  return {
+    interval,
+    reason: reasons.join(' + '),
+    adaptive: true,
+    stats: {
+      recentTotal: totalRecent,
+      userTriggers,
+      avgUserGapMin: avgGapMin,
+      criticalSignal
+    }
+  };
+}
+
 // 1.9.203: 자동 라운드 plan 정리 — 사용자 명시
 //   "백그라운드에 다음 작업이 시작가능한 예상 시간 + 일어났을때 해야하는 일을 정리"
 //   라운드 마무리 시 .harness/auto-resume-plan.json 자동 저장 → 다음 wakeup 시 즉시 실행 가능
@@ -2434,6 +2687,194 @@ function constraintsCmd(root, sub, ...rest) {
   process.exit(1);
 }
 
+// 1.9.209: leerness pre-wake-audit — sleep 전 sub-agent audit CLI (사용자 명시)
+//   "메인 에이전트가 슬립전에 서브에이전트를 호출해서 미비된 부분이 있는지, 충돌나는 부분이 있는지,
+//    이전에 누락된 작업이 있는지 등등 여러부분을 탐색하면서 필요한 내용을 정리"
+//   기본: 새 audit 실행 + 저장 + 출력
+//   --last: 최근 저장된 audit 표시 (사용자 깨어났을 때 검토용)
+//   --json: JSON 출력
+function preWakeAuditCmd(root, sub) {
+  root = absRoot(root);
+  const isTty = process.stdout && process.stdout.isTTY;
+  const cyan = s => isTty ? `\x1b[36m${s}\x1b[0m` : s;
+  const grn = s => isTty ? `\x1b[32m${s}\x1b[0m` : s;
+  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;
+
+  // --last 또는 review/show — 가장 최근 audit 표시 (실행 안 함)
+  if (has('--last') || sub === 'show' || sub === 'review') {
+    const state = _loadPreWakeReport(root);
+    if (state.reports.length === 0) {
+      log(cyan(`# leerness pre-wake-audit (1.9.209) — review`));
+      log(dim(`  (저장된 audit 없음 — leerness pre-wake-audit 으로 새 실행)`));
+      return;
+    }
+    const latest = state.reports[state.reports.length - 1];
+    if (has('--json')) { log(JSON.stringify(latest, null, 2)); return; }
+    log(cyan(`# leerness pre-wake-audit (1.9.209) — review (latest)`));
+    log(dim(`  audited at: ${latest.auditedAt}  (version ${latest.auditVersion})`));
+    log('');
+    const sum = latest.summary || {};
+    log(`  📊 ${red(`critical ${sum.criticalCount || 0}`)} · ${yel(`warning ${sum.warningCount || 0}`)} · info ${sum.infoCount || 0}`);
+    if (sum.needsAttention) log(yel(`  ⚠ needsAttention=true — 메인 에이전트 검토 필요`));
+    log('');
+    if (latest.findings.critical && latest.findings.critical.length) {
+      log(red(`## 🚨 critical (${latest.findings.critical.length})`));
+      latest.findings.critical.forEach(f => log(`  - [${f.kind}] ${f.detail}`));
+      log('');
+    }
+    if (latest.findings.warning && latest.findings.warning.length) {
+      log(yel(`## ⚠ warning (${latest.findings.warning.length})`));
+      latest.findings.warning.forEach(f => log(`  - [${f.kind}] ${f.detail}`));
+      log('');
+    }
+    if (latest.findings.info && latest.findings.info.length) {
+      log(dim(`## ℹ info (${latest.findings.info.length})`));
+      latest.findings.info.forEach(f => log(dim(`  - [${f.kind}] ${f.detail}`)));
+    }
+    return;
+  }
+
+  // 기본: 새 audit 실행 + 저장
+  const audit = _runPreWakeAudit(root);
+  _saveAndAppendPreWakeReport(root, audit);
+
+  if (has('--json')) { log(JSON.stringify(audit, null, 2)); return; }
+  log(cyan(`# leerness pre-wake-audit (1.9.209) — sleep 전 sub-agent audit`));
+  log(dim(`  audited at: ${audit.auditedAt}`));
+  log('');
+  const sum = audit.summary;
+  log(`  📊 ${red(`critical ${sum.criticalCount}`)} · ${yel(`warning ${sum.warningCount}`)} · info ${sum.infoCount}`);
+  if (sum.needsAttention) {
+    log(yel(`  ⚠ needsAttention=true — 깨어난 후 메인 에이전트 검토 필수`));
+  } else {
+    log(grn(`  ✓ 잠재 이슈 없음 — sleep 안전`));
+  }
+  log('');
+  if (audit.findings.critical.length) {
+    log(red(`## 🚨 critical (${audit.findings.critical.length})`));
+    audit.findings.critical.forEach(f => {
+      log(`  - [${f.kind}] ${f.detail}`);
+      if (f.items) f.items.forEach(i => log(dim(`       • ${i.id}: ${i.text}`)));
+    });
+    log('');
+  }
+  if (audit.findings.warning.length) {
+    log(yel(`## ⚠ warning (${audit.findings.warning.length})`));
+    audit.findings.warning.forEach(f => log(`  - [${f.kind}] ${f.detail}`));
+    log('');
+  }
+  if (audit.findings.info.length) {
+    log(dim(`## ℹ info (${audit.findings.info.length})`));
+    audit.findings.info.forEach(f => log(dim(`  - [${f.kind}] ${f.detail}`)));
+    log('');
+  }
+  log(dim(`  → 저장: .harness/pre-wake-report.json (최근 10개 유지)`));
+  log(dim(`  → 깨어난 후: leerness pre-wake-audit --last`));
+}
+
+// 1.9.210: leerness wakeup-interval <get|set|auto|history|record> — adaptive wakeup interval (사용자 명시)
+//   "wakeup 30분등 긴 시간이 필요없다면 간격을 타이트하게 자동으로 조절하도록"
+//   get      → 현재 권장 interval + 분석 stats (--json 가능)
+//   set N    → wakeup-history.json override 설정 (초)
+//   auto     → override 해제 (자동 계산 모드 복귀)
+//   history  → 최근 fire 이력 출력
+//   record <kind> → fire 기록 (user-trigger / auto / wakeup-miss)
+function wakeupIntervalCmd(root, sub, val) {
+  root = absRoot(root);
+  const isTty = process.stdout && process.stdout.isTTY;
+  const cyan = s => isTty ? `\x1b[36m${s}\x1b[0m` : s;
+  const grn = s => isTty ? `\x1b[32m${s}\x1b[0m` : s;
+  const yel = s => isTty ? `\x1b[33m${s}\x1b[0m` : s;
+  const dim = s => isTty ? `\x1b[2m${s}\x1b[0m` : s;
+
+  if (!sub || sub === 'help' || sub === '--help') {
+    log(`# leerness wakeup-interval (1.9.210) — adaptive wakeup 간격`);
+    log('');
+    log(`  get              → 현재 권장 interval + stats (--json 가능)`);
+    log(`  set <secs>       → override 설정 (예: leerness wakeup-interval set 900)`);
+    log(`  auto             → override 해제 + 자동 계산 모드`);
+    log(`  history          → 최근 fire 이력 출력`);
+    log(`  record <kind>    → fire 기록 (user-trigger / auto / wakeup-miss)`);
+    log('');
+    log(dim(`  opt-out: env LEERNESS_FIXED_INTERVAL=1500 (초) 또는 set <secs>`));
+    return;
+  }
+
+  if (sub === 'get') {
+    const result = _computeAdaptiveInterval(root);
+    if (has('--json')) { log(JSON.stringify(result, null, 2)); return; }
+    log(cyan(`# leerness wakeup-interval get (1.9.210)`));
+    log(`  📊 권장 interval: ${grn(`${result.interval}s (${Math.round(result.interval/60)}min)`)}`);
+    log(`  mode: ${result.adaptive ? grn('adaptive') : yel('fixed')}`);
+    log(`  reason: ${result.reason}`);
+    if (result.stats) {
+      log('');
+      log(`  📈 stats (recent 2h):`);
+      log(`     • total fires: ${result.stats.recentTotal}`);
+      log(`     • user triggers: ${result.stats.userTriggers}`);
+      if (result.stats.avgUserGapMin !== null) log(`     • avg user gap: ${result.stats.avgUserGapMin}min`);
+      if (result.stats.criticalSignal) log(yel(`     • pre-wake critical 감지`));
+    }
+    log('');
+    log(dim(`  → ScheduleWakeup(delaySeconds: ${result.interval}) 권장`));
+    return;
+  }
+
+  if (sub === 'set') {
+    const n = Number(val);
+    if (!val || isNaN(n) || n < 60) { console.error('Usage: leerness wakeup-interval set <secs ≥ 60>'); process.exit(1); }
+    const state = _loadWakeupHistory(root);
+    state.override = n;
+    _writeWakeupHistory(root, state);
+    if (has('--json')) { log(JSON.stringify({ override: n }, null, 2)); return; }
+    log(grn(`✓ wakeup-interval override 설정: ${n}s (${Math.round(n/60)}min)`));
+    log(dim(`  해제: leerness wakeup-interval auto`));
+    return;
+  }
+
+  if (sub === 'auto') {
+    const state = _loadWakeupHistory(root);
+    state.override = null;
+    _writeWakeupHistory(root, state);
+    const result = _computeAdaptiveInterval(root);
+    if (has('--json')) { log(JSON.stringify({ override: null, current: result }, null, 2)); return; }
+    log(grn(`✓ override 해제 — 자동 계산 모드`));
+    log(`  현재 권장: ${result.interval}s (${Math.round(result.interval/60)}min) — ${result.reason}`);
+    return;
+  }
+
+  if (sub === 'history') {
+    const state = _loadWakeupHistory(root);
+    if (has('--json')) { log(JSON.stringify({ override: state.override, fires: state.fires.slice(-20) }, null, 2)); return; }
+    log(cyan(`# leerness wakeup-interval history (1.9.210)`));
+    log(`  total fires: ${state.fires.length}${state.override ? ` · override: ${state.override}s` : ''}`);
+    log('');
+    const recent = state.fires.slice(-15);
+    if (recent.length === 0) { log(dim('  (없음)')); return; }
+    for (const f of recent) {
+      const icon = f.kind === 'user-trigger' ? '👆' : (f.kind === 'wakeup-miss' ? '❗' : '⏰');
+      log(`  ${icon} ${f.at}  ${dim(f.kind)}`);
+    }
+    return;
+  }
+
+  if (sub === 'record') {
+    const kind = val || 'auto';
+    const validKinds = ['auto', 'user-trigger', 'wakeup-miss'];
+    if (!validKinds.includes(kind)) { console.error(`kind must be: ${validKinds.join('/')}`); process.exit(1); }
+    _recordWakeupFire(root, kind);
+    if (has('--json')) { log(JSON.stringify({ recorded: kind, at: new Date().toISOString() }, null, 2)); return; }
+    log(grn(`✓ wakeup fire 기록: ${kind}`));
+    return;
+  }
+
+  console.error(`Unknown subcommand: ${sub}`);
+  console.error(`Run: leerness wakeup-interval help`);
+  process.exit(1);
+}
+
 // 1.9.199: wakeup miss 자동 회복 강화 — last-handoff timestamp 기록 + 25min 기대 interval 정밀 측정
 //   사용자 명시 (1.9.198 후속): "22:01에 라운드에 자동진입되지않았어"
 //   1.9.196 task-log mtime 기반 detector 는 task-log 가 자주 안 업데이트되면 false positive.
@@ -4477,13 +4918,52 @@ function handoff(root) {
           parts.push(`📥 요청 ${audit.open} (tracked)`);
         }
       } catch {}
+      // 14) 1.9.209: pre-wake-audit 최근 보고서 (사용자 명시) — 깨어남 직후 자동 노출
+      try {
+        const pwState = _loadPreWakeReport(root);
+        if (pwState.reports.length > 0) {
+          const latest = pwState.reports[pwState.reports.length - 1];
+          const sum = latest.summary || {};
+          if (sum.criticalCount > 0 || sum.warningCount > 0) {
+            const ageMin = Math.floor((Date.now() - new Date(latest.auditedAt).getTime()) / 60000);
+            parts.push(`🔍 pre-wake ${sum.criticalCount}C/${sum.warningCount}W (${ageMin}m)`);
+          }
+        }
+      } catch {}
       if (parts.length) {
         const isTty = process.stdout && process.stdout.isTTY;
         const cy = s => isTty ? `\x1b[36m${s}\x1b[0m` : s;
-        log(cy(`📊 헤드라인 (1.9.81/93/113/152/162/192/197/204/207): ${parts.join(' · ')}`));
+        log(cy(`📊 헤드라인 (1.9.81/93/113/152/162/192/197/204/207/209): ${parts.join(' · ')}`));
       }
     } catch {}
   }
+
+  // 1.9.209: pre-wake-audit 본문 자동 노출 (handoff 마지막 부분, 사용자 명시)
+  //   "메인 에이전트가 깨어났을때, 서브에이전트가 정리한 내용을 확인"
+  try {
+    const pwState = _loadPreWakeReport(root);
+    if (pwState.reports.length > 0) {
+      const latest = pwState.reports[pwState.reports.length - 1];
+      const ageMin = Math.floor((Date.now() - new Date(latest.auditedAt).getTime()) / 60000);
+      // 4시간 이내 보고서만 자동 노출 (오래된 건 stale)
+      if (ageMin < 240 && (latest.summary.criticalCount > 0 || latest.summary.warningCount > 0)) {
+        const isTty = process.stdout && process.stdout.isTTY;
+        const cy2 = s => isTty ? `\x1b[36m${s}\x1b[0m` : s;
+        const rd2 = s => isTty ? `\x1b[31m${s}\x1b[0m` : s;
+        const yl2 = s => isTty ? `\x1b[33m${s}\x1b[0m` : s;
+        const dm2 = s => isTty ? `\x1b[2m${s}\x1b[0m` : s;
+        log('');
+        log(cy2(`## 🔍 직전 sleep pre-wake-audit (1.9.209, ${ageMin}분 전)`));
+        if (latest.findings.critical && latest.findings.critical.length) {
+          latest.findings.critical.slice(0, 3).forEach(f => log(rd2(`  🚨 [${f.kind}] ${f.detail}`)));
+        }
+        if (latest.findings.warning && latest.findings.warning.length) {
+          latest.findings.warning.slice(0, 3).forEach(f => log(yl2(`  ⚠ [${f.kind}] ${f.detail}`)));
+        }
+        log(dm2(`  → 상세: leerness pre-wake-audit --last`));
+      }
+    }
+  } catch {}
   // 1.9.8: active rules 자동 노출 (매 세션 시작 시 AI에게 보임)
   const activeRules = readRules(root).filter(r => r.status === 'active');
   if (activeRules.length) {
@@ -15796,6 +16276,10 @@ async function main() {
   if (cmd === 'requests')                           return requestsCmd(arg('--path', process.cwd()), args[1], ...args.slice(2));
   // 1.9.208: leerness constraints <list|check|add> — 플랫폼/API 제약 사전 체크 (사용자 명시)
   if (cmd === 'constraints')                        return constraintsCmd(arg('--path', process.cwd()), args[1], ...args.slice(2));
+  // 1.9.209: leerness pre-wake-audit — sleep 전 sub-agent audit (사용자 명시)
+  if (cmd === 'pre-wake-audit')                     return preWakeAuditCmd(arg('--path', process.cwd()), args[1]);
+  // 1.9.210: leerness wakeup-interval <get|set|auto|history|record> — adaptive interval (사용자 명시)
+  if (cmd === 'wakeup-interval')                    return wakeupIntervalCmd(arg('--path', process.cwd()), args[1], args[2]);
   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()));
   if (cmd === 'rule' && args[1] === 'remove')       return ruleRemove(arg('--path', process.cwd()), args[2]);

package/package.json

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