leerness 1.9.40 → 1.9.41

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 1.9.41 — 2026-05-19
+
+**디스크 마이그레이션 ↔ AI 컨텍스트 인지 갭 차단 — 맞춤형 차분 마이그레이션**.
+
+사용자 통찰: 같은 채팅 세션에서 leerness를 latest로 migrate해도, AI 에이전트는 이전 청크의 마인드셋으로 계속 작업하여 신규 도구(release pack, drift check 등)를 자동으로 호출하지 않는 패턴 발견. migrate는 파일만 업데이트, AI에겐 "새 도구가 들어왔다"는 신호 전달 부재.
+
+### Added
+
+- **`leerness whats-new [--from V] [--to V] [--json]`** 신규 명령 — CHANGELOG.md를 자동 파싱하여 두 버전 사이의 차분 추출:
+  - 신규 명령 (`leerness X` 패턴), 신규 플래그 (`--xxx`), 신규 파일 (`.harness/*.md`) 자동 분류
+  - 각 버전의 헤드라인 (`**...**` 또는 첫 라인) 추출
+  - AI 가독 권장 행동 자동 출력
+- **`migrate` 후 stdout에 AI must re-read 차분 자동 출력** — migrate 직전 이전 버전을 캡처 (`_previousVersion`) → CHANGELOG 차분 추출 → 신규 명령/파일을 stdout에 즉시 표시:
+  - "이전 청크의 기억 무효 — 새 도구 우선 시도" 명시
+  - 같은 세션 내 AI 인-컨텍스트에 신규 도구 인지 주입
+- **`migration-report.md`에 "🤖 AI must re-read" 섹션 영구 기록** — 신규 명령/플래그/파일 + 버전별 헤드라인 + 권장 행동
+- **`handoff`가 fresh migration-report (24h 내) 시 자동 알림** — "🆕 최근 N시간 전 migrate 차분" 블록 자동 표시. 같은 세션 내 매 handoff 호출이 AI에게 신규 도구 재안내.
+
+### 발견된 시스템 결함 (이번 라운드 해결)
+- ❌ **before 1.9.41**: migrate가 파일만 업데이트, AI 마인드셋 stale 유지 → 신규 도구 자동 호출 X
+- ✅ **1.9.41 이후**: migrate 직후 stdout + migration-report.md + handoff 모두 신규 도구를 AI 가독 포맷으로 노출 → "잊을 수 없는" 차분 안내
+
+### 자기 검증
+- 의도적으로 root를 1.9.37로 되돌림 → `leerness migrate .` 호출 → **AI must re-read 차분 자동 stdout 출력**:
+  - `📌 신규 명령: leerness release pack`
+  - 1.9.38/1.9.39/1.9.40 버전별 헤드라인 자동 추출
+  - 권장 행동 4단계 (--help, 신규 파일 재독, 인스트럭션 재독, whats-new --json)
+
+### e2e: 186/186 PASS (1.9.40 182 + 신규 4)
+
+### 정책
+- ✅ 차분 안내는 **AI 가독 포맷** (`**📌**`, `` `leerness X` `` 등 마크다운)
+- ✅ 같은 세션 내 다양한 채널 (stdout + report + handoff)로 *반복 노출* → 청크 stale 방지
+- ✅ 추출은 CHANGELOG.md 파싱 — 새 라운드 마다 자동 갱신
+
 ## 1.9.40 — 2026-05-19
 
 **dogfooding gap 차단 — `leerness release pack` 통합 명령 + audit README mismatch 자동 감지**.

package/README.md

@@ -12,7 +12,7 @@
   ║  ██║     ██╔══╝  ██╔══╝  ██╔══██╗██║╚██╗██║██╔══╝  ╚════██║  ║
   ║  ███████╗███████╗███████╗██║  ██║██║ ╚████║███████╗███████║  ║
   ║  ╚══════╝╚══════╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝╚══════╝╚══════╝  ║
