leerness 1.9.202 → 1.9.204

package/CHANGELOG.md

@@ -1,5 +1,114 @@
 # Changelog
 
+## 1.9.204 — 2026-05-22
+
+**⏰ timezone 보강 + 🔄 auto-loop 활성 라벨 (사용자 명시 2종).**
+
+### 사용자 명시
+> 1. *"시간관련 기능 등은 해당 국가의 시간대를 고려해서 작업이 될 수 있는지"*
+> 2. *"자동으로 깨어나서 작업하는 모드도 활성룰에 표시되어야 할 것 같은데, 활성 룰 에 표시되는 기능 점검"*
+
+### 1. timezone 시스템 (Intl.DateTimeFormat 기반, 의존성 0)
+- `_getLocalTz()` — `process.env.LEERNESS_TZ` → 시스템 timezone → `Asia/Seoul` fallback
+- `_formatLocal(iso, opts)` — ISO UTC → 사용자 local time (예: `2026-05-22 10:13 KST`)
+- 단축 라벨: KST / JST / UTC / 자동 추출
+- **저장은 UTC ISO 유지** (이식성/일관성), **display 만 local time 변환**
+
+### 2. resume CLI local time 표시
+```
+$ leerness resume
+  📅 plan 저장: 2026-05-22 09:48 KST  (29분 전)
+  ⏰ 예상 fire: 2026-05-22 10:13 KST  (정시)
+```
+이전: `2026-05-22T00:48:23.298Z` (한국 사용자 +9 머릿속 변환 필요)
+이후: `2026-05-22 09:48 KST` (즉시 인지 가능)
+
+### 3. 자동 모드 활성 라벨 (헤드라인 12번째)
+```
+📊 헤드라인 (1.9.81/93/113/152/162/192/197/204): ... · 🔄 auto-loop 25min · ...
+```
+- `_getAutoLoopRule(root)` — `R-XXXX [every-round]` 활성 룰 자동 감지
+- 룰 텍스트에서 `25분` 또는 `1500초` 패턴 추출 → 분 단위 표시
+
+### 4. 누적 회귀 (1.9.198~203) — 모두 유지
+
+### 5. stress-v149 — 16/16 PASS
+- timezone (3) + resume display (1) + headline label (2) + 실 검증 (1) + 성능 (2) + 누적 (7)
+- 성능: --version cold start avg **471 ms** · MCP 54 도구 **438 ms**
+
+### 6. 자동 release 흐름
+- main 자동 push **66 라운드 연속** (1.9.140~204)
+- npm publish 자동 (1.9.178~)
+
+---
+
+## 1.9.203 — 2026-05-22
+
+**📋 자동 라운드 plan 자동 정리 + `leerness resume` 신규 CLI (사용자 명시).**
+
+### 사용자 명시
+> *"자동모드는 백그라운드에 다음 작업이 시작가능한 예상 시간을 설정해서 백그라운드에서 알람 트리거 같은걸 구현하고 일어났을때 해야하는 일을 정리해서 또 진행하고 반복으로 하는건 어떨까"*
+
+### 1. `.harness/auto-resume-plan.json` 자동 저장
+- 라운드 마무리 (release sync-main 시 npm publish 완료 후) **자동 저장**
+- plan 구조:
+  - `savedAt`, `nextRoundVersion`, `expectedFireAt`, `intervalMin`
+  - `focus` (자유 텍스트)
+  - `contextSnapshot` (currentVersion, activeTaskId, activeTaskRequest, memorySurface, r0001Rule)
+  - `nextActions` (1.9.201 next-action-queue snapshot)
+- 함수: `_loadAutoResumePlan` / `_writeAutoResumePlan` / `_buildAutoResumePlan` / `_autoResumePlanPath`
+
+### 2. `leerness resume` 신규 CLI
+일어났을 때 즉시 무엇부터 할지 한눈에:
+```
+$ leerness resume
+# 🔄 leerness resume (1.9.203 자동 라운드 plan 적용)
+  📅 plan 저장: 2026-05-22T00:10:10.797Z  (15분 전)
+  ⏰ 예상 fire: 2026-05-22T00:35:10.797Z  (정시)
+  🎯 focus: 다음 라운드: handoff → next-action take → 사용자 명시 또는 5축 매트릭스 보강
+
+## 다음 라운드: next after 1.9.203
+  현재 버전: 1.9.203
+  활성 task: T-9999 — ...
+  memory: T2/D15/R1/L3
+  룰: 25분 간격 (사용자 명시, R-0001)
+
+## 사전 정리된 next-actions (3건)
+  🛡 lessons.md "X" 관련 ...
+     `leerness lessons --auto --path .`
+  ...
+  → 즉시 task 추가: leerness next-action take
+
+✓ resume 준비 완료 — 권장: leerness handoff . 또는 leerness next-action take
+```
+- `--json` 옵션 (자동화/MCP)
+
+### 3. handoff 자동 plan 알림
+handoff 진입 시 plan 존재 시 자동 노출:
+```
+## 📋 auto-resume-plan 로드 (1.9.203) — 15분 전 저장 (정시)
+  🎯 focus: 다음 라운드: ...
+  📦 다음 버전: next after 1.9.203
+  📥 사전 정리된 actions: 3건 → leerness next-action take
+  → 상세: leerness resume
+```
+끄기: `LEERNESS_NO_RESUME_PLAN=1`
+
+### 4. 자율 모드 cycle 완성
+- 라운드 마무리 → plan 자동 저장 → ScheduleWakeup 25분 → wakeup → handoff plan 자동 로드 → resume / next-action take → 즉시 진입
+
+### 5. 누적 회귀 (1.9.197~202) — 모두 유지
+
+### 6. stress-v148 — 17/17 PASS
+- auto-resume-plan 5 + resume CLI 3 + handoff 통합 + 성능 2 + 누적 회귀 7
+- 성능: --version cold start avg **464 ms** · MCP 54 도구 **449 ms**
+
+### 7. 자동 release 흐름
+- main 자동 push **65 라운드 연속** (1.9.140~203)
+- npm publish 자동 (1.9.178~)
+
+---
+
 ## 1.9.202 — 2026-05-22
 
 **🌐 C축 (공식 표준 스킬 자동 활용) 9.0/10 → 9.5/10 보강 — matched skill 설치 상태 표시 + leerness skill install-top.**

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.202-green)]() [![tests](https://img.shields.io/badge/e2e-217%2F217-success)]() [![stress](https://img.shields.io/badge/stress--v147-15%2F15-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-54-brightgreen)]() [![rounds](https://img.shields.io/badge/autonomous--rounds-132-blueviolet)]() [![main-push](https://img.shields.io/badge/release--main--push-64_rounds-success)]() [![goal-matrix](https://img.shields.io/badge/목적_매트릭스-98%2F100_(5축)-brightgreen)]() [![skill-install-top](https://img.shields.io/badge/skill-install--top_즉시-success)]() [![perf](https://img.shields.io/badge/cold_start-457ms-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.204-green)]() [![tests](https://img.shields.io/badge/e2e-217%2F217-success)]() [![stress](https://img.shields.io/badge/stress--v149-16%2F16-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-54-brightgreen)]() [![rounds](https://img.shields.io/badge/autonomous--rounds-134-blueviolet)]() [![main-push](https://img.shields.io/badge/release--main--push-66_rounds-success)]() [![goal-matrix](https://img.shields.io/badge/목적_매트릭스-98%2F100_(5축)-brightgreen)]() [![tz-aware](https://img.shields.io/badge/timezone-KST_local_time-success)]() [![perf](https://img.shields.io/badge/cold_start-471ms-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.202  AI Agent Reliability Harness + Sandbox            ║
+  ║  v1.9.204  AI Agent Reliability Harness + Sandbox            ║
   ║  verify · remember · orchestrate · audit · sandbox · drift   ║
-  ║  🌐 skill install-top + 설치 상태 · 매트릭스 98/100 · A·D·E 10/10 ║
+  ║  ⏰ timezone 보강 (KST) · 🔄 auto-loop 25min 헤드라인 라벨       ║
   ╚══════════════════════════════════════════════════════════════╝
 ```
 

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.202';
+const VERSION = '1.9.204';
 
 // 1.9.184: DEP0190 (child_process shell: true) deprecation warning 억제 (사용자 명시).
 //   leerness 는 cross-platform PATH resolution 을 위해 shell: true 를 의도적으로 사용 (claude.cmd / ollama.cmd 등 Windows .cmd 처리).
@@ -130,6 +130,52 @@ function append(p, s) { mkdirp(path.dirname(p)); fs.appendFileSync(p, s, 'utf8')
 function rel(root, p) { return path.relative(root, p).replace(/\\/g, '/') || '.'; }
 function today() { return new Date().toISOString().slice(0, 10); }
 function now() { return new Date().toISOString(); }
+// 1.9.204: timezone 보강 (사용자 명시)
+//   ISO UTC timestamp 저장은 유지 (이식성/일관성) → display 시 사용자 local time 변환
+//   환경변수: LEERNESS_TZ (default = 시스템 timezone, fallback: 'Asia/Seoul')
+function _getLocalTz() {
+  if (process.env.LEERNESS_TZ) return process.env.LEERNESS_TZ;
+  try {
+    const sys = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (sys && sys !== 'UTC') return sys;
+  } catch {}
+  return 'Asia/Seoul';
+}
+// ISO timestamp → local time 표시 (예: "2026-05-22 10:13 KST")
+function _formatLocal(iso, opts) {
+  if (!iso) return '?';
+  opts = opts || {};
+  const tz = opts.tz || _getLocalTz();
+  try {
+    const d = typeof iso === 'string' ? new Date(iso) : iso;
+    if (isNaN(d.getTime())) return String(iso);
+    const fmt = new Intl.DateTimeFormat('en-CA', {
+      timeZone: tz,
+      year: 'numeric', month: '2-digit', day: '2-digit',
+      hour: '2-digit', minute: '2-digit',
+      hour12: false
+    });
+    const parts = fmt.formatToParts(d);
+    const get = (t) => (parts.find(p => p.type === t) || {}).value || '';
+    const date = `${get('year')}-${get('month')}-${get('day')}`;
+    const time = `${get('hour')}:${get('minute')}`;
+    // tz 약어 (KST/JST/UTC 등) — 간단 추출
+    const tzShort = tz === 'Asia/Seoul' ? 'KST' : tz === 'Asia/Tokyo' ? 'JST' : tz === 'UTC' ? 'UTC' : tz.split('/').pop().slice(0, 3);
+    return opts.dateOnly ? date : `${date} ${time} ${tzShort}`;
+  } catch { return String(iso); }
+}
+// 자동 모드 활성 여부 (R-XXXX every-round 룰 존재 시 true)
+function _isAutoLoopActive(root) {
+  try {
+    const rules = readRules(root);
+    return rules.some(r => r.status === 'active' && /every-round|every-session/i.test(r.trigger || ''));
+  } catch { return false; }
+}
+function _getAutoLoopRule(root) {
+  try {
+    return readRules(root).find(r => r.status === 'active' && /every-round/i.test(r.trigger || '')) || null;
+  } catch { return null; }
+}
 function arg(name, def = null) { const i = process.argv.indexOf(name); return i >= 0 ? (process.argv[i + 1] || true) : def; }
 function has(name) { return process.argv.includes(name); }
 function nonFlagArgs() {
@@ -1733,6 +1779,115 @@ async function skillAutoCacheCmd(root, sub) {
   if (c.expired) log(`  → 갱신: leerness skill auto-cache refresh`);
 }
 
+// 1.9.203: 자동 라운드 plan 정리 — 사용자 명시
+//   "백그라운드에 다음 작업이 시작가능한 예상 시간 + 일어났을때 해야하는 일을 정리"
+//   라운드 마무리 시 .harness/auto-resume-plan.json 자동 저장 → 다음 wakeup 시 즉시 실행 가능
+//   plan 구조: { savedAt, nextRoundVersion, expectedFireAt, focus, contextSnapshot, nextActions }
+function _autoResumePlanPath(root) { return path.join(root, '.harness', 'auto-resume-plan.json'); }
+function _loadAutoResumePlan(root) {
+  try {
+    const fp = _autoResumePlanPath(root);
+    if (!exists(fp)) return null;
+    const j = JSON.parse(read(fp));
+    if (!j.savedAt) return null;
+    const ageMs = Date.now() - new Date(j.savedAt).getTime();
+    const expiredMs = j.expectedFireAt ? Date.now() - new Date(j.expectedFireAt).getTime() : 0;
+    return { ...j, ageMs, ageMin: Math.floor(ageMs / 60000), elapsedFromExpected: Math.floor(expiredMs / 60000) };
+  } catch { return null; }
+}
+function _writeAutoResumePlan(root, plan) {
+  try {
+    mkdirp(path.join(root, '.harness'));
+    const payload = { savedAt: new Date().toISOString(), ...plan };
+    writeUtf8(_autoResumePlanPath(root), JSON.stringify(payload, null, 2));
+    return true;
+  } catch { return false; }
+}
+// 현재 워크스페이스 상태에서 다음 라운드 plan 자동 생성 (현재 task / matrix / handoff gap / next-action queue 결합)
+function _buildAutoResumePlan(root, opts) {
+  opts = opts || {};
+  const intervalMin = opts.intervalMin || 25;  // R-0001 영구 룰
+  const now = Date.now();
+  const expectedFireAt = new Date(now + intervalMin * 60 * 1000).toISOString();
+  // 현재 in-progress task
+  const rows = readProgressRows(root);
+  const active = rows.find(r => r.status === 'in-progress' || r.status === '[진행]');
+  // 현재 VERSION
+  const currentVersion = VERSION;
+  // next-action queue snapshot
+  const queueState = _loadNextActionQueue(root);
+  const queueTop = queueState.queue.length > 0 ? queueState.queue[queueState.queue.length - 1] : null;
+  // memory surface counts
+  const memorySurface = {
+    tasksInProgress: rows.filter(r => r.status === 'in-progress').length,
+    decisions: exists(decisionsPath(root)) ? (read(decisionsPath(root)).match(/^### \d{4}-\d{2}-\d{2}/gm) || []).length : 0,
+    rulesActive: readRules(root).filter(r => r.status === 'active').length,
+    lessons: exists(lessonsPath(root)) ? (read(lessonsPath(root)).match(/^### \d{4}-\d{2}-\d{2}/gm) || []).length : 0
+  };
+  return {
+    nextRoundVersion: opts.nextRoundVersion || `next after ${currentVersion}`,
+    expectedFireAt,
+    intervalMin,
+    focus: opts.focus || (active ? `${active.id} — ${(active.request || '').slice(0, 80)}` : '사용자 명시 대기 또는 5축 매트릭스 보강'),
+    contextSnapshot: {
+      currentVersion,
+      activeTaskId: active ? active.id : null,
+      activeTaskRequest: active ? (active.request || '').slice(0, 200) : null,
+      memorySurface,
+      r0001Rule: '25분 간격 (사용자 명시, R-0001)'
+    },
+    nextActions: (queueState.queue || []).slice(-3).map(a => ({ icon: a.icon, title: a.title, command: a.command || null })),
+    note: opts.note || '다음 wakeup 시 leerness resume 또는 leerness handoff 실행 → plan 자동 적용'
+  };
+}
+
+// 1.9.203: leerness resume 신규 CLI — auto-resume-plan 읽고 즉시 진행할 일 안내
+function resumeCmd(root) {
+  root = absRoot(root);
+  const plan = _loadAutoResumePlan(root);
+  if (!plan) {
+    log(`# leerness resume (1.9.203)`);
+    log(`  (auto-resume-plan 없음 — 첫 라운드)`);
+    log(`  → leerness handoff . 로 시작`);
+    return;
+  }
+  if (has('--json')) { log(JSON.stringify(plan, null, 2)); return; }
+  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;
+  log(cyan(`# 🔄 leerness resume (1.9.203 자동 라운드 plan 적용)`));
+  log('');
+  log(`  📅 plan 저장: ${_formatLocal(plan.savedAt)}  (${plan.ageMin}분 전)`);
+  log(`  ⏰ 예상 fire: ${_formatLocal(plan.expectedFireAt)}` + (plan.elapsedFromExpected > 0 ? yel(`  (${plan.elapsedFromExpected}분 지연)`) : ' (정시)'));
+  log(`  🎯 focus: ${plan.focus}`);
+  log('');
+  log(grn(`## 다음 라운드: ${plan.nextRoundVersion}`));
+  if (plan.contextSnapshot) {
+    const c = plan.contextSnapshot;
+    log(`  현재 버전: ${c.currentVersion}`);
+    if (c.activeTaskId) log(`  활성 task: ${c.activeTaskId} — ${(c.activeTaskRequest || '').slice(0, 70)}`);
+    const m = c.memorySurface || {};
+    log(`  memory: T${m.tasksInProgress || 0}/D${m.decisions || 0}/R${m.rulesActive || 0}/L${m.lessons || 0}`);
+    log(`  룰: ${c.r0001Rule || '-'}`);
+  }
+  if (plan.nextActions && plan.nextActions.length > 0) {
+    log('');
+    log(grn(`## 사전 정리된 next-actions (${plan.nextActions.length}건)`));
+    for (const a of plan.nextActions) {
+      log(`  ${a.icon || '•'} ${a.title}`);
+      if (a.command) log(dim(`     \`${a.command}\``));
+    }
+    log('');
+    log(dim(`  → 즉시 task 추가: leerness next-action take`));
+  }
+  log('');
+  log(dim(plan.note || ''));
+  log('');
+  log(grn(`✓ resume 준비 완료 — 권장: leerness handoff . 또는 leerness next-action take`));
+}
+
 // 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.
@@ -3535,6 +3690,9 @@ function handoff(root) {
   let _priorHandoffGap = { hasLast: false };
   try { _priorHandoffGap = _getLastHandoffGap(root); } catch {}
   try { _recordLastHandoff(root); } catch {}
+  // 1.9.203: auto-resume-plan 자동 로드 (사용자 명시 — 자동 모드 알람 트리거)
+  let _autoResumePlan = null;
+  try { _autoResumePlan = _loadAutoResumePlan(root); } catch {}
   // 1.9.96: --json 옵션 (구조화 출력, MCP 통합 / 외부 AI 친화)
   if (has('--json')) {
     const result = {
@@ -3738,6 +3896,23 @@ function handoff(root) {
           parts.push(`🌐 official ${m.total}/${m.cacheTotal} (${ageStr}${status})`);
         }
       } catch {}
+      // 12) 1.9.204: 자동 모드 활성 표시 (사용자 명시) — R-0001 every-round 룰 활성 시 헤드라인 노출
+      try {
+        const autoRule = _getAutoLoopRule(root);
+        if (autoRule) {
+          // 룰 텍스트에서 "25분" 우선, 없으면 "1500초" 패턴 추출 (분 우선순위)
+          const txt = autoRule.rule || '';
+          const minMatch = txt.match(/(\d+)\s*분/);
+          const secMatch = txt.match(/(\d+)\s*초/);
+          let label = '🔄 auto-loop';
+          if (minMatch) {
+            label = `🔄 auto-loop ${minMatch[1]}min`;
+          } else if (secMatch) {
+            label = `🔄 auto-loop ${Math.round(Number(secMatch[1]) / 60)}min`;
+          }
+          parts.push(label);
+        }
+      } catch {}
       // 11) 1.9.197: A축 (범용 AI 하네스) 9.5→10 보강 — provider probe 60분 캐시 자동 노출
       //     사용자 명시: "범용 AI 하네스 ... 최고의 도구" — 매 handoff 시 11 backend ready 상태 즉시 노출
       try {
@@ -3750,7 +3925,7 @@ function handoff(root) {
       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): ${parts.join(' · ')}`));
+        log(cy(`📊 헤드라인 (1.9.81/93/113/152/162/192/197/204): ${parts.join(' · ')}`));
       }
     } catch {}
   }
@@ -4049,6 +4224,26 @@ function handoff(root) {
       }
     } catch {}
   }
+  // 1.9.203: auto-resume-plan 알림 — 라운드 마무리 시 저장된 plan 자동 노출
+  //   사용자 명시: "백그라운드에 다음 작업이 시작가능한 예상 시간 + 일어났을때 해야하는 일을 정리"
+  if (_autoResumePlan && !has('--quiet') && process.env.LEERNESS_NO_RESUME_PLAN !== '1') {
+    try {
+      const isTty = process.stdout && process.stdout.isTTY;
+      const cy = s => isTty ? `\x1b[36m${s}\x1b[0m` : s;
+      const dim = s => isTty ? `\x1b[2m${s}\x1b[0m` : s;
+      const yel = s => isTty ? `\x1b[33m${s}\x1b[0m` : s;
+      const elapsed = _autoResumePlan.elapsedFromExpected || 0;
+      const status = elapsed > 5 ? yel(`(${elapsed}분 지연)`) : (elapsed > -5 ? '(정시)' : dim(`(${Math.abs(elapsed)}분 일찍)`));
+      log(cy(`## 📋 auto-resume-plan 로드 (1.9.203) — ${_autoResumePlan.ageMin}분 전 저장 ${status}`));
+      log(dim(`  🎯 focus: ${_autoResumePlan.focus || '(none)'}`));
+      log(dim(`  📦 다음 버전: ${_autoResumePlan.nextRoundVersion || '(none)'}`));
+      if (_autoResumePlan.nextActions && _autoResumePlan.nextActions.length > 0) {
+        log(dim(`  📥 사전 정리된 actions: ${_autoResumePlan.nextActions.length}건 → leerness next-action take`));
+      }
+      log(dim(`  → 상세: leerness resume`));
+      log('');
+    } catch {}
+  }
   // 1.9.196/199: ScheduleWakeup miss detector — 자율 모드 사용자 명시 "못일어나는 경우 종종 있음"
   //   1.9.196: task-log mtime 기반 (60min+) — false positive 가능
   //   1.9.199: last-handoff.json 정밀 측정 — R-0001 룰 (25min) 대비 gap 측정
@@ -9130,6 +9325,16 @@ function _publishToNpm(root, opts = {}) {
     if (pubR.status === 0) {
       ok(`npm publish 완료: ${pkgName}@${pkgVersion}`);
       try { _recordRun(root, { kind: 'npm_publish', package: pkgName, version: pkgVersion, dryRun: !!opts.dryRun, ok: true }); } catch {}
+      // 1.9.203: 라운드 마무리 시 다음 라운드 plan 자동 저장
+      try {
+        const plan = _buildAutoResumePlan(root, {
+          nextRoundVersion: `next after ${pkgVersion}`,
+          focus: '다음 라운드: handoff → next-action take → 사용자 명시 또는 5축 매트릭스 보강',
+          intervalMin: 25,
+          note: `다음 wakeup 시: 1) leerness resume . 으로 plan 확인  2) leerness handoff . 실행  3) leerness next-action take 로 즉시 task 진입`
+        });
+        _writeAutoResumePlan(root, plan);
+      } catch {}
     } else {
       const errOut = (pubR.stderr || pubR.stdout || '').slice(-400);
       if (/EPUBLISHCONFLICT|already exists|cannot publish over/i.test(errOut)) {
@@ -14965,6 +15170,8 @@ async function main() {
   if (cmd === 'roadmap')                            return roadmapCmd(args[1] || process.cwd());
   // 1.9.201: next-action queue CLI (E축 9.5→10)
   if (cmd === 'next-action')                        return nextActionCmd(arg('--path', process.cwd()), args[1], ...args.slice(2));
+  // 1.9.203: leerness resume — auto-resume-plan 읽고 다음 라운드 즉시 안내 (사용자 명시)
+  if (cmd === 'resume')                             return resumeCmd(arg('--path', process.cwd()));
   if (cmd === 'rule' && args[1] === 'add')          return ruleAdd(arg('--path', process.cwd()), args.slice(2).filter(x => !x.startsWith('-')).join(' '));
   if (cmd === 'rule' && args[1] === 'list')         return ruleList(arg('--path', process.cwd()));
   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.202",
+  "version": "1.9.204",
   "description": "Leerness: 비파괴 마이그레이션, 자동 버전 감지·업데이트, 계획/진행/핸드오프 자동화, 게으름·시크릿·인코딩 자동 가드, Claude Code 슬래시 통합을 갖춘 한국어 우선 AI 개발 하네스.",
   "keywords": [
     "leerness",