-  ║  v1.9.40   AI Agent Reliability Harness                      ║
+  ║  v1.9.41   AI Agent Reliability Harness                      ║
   ║  verify · remember · orchestrate · audit · prevent drift     ║
   ╚══════════════════════════════════════════════════════════════╝
 ```
@@ -394,6 +394,7 @@ npm test     # = node ./scripts/e2e.js
 
 ## 변경 이력 (최근)
 
+- **1.9.41** — 디스크↔AI 컨텍스트 인지 갭 차단: `leerness whats-new` 명령 (CHANGELOG 자동 차분 추출) · `migrate` 후 stdout에 AI must re-read 차분 자동 출력 · `migration-report.md`에 신규 명령/파일 영구 기록 · `handoff`가 fresh migrate(24h 내) 시 자동 알림.
 - **1.9.40** — dogfooding gap 차단: `leerness release pack` 통합 명령 (라운드 마감 자동화 — npm pack + parent migrate + task add + close + readme sync) · `audit`에 README ↔ package.json version mismatch 자동 감지 + `--fix`로 자동 갱신.
 - **1.9.39** — AI 하네스 엔지니어링 6단계 워크플로 자동 유도 (`session-workflow.md` + handoff 끝 가이드 + AGENTS/CLAUDE 인스트럭션 통합) · `drift check --auto-fix` · `handoff --auto-recover` (critical 시 session close 자동 실행).
 - **1.9.38** — drift 자동 reminder (`agent-reminders.md`) · `usage stats` 명령 · `task sync --from <todo.json>` · drift 임계 학습 (skip ≥5 → 임계 완화).

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.40';
+const VERSION = '1.9.41';
 const MARK = '<!-- leerness:managed -->';
 const README_START = '<!-- leerness:project-readme:start -->';
 const README_END = '<!-- leerness:project-readme:end -->';
@@ -411,10 +411,43 @@ function mergeLinesFile(p, lines) {
   writeUtf8(p, next);
 }
 
-function writeMigrationReport(root, backup, actions) {
+function writeMigrationReport(root, backup, actions, opts = {}) {
   const p = path.join(root, '.harness/migration-report.md');
   const rows = actions.map(a => `| ${a.file} | ${a.action} |`).join('\n');
-  writeUtf8(p, `# Leerness Migration Report\n\nVersion: ${VERSION}\nDate: ${now()}\nBackup: ${rel(root, backup.archiveDir)}\n\n## Policy\n\n- Existing harness, skill, and instruction files are backed up before migration.\n- Project memory files are preserved by default.\n- Managed instruction files are merged with previous content instead of being blindly overwritten.\n- .env.example/.gitignore are line-merged only.\n\n## Backed Up Candidates\n\n${backup.candidates.map(x => '- ' + x).join('\n')}\n\n## File Actions\n\n| File | Action |\n|---|---|\n${rows}\n`);
+  // 1.9.41: AI must re-read 섹션 — migrate가 추가/변경한 파일을 AI 가독 포맷으로 추출
+  // fromV가 명시되면 CHANGELOG 차분 포함
+  let aiReadBlock = '';
+  try {
+    const fromV = opts.fromV || (backup && backup.previousVersion) || null;
+    if (fromV && fromV !== VERSION) {
+      const changelogPath = path.join(__dirname, '..', 'CHANGELOG.md');
+      const cl = exists(changelogPath) ? read(changelogPath) : (exists(path.join(root, 'CHANGELOG.md')) ? read(path.join(root, 'CHANGELOG.md')) : '');
+      if (cl) {
+        const diff = _parseChangelogBetween(cl, fromV, VERSION);
+        const allCommands = new Set(), allFlags = new Set(), allFiles = new Set();
+        for (const v of diff) {
+          v.newCommands.forEach(c => allCommands.add(c));
+          v.newFlags.forEach(f => allFlags.add(f));
+          v.newFiles.forEach(f => allFiles.add(f));
+        }
+        if (diff.length) {
+          aiReadBlock = `\n## 🤖 AI must re-read (1.9.41 차분 안내)\n\n`;
+          aiReadBlock += `이 migrate는 ${fromV} → ${VERSION} 점프입니다. 메인 AI 에이전트는 다음을 인지하고 우선 활용:\n\n`;
+          if (allCommands.size) aiReadBlock += `**📌 신규 명령** (이전엔 없던 것):\n${[...allCommands].map(c => `- \`leerness ${c}\``).join('\n')}\n\n`;
+          if (allFlags.size)    aiReadBlock += `**🚩 신규 플래그**:\n${[...allFlags].map(f => `- \`${f}\``).join('\n')}\n\n`;
+          if (allFiles.size)    aiReadBlock += `**📄 신규/변경 파일** (반드시 재독):\n${[...allFiles].map(f => `- \`${f}\``).join('\n')}\n\n`;
+          aiReadBlock += `**버전별 헤드라인**:\n`;
+          for (const v of diff) {
+            const firstLine = (v.body.match(/^\*\*([^*]+)\*\*/) || [])[1]
+                           || (v.body.split('\n').find(l => l.trim() && !l.startsWith('##')) || '').trim().slice(0, 120);
+            aiReadBlock += `- ${v.version} — ${firstLine || '(no headline)'}\n`;
+          }
+          aiReadBlock += `\n**권장 행동**:\n1. 위 신규 명령을 \`--help\`로 확인\n2. \`AGENTS.md\` / \`CLAUDE.md\` / \`.harness/session-workflow.md\` 재독 (다음 \`leerness handoff\` 호출 시 자동 안내)\n3. 이전 청크의 기억 무효 — 새 도구 우선 시도\n4. 상세: \`leerness whats-new --from ${fromV}\`\n`;
+        }
+      }
+    }
+  } catch {}
+  writeUtf8(p, `# Leerness Migration Report\n\nVersion: ${VERSION}\nDate: ${now()}\nBackup: ${rel(root, backup.archiveDir)}\n${opts.fromV ? `Previous: ${opts.fromV}\n` : ''}${aiReadBlock}\n## Policy\n\n- Existing harness, skill, and instruction files are backed up before migration.\n- Project memory files are preserved by default.\n- Managed instruction files are merged with previous content instead of being blindly overwritten.\n- .env.example/.gitignore are line-merged only.\n\n## Backed Up Candidates\n\n${backup.candidates.map(x => '- ' + x).join('\n')}\n\n## File Actions\n\n| File | Action |\n|---|---|\n${rows}\n`);
 }
 
 function syncReadme(root) {
@@ -517,6 +550,14 @@ async function resolveInstallOptions(root, opts = {}) {
 
 async function install(root, opts = {}) {
   root = absRoot(root); mkdirp(root);
+  // 1.9.41: migrate 직전 이전 버전 캡처 — 차분 안내에 사용
+  try {
+    const hv = path.join(root, '.harness', 'HARNESS_VERSION');
+    if (exists(hv) && !opts._previousVersion) {
+      const parsed = parseHarnessVersion(read(hv));
+      opts._previousVersion = parsed.base || parsed.plus || null;
+    }
+  } catch {}
   // 1.9.32: init 시 ASCII 배너 + 빠른 시작 가이드 (migrate는 quiet)
   if (!opts.migration && !has('--no-banner')) _banner({ quickStart: !opts.dry });
   // 1.9.33: npx 캐시로 옛 버전이 실행될 때 경고 (migrate/--no-stale-check 시 스킵)
@@ -588,7 +629,23 @@ async function install(root, opts = {}) {
     ]);
     syncReadme(root);
     installSkills(root, skills);
-    writeMigrationReport(root, backup, actions);
+    // 1.9.41: migrate 시 이전 버전을 미리 캡처해 차분 안내에 사용
+    writeMigrationReport(root, backup, actions, { fromV: opts._previousVersion || null });
+    // 1.9.41: migrate 후 (= 점프인 경우) 차분 안내를 stdout에 즉시 출력 — AI 컨텍스트에 새 도구 주입
+    if (opts.migration && opts._previousVersion && opts._previousVersion !== VERSION) {
+      try {
+        const reportPath = path.join(root, '.harness', 'migration-report.md');
+        if (exists(reportPath)) {
+          const rep = read(reportPath);
+          const aiBlock = rep.match(/## 🤖 AI must re-read[\s\S]*?(?=\n## )/);
+          if (aiBlock) {
+            log('');
+            log(aiBlock[0].trim());
+            log('');
+          }
+        }
+      } catch {}
+    }
     // 1.9.1 P7: 디폴트 M-0001이 plan에 있고 progress에 row가 없으면 자동 추가
     try {
       const planText = exists(planPath(root)) ? read(planPath(root)) : '';
@@ -1425,6 +1482,29 @@ function handoff(root) {
     const cs = read(currentStatePath(root)).replace(/Updated: \d{4}-\d{2}-\d{2}/, `Updated: ${today()}`);
     writeUtf8(currentStatePath(root), cs);
   }
+  // 1.9.41: 최근 migrate 차분 알림 — migration-report.md가 24h 내면 "AI must re-read" 블록 자동 표시
+  // 같은 채팅 세션의 AI 청크가 이전 버전 마인드셋이어도 새 도구를 즉시 인지하도록.
+  if (!has('--no-workflow-guide') && !has('--compact')) {
+    try {
+      const reportPath = path.join(root, '.harness', 'migration-report.md');
+      if (exists(reportPath)) {
+        const stat = fs.statSync(reportPath);
+        const ageHr = (Date.now() - stat.mtimeMs) / 3600000;
+        if (ageHr < 24) {
+          const rep = read(reportPath);
+          const aiBlock = rep.match(/## 🤖 AI must re-read[\s\S]*?(?=\n## )/);
+          if (aiBlock) {
+            const isTty = process.stdout && process.stdout.isTTY;
+            const yel = s => isTty ? `\x1b[33m${s}\x1b[0m` : s;
+            log('');
+            log(yel(`## 🆕 최근 ${ageHr.toFixed(1)}시간 전 migrate 차분 — AI 에이전트는 신규 도구 우선 시도`));
+            log(aiBlock[0].trim());
+            log('');
+          }
+        }
+      }
+    } catch {}
+  }
   // 1.9.39: handoff 출력 끝에 6단계 워크플로 가이드 자동 표시 (메인 에이전트가 매 세션 인지)
   if (!has('--no-workflow-guide') && !has('--compact') && process.env.LEERNESS_NO_WORKFLOW_GUIDE !== '1') {
     const isTty = process.stdout && process.stdout.isTTY;
@@ -5698,6 +5778,107 @@ function _bumpUsage(root, cmdName) {
   } catch {}
 }
 
+// 1.9.41: CHANGELOG.md를 파싱하여 from → to 사이 버전 차분 추출
+// 반환: [{ version, date, body, newCommands, newFlags, newFiles }]
+function _parseChangelogBetween(changelogText, fromV, toV) {
+  // ## 1.9.X — YYYY-MM-DD 헤더 사이의 텍스트 추출
+  const sections = [];
+  const re = /^## (\d+\.\d+\.\d+)(?:\s+—\s+(\d{4}-\d{2}-\d{2}))?\s*\n([\s\S]*?)(?=^## \d+\.\d+\.\d+|$)/gm;
+  let m;
+  while ((m = re.exec(changelogText)) !== null) {
+    sections.push({ version: m[1], date: m[2] || null, body: m[3].trim() });
+  }
+  // from < V <= to 만 (fromV 자체는 이미 적용된 버전이므로 제외)
+  const ranged = sections.filter(s => {
+    const cmp = (v1, v2) => {
+      const a = v1.split('.').map(Number), b = v2.split('.').map(Number);
+      for (let i = 0; i < 3; i++) { if (a[i] !== b[i]) return a[i] - b[i]; }
+      return 0;
+    };
+    return cmp(s.version, fromV) > 0 && cmp(s.version, toV) <= 0;
+  });
+  // 각 섹션에서 신규 명령/플래그/파일 추출
+  for (const s of ranged) {
+    s.newCommands = [];
+    s.newFlags = [];
+    s.newFiles = [];
+    // `leerness X [...]` 또는 backtick에 싸인 leerness 명령
+    for (const cm of s.body.matchAll(/`leerness\s+([a-z][\w-]*(?:\s+[a-z][\w-]*)?)/g)) {
+      const cmd = cm[1].trim();
+      if (!s.newCommands.includes(cmd)) s.newCommands.push(cmd);
+    }
+    // `--xxx` 플래그
+    for (const fm of s.body.matchAll(/`(--[a-z][\w-]*)`/g)) {
+      if (!s.newFlags.includes(fm[1])) s.newFlags.push(fm[1]);
+    }
+    // .harness/X.md 같은 신규 파일
+    for (const ff of s.body.matchAll(/`(\.harness\/[\w./-]+\.(?:md|json|jsonl))`/g)) {
+      if (!s.newFiles.includes(ff[1])) s.newFiles.push(ff[1]);
+    }
+  }
+  return ranged;
+}
+
+// 1.9.41: leerness whats-new [--from V] — 현재 워크스페이스 버전 → leerness latest 차분
+function whatsNewCmd(root) {
+  root = absRoot(root || process.cwd());
+  const fromV = arg('--from', null) || (function () {
+    const hv = path.join(root, '.harness', 'HARNESS_VERSION');
+    if (exists(hv)) { try { return parseHarnessVersion(read(hv)).base || parseHarnessVersion(read(hv)).plus; } catch { return null; } }
+    return null;
+  })();
+  const toV = arg('--to', null) || VERSION;
+  if (!fromV) {
+    fail('현재 버전을 파악할 수 없습니다. --from <version> 명시');
+    return process.exit(1);
+  }
+  // CHANGELOG.md — 우선 root, 없으면 leerness-pkg 자체
+  let changelogPath = path.join(root, 'CHANGELOG.md');
+  if (!exists(changelogPath)) changelogPath = path.join(__dirname, '..', 'CHANGELOG.md');
+  if (!exists(changelogPath)) {
+    fail('CHANGELOG.md 없음');
+    return process.exit(1);
+  }
+  const diff = _parseChangelogBetween(read(changelogPath), fromV, toV);
+  if (has('--json')) { log(JSON.stringify({ from: fromV, to: toV, versions: diff }, null, 2)); return; }
+  if (!diff.length) {
+    log(`# leerness whats-new (1.9.41)`);
+    log(`현재 ${fromV} ↔ 대상 ${toV}: 새 항목 없음 (또는 CHANGELOG에 기록 안 됨)`);
+    return;
+  }
+  log(`# leerness whats-new (1.9.41)`);
+  log(`현재 워크스페이스 버전: ${fromV} → 대상: ${toV}`);
+  log(`범위: ${diff.length}개 버전 (${diff[0].version} → ${diff[diff.length - 1].version})`);
+  log('');
+  // AI 가독 요약 — 각 버전당 한 줄 + 신규 명령/플래그/파일
+  log(`## 🆕 신규 명령·플래그·파일 (AI 에이전트는 다음 명령을 우선 시도)`);
+  const allCommands = new Set();
+  const allFlags = new Set();
+  const allFiles = new Set();
+  for (const v of diff) {
+    v.newCommands.forEach(c => allCommands.add(c));
+    v.newFlags.forEach(f => allFlags.add(f));
+    v.newFiles.forEach(f => allFiles.add(f));
+  }
+  if (allCommands.size) log(`  📌 신규 명령: ${[...allCommands].join(', ')}`);
+  if (allFlags.size)    log(`  🚩 신규 플래그: ${[...allFlags].join(', ')}`);
+  if (allFiles.size)    log(`  📄 신규 파일: ${[...allFiles].join(', ')}`);
+  log('');
+  log(`## 📜 버전별 헤드라인`);
+  for (const v of diff) {
+    // body 첫 줄(또는 strong header) 추출
+    const firstLine = (v.body.match(/^\*\*([^*]+)\*\*/) || [])[1]
+                   || (v.body.split('\n').find(l => l.trim() && !l.startsWith('##')) || '').trim().slice(0, 120);
+    log(`  • ${v.version}${v.date ? ` (${v.date})` : ''} — ${firstLine || '(no headline)'}`);
+  }
+  log('');
+  log(`## 💡 권장 행동`);
+  log(`  1. 위 신규 명령들을 시도해 보세요 (예: \`leerness <명령> --help\`)`);
+  log(`  2. 신규 파일들을 읽어 보세요 (예: \`cat .harness/session-workflow.md\`)`);
+  log(`  3. AGENTS.md/CLAUDE.md 재독 — migrate가 인스트럭션을 업데이트했을 수 있음`);
+  log(`  4. 상세: \`cat CHANGELOG.md\` 또는 \`leerness whats-new --json\``);
+}
+
 function usageStatsCmd(root) {
   root = absRoot(root || process.cwd());
   const stats = _readUsageStats(root);
@@ -5963,6 +6144,7 @@ async function main() {
   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 === 'usage' && (args[1] === 'stats' || !args[1])) return usageStatsCmd(args[2] || arg('--path', process.cwd()));
+  if (cmd === 'whats-new') return whatsNewCmd(args[1] || 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.40",
+  "version": "1.9.41",
   "description": "Leerness: 비파괴 마이그레이션, 자동 버전 감지·업데이트, 계획/진행/핸드오프 자동화, 게으름·시크릿·인코딩 자동 가드, Claude Code 슬래시 통합을 갖춘 한국어 우선 AI 개발 하네스.",
   "keywords": [
     "leerness",

package/scripts/e2e.js

@@ -950,6 +950,66 @@ total++;
   if (!ok) { failed++; console.log(r.stdout.slice(0, 800)); }
 }
 
+// 1.9.41 회귀: whats-new 명령 + migrate 차분 AI must re-read + handoff fresh 알림
+total++;
+{
+  // whats-new --from 큰 점프 → 신규 명령 추출
+  const r = cp.spawnSync(process.execPath, [CLI, 'whats-new', '--from', '1.9.33', '--json'], { encoding: 'utf8', timeout: 15000 });
+  let parsed = null;
+  try { parsed = JSON.parse(r.stdout); } catch {}
+  const ok = parsed
+    && parsed.from === '1.9.33'
+    && Array.isArray(parsed.versions)
+    && parsed.versions.length >= 5
+    && parsed.versions.some(v => v.newCommands && v.newCommands.length > 0);
+  console.log(ok ? '✓ B(1.9.41) whats-new --from 1.9.33: 5+ 버전 차분 + 신규 명령 추출' : `✗ whats-new 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+total++;
+{
+  // migrate가 fromV가 있는 경우 AI must re-read 블록을 stdout에 출력
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-mig-'));
+  // 1.9.30 표시로 init한 척 (HARNESS_VERSION 직접 작성)
+  fs.mkdirSync(path.join(tmpC, '.harness'), { recursive: true });
+  fs.writeFileSync(path.join(tmpC, '.harness', 'HARNESS_VERSION'), 'leerness@1.9.36\n', 'utf8');
+  const r = cp.spawnSync(process.execPath, [CLI, 'migrate', tmpC, '--yes', '--no-banner', '--no-stale-check'], { encoding: 'utf8', timeout: 60000 });
+  const ok = r.status === 0
+    && /AI must re-read/.test(r.stdout)
+    && /1\.9\.36 → 1\.9\.4[01]/.test(r.stdout)
+    && /신규 명령/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.41) migrate stdout: AI must re-read 차분 자동 출력' : `✗ migrate 차분 출력 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(-800)); }
+}
+
+total++;
+{
+  // migration-report.md에 AI must re-read 섹션 영구 기록
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-mig2-'));
+  fs.mkdirSync(path.join(tmpC, '.harness'), { recursive: true });
+  fs.writeFileSync(path.join(tmpC, '.harness', 'HARNESS_VERSION'), 'leerness@1.9.30\n', 'utf8');
+  cp.spawnSync(process.execPath, [CLI, 'migrate', tmpC, '--yes', '--no-banner', '--no-stale-check'], { stdio: 'ignore', timeout: 60000 });
+  const reportPath = path.join(tmpC, '.harness', 'migration-report.md');
+  const body = fs.existsSync(reportPath) ? fs.readFileSync(reportPath, 'utf8') : '';
+  const ok = /## 🤖 AI must re-read/.test(body) && /Previous: 1\.9\.30/.test(body);
+  console.log(ok ? '✓ B(1.9.41) migration-report.md: AI must re-read 섹션 + Previous 버전 기록' : `✗ report 기록 실패`);
+  if (!ok) { failed++; console.log(body.slice(0, 600)); }
+}
+
+total++;
+{
+  // handoff가 fresh migration-report (24h 내) 시 자동 알림
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-fresh-'));
+  fs.mkdirSync(path.join(tmpC, '.harness'), { recursive: true });
+  fs.writeFileSync(path.join(tmpC, '.harness', 'HARNESS_VERSION'), 'leerness@1.9.30\n', 'utf8');
+  cp.spawnSync(process.execPath, [CLI, 'migrate', tmpC, '--yes', '--no-banner', '--no-stale-check'], { stdio: 'ignore', timeout: 60000 });
+  const r = cp.spawnSync(process.execPath, [CLI, 'handoff', tmpC, '--no-drift-check'], { encoding: 'utf8', timeout: 15000 });
+  const ok = r.status === 0
+    && /최근.*시간 전 migrate 차분|AI must re-read/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.41) handoff: 최근 migrate 차분 자동 표시 (24h 내)' : `✗ handoff 차분 알림 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(-500)); }
+}
+
 // 1.9.40 회귀: release pack 통합 명령 + audit README mismatch 감지
 total++;
 {