leerness 1.36.168 → 1.36.170

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.36.170 — 2026-08-27
+
+- next-action의 정규화 계약을 모든 읽기 표면으로 확장했습니다. release-time auto-resume plan 생성과 외부 에이전트용 `context`가 legacy `--filter`, 자동 완료 명령, 시간 기반 중복, 존재하지 않는 stress 실행을 다시 노출하지 않습니다.
+- 1.36.169 이전에 저장된 `auto-resume-plan.json`도 `resume`/`handoff`에서 지연 정규화하며, pre-wake audit가 폐기된 `pending` 필드 대신 canonical queue를 세어 대기 작업을 정확히 보고합니다.
+- 회귀 probe가 `next-action list/take`뿐 아니라 release plan, 기존 plan 재개, context JSON, pre-wake pending count까지 실제 CLI로 검증합니다. 외부 Codex 교차 리뷰 결과 P0/P1/P2는 없었습니다.
+
+## 1.36.169 — 2026-08-27
+
+- 멀티세션 lost-update 방지: plan/anchors canonical lock, decisions·lessons migration transaction, rule baseline verification serialization, 11-pair forced-interleaving regressions
+- 외부 Codex 교차 검수에서 재현한 자동 next-action 오류를 수정했습니다. decision/plan 제안은 실제 지원 명령만 안내하고, 일반 적용 프로젝트에 없는 `scripts/e2e.js` 대신 `leerness verify-code .`를 사용하며, 아직 생성되지 않은 stress 파일 실행을 제거합니다.
+- next-action에 시간·버전과 무관한 안정 키를 도입해 stress 버전 및 progress 경과시간 중복을 하나로 갱신합니다. 업그레이드 직후 list/take도 legacy 큐를 즉시 정규화하고, take의 선택·정규화·제거를 한 잠금 트랜잭션으로 묶어 동시 handoff가 제목을 바꿔도 task와 큐 상태가 갈라지지 않게 했습니다.
+
 ## 1.36.168 — 2026-08-26
 
 - Windows which가 동일 npm 설치의 extensionless/.cmd/.ps1 shim을 실제 package bin target과 npm 실행문까지 검증한 뒤 한 설치로 그룹화하고, pathCandidates 원문은 유지한 채 pathInstallations를 추가해 PATH 충돌 오탐을 제거. 독립 검토에서 잡힌 주석·더미 인자 우회까지 막아 변조·미증명·다른 디렉터리·비표준 .bat·POSIX 후보를 보수적으로 분리하며 15개 회귀 프로브와 제품 배선 가드 추가.

package/README.md

@@ -138,7 +138,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.168 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.170 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### 정체성 — AI 에이전트 운영 레이어 (UR-0030)
 
@@ -192,7 +192,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.36.168는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
+Leerness v1.36.170는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -213,7 +213,7 @@ Leerness v1.36.168는 stdio JSON-RPC MCP server를 내장합니다 — Claude Co
 `<<autonomous-loop-dynamic>>` 신호만 보내면 AI가:
 1) 다음 라운드 후보 선정 → 2) 코드 변경 → 3) 회귀 테스트 갱신 → 4) 전체 e2e 스위트 통과 → 5) npm publish + git tag → 6) main push → 7) session close → 8) 다음 라운드 예약.
 
-현재 누적: **v1.9.x → 1.36.168 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.170 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
 
 ### 성능 가이드
 
@@ -251,5 +251,5 @@ leerness release pack --close --auto-main-push
 - `.leerness/session-handoff.md`: 다음 세션 인수인계 (자동 작성)
 - `.leerness/lessons.md` / `decisions.md` / `rules.md`: 영구 메모리 (5 surface)
 
-Last synced by Leerness v1.36.168: 2026-08-26
+Last synced by Leerness v1.36.170: 2026-08-27
 <!-- leerness:project-readme:end -->

package/bin/leerness.js

@@ -48,7 +48,7 @@ const {
   migrateLegacyWorkspace,
 } = require('../lib/workspace-dir');
 
-const VERSION = '1.36.168';
+const VERSION = '1.36.170';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -4384,9 +4384,26 @@ function _selfTestCases() {
       // 1.36.47: 어색 조사 병기 소거 + 장문은 단어 경계 절단(…) — 실적용에서 발견된 품질 결함 회귀 방지
       const dLong = p._draftAnchors({ pkgDescription: '가나다 라마바사 아자차카 타파하 '.repeat(20) });
       const phraseOk = !dLong.goal.join('').includes('를(을)') && dLong.goal.some(l => l.includes('…')) && !/[가-힣]{2}…[가-힣]/.test(dLong.goal.join(''));
-      // 재초안: draft 마커 잔존 섹션은 gap 취급 (배선 소스가드)
-      const s47 = read(__filename);
-      const redraftOk = s47.includes("_mdSectionBody(briefTxt, 'Purpose') || '').includes(_draftM)");
+      // 재초안: draft 마커 잔존 섹션은 gap 취급 — 실제 CLI 핸들러가 두 파일을 교체하는지 검증한다.
+      const redraw = fs.mkdtempSync(path.join(os.tmpdir(), '__leerness_anchor_redraft_'));
+      let redraftOk = false;
+      const savedArgv = process.argv, savedWrite = process.stdout.write;
+      try {
+        mkdirp(path.join(redraw, '.leerness'));
+        writeUtf8(path.join(redraw, 'package.json'), JSON.stringify({ name: 'probe', version: '1.0.0', description: '새 정체성 신호' }));
+        writeUtf8(path.join(redraw, '.leerness', 'project-brief.md'), '# Brief\n\n## Purpose\n<!-- draft: leerness anchors old -->\n- OLD_PURPOSE_SENTINEL\n');
+        writeUtf8(path.join(redraw, '.leerness', 'plan.md'), '# Plan\n\n## Goal\n<!-- draft: leerness anchors old -->\n- OLD_GOAL_SENTINEL\n');
+        process.argv = ['node', 'leerness', 'anchors', 'draft', '--apply'];
+        process.stdout.write = () => true;
+        anchorsCmd(redraw, 'draft');
+        const rb = read(path.join(redraw, '.leerness', 'project-brief.md'));
+        const rp = read(path.join(redraw, '.leerness', 'plan.md'));
+        redraftOk = !rb.includes('OLD_PURPOSE_SENTINEL') && !rp.includes('OLD_GOAL_SENTINEL')
+          && rb.includes('새 정체성 신호') && rp.includes('새 정체성 신호');
+      } catch {} finally {
+        process.argv = savedArgv; process.stdout.write = savedWrite;
+        try { fs.rmSync(redraw, { recursive: true, force: true }); } catch {}
+      }
       if (!(phraseOk && redraftOk)) return false;
       // 무신호 시 발명 금지
       const empty = p._draftAnchors({});
@@ -4401,6 +4418,60 @@ function _selfTestCases() {
       const wired = typeof anchorsCmd === 'function' && s.includes("cmd === 'anchors'") && s.includes('→ leerness anchors draft');
       return draftOk && noInvent && secOk && noSec && wired;
     } },
+    { name: 'next-action 자동 제안 실행 가능성 (1.36.169/Codex P2): 일반 프로젝트 명령 + stable-key 마이그레이션/중복 갱신', run: () => {
+      const arena = fs.mkdtempSync(path.join(os.tmpdir(), '__leerness_next_action_'));
+      const root = path.join(arena, 'project');
+      try {
+        const hd = path.join(root, '.leerness');
+        const stressDir = path.join(arena, '_apps', 'leerness-stress', 'bin');
+        mkdirp(hd); mkdirp(stressDir);
+        writeUtf8(path.join(hd, 'plan.md'), '# Plan\n\n### M-0001. install release\nStatus: planned\n');
+        writeUtf8(path.join(hd, 'decisions.md'), '# Decisions\n\n### 2026-08-27 — install policy\n- Reason: probe\n');
+        writeUtf8(path.join(hd, 'review-evidence.md'), 'verified\n'.repeat(20));
+        const stressFile = path.join(stressDir, 'stress-v211.js');
+        writeUtf8(stressFile, '// existing baseline\n');
+        const old = new Date(Date.now() - 48 * 3600000); fs.utimesSync(stressFile, old, old);
+
+        const actions = _suggestNextActions(root, { id: 'T-0001', request: 'install 기능 보강' }, 'install');
+        const plan = actions.find(a => a.icon === '🎯');
+        const decision = actions.find(a => a.icon === '💭');
+        const stress = actions.find(a => a.icon === '🧬');
+        const generatedOk = plan?.command === 'leerness plan list --path .'
+          && decision?.command === 'leerness decision list --query "install"'
+          && stress?.title === 'stress-v211 오래됨 — 새 stress test 작성 권장'
+          && !Object.prototype.hasOwnProperty.call(stress, 'command')
+          && plan?.actionKey === 'plan:M-0001' && decision?.actionKey === 'decision:install'
+          && stress?.actionKey === 'stress-refresh';
+
+        const legacy = [
+          { icon: '🧬', title: 'stress-v210 마지막 갱신 46h 전 — 새 stress test 작성 권장', command: 'node _apps/leerness-stress/bin/stress-v211.js' },
+          { icon: '🧬', title: 'stress-v211 마지막 갱신 48h 전 — 새 stress test 작성 권장', command: 'node _apps/leerness-stress/bin/stress-v212.js' },
+          { icon: '🎯', title: plan.title, command: 'leerness plan list --filter "install"' },
+          { icon: '💭', title: decision.title, command: 'leerness decision list --filter "install"' },
+          { icon: '🧪', title: 'review-evidence.md 비어있음 — e2e 또는 verify-code 실행', command: 'node ./scripts/e2e.js' },
+          { icon: '🔄', title: 'progress-tracker 24h 정체 — task T-0001 status 갱신', command: 'leerness task update T-0001 --status completed' },
+          { icon: '🔄', title: 'progress-tracker 25h 정체 — task T-0001 status 갱신', command: 'leerness task update T-0001 --status completed' }
+        ];
+        writeUtf8(_nextActionQueuePath(root), JSON.stringify({ queue: legacy, at: new Date().toISOString() }, null, 2));
+        _enqueueNextActions(root, []);  // 새 제안이 없는 handoff도 legacy 큐를 고쳐야 한다.
+        _enqueueNextActions(root, [{ actionKey: 'stress-refresh', icon: '🧬', title: 'stress-v212 오래됨 — 새 stress test 작성 권장' }]);
+        const migrated = JSON.parse(read(_nextActionQueuePath(root))).queue;
+        const migratedStress = migrated.filter(a => a.icon === '🧬');
+        const migratedPlan = migrated.find(a => a.icon === '🎯');
+        const migratedDecision = migrated.find(a => a.icon === '💭');
+        const migratedEvidence = migrated.find(a => a.icon === '🧪');
+        const migratedProgress = migrated.find(a => a.icon === '🔄');
+        return generatedOk && migrated.length === 5 && migratedStress.length === 1
+          && migratedStress[0].title === 'stress-v212 오래됨 — 새 stress test 작성 권장'
+          && !Object.prototype.hasOwnProperty.call(migratedStress[0], 'command')
+          && migratedPlan.command === plan.command && migratedDecision.command === decision.command
+          && migratedEvidence.command === 'leerness verify-code .'
+          && migratedProgress.title === 'progress-tracker 정체 — task T-0001 상태 검토'
+          && migratedProgress.command === 'leerness task list --path .'
+          && migrated.every(a => typeof a.actionKey === 'string' && a.actionKey.length > 0);
+      } catch { return false; }
+      finally { try { fs.rmSync(arena, { recursive: true, force: true }); } catch {} }
+    } },
     { name: 'managed 파일 force 병합 (1.36.37, 1.9.441 드리프트 실측): writeIfSafe 가 --force 여도 managed 는 라인-diff 병합 — CLAUDE 커스텀 보존 (행위검사)', run: () => {
       const tmp = fs.mkdtempSync(path.join(os.tmpdir(), '__leerness_wif_'));
       let ok1 = false, ok2 = false, ok3 = false;
@@ -8393,8 +8464,10 @@ function anchorsCmd(root, sub) {
   const _draftM = '<!-- draft: leerness anchors';
   // 1.36.49 (codex 6차 #4): 헤딩 자체가 없는 파일도 gap — 종전 _sectionUnfilled 는 "섹션 없음→미플래그"(감지용 보수 기본)라
   //   ## Goal 이 아예 없는 plan.md 가 "작성됨"으로 보고되고 draft --apply 도 무동작이었다. apply 시 헤딩을 신설한다.
-  const briefGap = !!briefTxt && !briefTxt.includes(naM) && (_briefUnfilled(briefTxt) || _mdSectionBody(briefTxt, 'Purpose') == null || (_mdSectionBody(briefTxt, 'Purpose') || '').includes(_draftM));
-  const planGap = !!planTxt && !planTxt.includes(naM) && (_planGoalUnfilled(planTxt) || _mdSectionBody(planTxt, 'Goal') == null || (_mdSectionBody(planTxt, 'Goal') || '').includes(_draftM));
+  const _briefHasGap = txt => !!txt && !txt.includes(naM) && (_briefUnfilled(txt) || _mdSectionBody(txt, 'Purpose') == null || (_mdSectionBody(txt, 'Purpose') || '').includes(_draftM));
+  const _planHasGap = txt => !!txt && !txt.includes(naM) && (_planGoalUnfilled(txt) || _mdSectionBody(txt, 'Goal') == null || (_mdSectionBody(txt, 'Goal') || '').includes(_draftM));
+  const briefGap = _briefHasGap(briefTxt);
+  const planGap = _planHasGap(planTxt);
   if (!sub || sub === 'status') {
     if (json) { log(JSON.stringify({ briefUnfilled: briefGap, planGoalUnfilled: planGap }, null, 2)); return; }
     log(`# leerness anchors — 정체성앵커 상태`);
@@ -8416,16 +8489,31 @@ function anchorsCmd(root, sub) {
     const apply = has('--apply');
     const applied = [];
     if (briefGap && draft.purpose.length) {
-      if (apply) { writeUtf8(bf, _replaceMdSection(briefTxt, 'Purpose', draft.purpose, { appendIfMissing: true })); applied.push('project-brief.md#Purpose'); }
+      if (apply) {
+        // 1.36.169 (T-0108): 초안 계산 뒤 다른 세션이 채운 내용을 낡은 snapshot으로 덮지 않는다.
+        _withLock(bf, () => {
+          const current = exists(bf) ? read(bf) : '';
+          if (!_briefHasGap(current)) return;
+          writeUtf8(bf, _replaceMdSection(current, 'Purpose', draft.purpose, { appendIfMissing: true }));
+          applied.push('project-brief.md#Purpose');
+        });
+      }
     }
     if (planGap && draft.goal.length) {
-      if (apply) { writeUtf8(pf, _replaceMdSection(planTxt, 'Goal', draft.goal, { appendIfMissing: true })); applied.push('plan.md#Goal'); }
+      if (apply) {
+        _withPlanLock(root, () => {
+          const current = exists(pf) ? read(pf) : '';
+          if (!_planHasGap(current)) return;
+          writeUtf8(pf, _replaceMdSection(current, 'Goal', draft.goal, { appendIfMissing: true }));
+          applied.push('plan.md#Goal');
+        });
+      }
     }
     if (json) { log(JSON.stringify({ briefUnfilled: briefGap, planGoalUnfilled: planGap, draft: { purpose: draft.purpose, goal: draft.goal }, applied, dryRun: !apply }, null, 2)); return; }
     log(`# leerness anchors draft ${apply ? '(적용)' : '(dry-run — 적용: --apply)'}`);
-    if (briefGap) { log(`\n## project-brief Purpose ${apply ? '← 적용됨' : '초안'}`); draft.purpose.forEach(l => log('  ' + l)); }
+    if (briefGap) { log(`\n## project-brief Purpose ${apply ? (applied.includes('project-brief.md#Purpose') ? '← 적용됨' : '← 다른 세션 변경 감지로 건드리지 않음') : '초안'}`); draft.purpose.forEach(l => log('  ' + l)); }
     else log(`\n  ✓ project-brief Purpose 는 이미 작성됨 — 건드리지 않음`);
-    if (planGap) { log(`\n## plan Goal ${apply ? '← 적용됨' : '초안'}`); draft.goal.forEach(l => log('  ' + l)); }
+    if (planGap) { log(`\n## plan Goal ${apply ? (applied.includes('plan.md#Goal') ? '← 적용됨' : '← 다른 세션 변경 감지로 건드리지 않음') : '초안'}`); draft.goal.forEach(l => log('  ' + l)); }
     else log(`  ✓ plan Goal 은 이미 작성됨 — 건드리지 않음`);
     if (apply && applied.length) log(`\n✓ 적용: ${applied.join(', ')} (초안 표식 주석 포함 — 검토 후 주석 제거로 확정)`);
     return;
@@ -11312,12 +11400,14 @@ function _runPreWakeAudit(root) {
 
   // 6) next-action queue 잔여 (1.9.201)
   try {
-    const q = _loadNextActionQueue(root);
-    if (q && q.pending && q.pending.length > 0) {
+    // loader 계약은 { queue, at }이다. 과거 `pending`을 읽어 이 검사가 항상 무언
+    // no-op이었고, raw 큐 수를 쓰면 legacy 중복까지 과대 계수된다.
+    const q = _normalizedNextActionState(root);
+    if (q.queue.length > 0) {
       audit.findings.info.push({
         kind: 'next-action-pending',
-        count: q.pending.length,
-        detail: `${q.pending.length}건 next-action 대기 — leerness next-action take 로 즉시 처리`
+        count: q.queue.length,
+        detail: `${q.queue.length}건 next-action 대기 — leerness next-action take 로 즉시 처리`
       });
     }
   } catch {}
@@ -11820,7 +11910,11 @@ function _loadAutoResumePlan(root) {
     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) };
+    // 1.36.170: 1.36.169 이전에 저장한 plan도 resume/handoff에서 곧바로 현재 명령 계약으로
+    // 읽는다. 큐 list/take만 정규화하면 release 직후 저장된 plan이 legacy --filter,
+    // 자동 done 명령, 존재하지 않는 stress 파일 실행을 다시 노출할 수 있다.
+    const nextActions = _compactNextActionQueue(Array.isArray(j.nextActions) ? j.nextActions : []);
+    return { ...j, nextActions, ageMs, ageMin: Math.floor(ageMs / 60000), elapsedFromExpected: Math.floor(expiredMs / 60000) };
   } catch { return null; }
 }
 function _writeAutoResumePlan(root, plan) {
@@ -11843,7 +11937,7 @@ function _buildAutoResumePlan(root, opts) {
   // 현재 VERSION
   const currentVersion = VERSION;
   // next-action queue snapshot
-  const queueState = _loadNextActionQueue(root);
+  const queueState = _normalizedNextActionState(root);
   const queueTop = queueState.queue.length > 0 ? queueState.queue[queueState.queue.length - 1] : null;
   // memory surface counts
   const memorySurface = {
@@ -13686,24 +13780,102 @@ function _writeNextActionQueue(root, queue) {
     return false;
   }
 }
-// handoff 에서 제안된 next-action 들을 큐에 자동 저장 (중복 방지: 이미 있는 title 은 skip)
+// handoff 에서 제안된 next-action 들을 큐에 자동 저장 (중복 방지: 안정된 actionKey 는 갱신)
 // 1.36.108 (T-0097): 읽기~쓰기를 락으로 직렬화. 이 큐는 handoff 가 자동으로도 채우기 때문에
 //   사용자가 `next-action add` 하는 순간 handoff 가 겹칠 수 있다 — 실사용에서 가장 겹치기 쉬운 조합이다.
+function _normalizeSuggestedAction(action) {
+  const a = { ...(action || {}) };
+  // 1.36.169 (Codex 교차검수 P2): 예전 생성기는 존재하지 않는 --filter를 안내했다.
+  // 이미 큐에 들어간 항목도 다음 enqueue 때 실행 가능한 현재 CLI 문법으로 마이그레이션한다.
+  if (a.icon === '💭' && /^leerness decision list --filter\s+/.test(String(a.command || ''))) {
+    a.command = String(a.command).replace('decision list --filter', 'decision list --query');
+  }
+  if (a.icon === '🎯' && /^leerness plan list --filter\s+/.test(String(a.command || ''))) {
+    a.command = 'leerness plan list --path .';
+  }
+  const plan = String(a.title || '').match(/plan\.md milestone (M-\d{4,})/);
+  if (a.icon === '🎯' && plan) a.actionKey = `plan:${plan[1]}`;
+  const decision = String(a.command || '').match(/decision list --(?:query|filter)\s+"([^"]+)"/)
+    || String(a.title || '').match(/decisions\.md "([^"]+)"/);
+  if (a.icon === '💭' && decision) a.actionKey = `decision:${decision[1]}`;
+  const lesson = String(a.title || '').match(/lessons\.md 에 "([^"]+)" 관련/);
+  if (a.icon === '🛡' && lesson) a.actionKey = `lessons:${lesson[1]}`;
+  // 패키지를 적용한 일반 프로젝트에는 leerness 자체의 scripts/e2e.js가 없다. 이전 제안도
+  // 업그레이드 직후 list/take에서 바로 실행 가능한 공개 CLI로 바꾼다.
+  if (a.icon === '🧪' && (/review-evidence\.md/.test(String(a.title || ''))
+    || String(a.command || '') === 'node ./scripts/e2e.js')) {
+    a.command = 'leerness verify-code .';
+    a.actionKey = 'verification:evidence';
+  }
+  // 경과 시간이 제목에 들어가면 24h/25h가 서로 다른 큐 항목이 된다. 상태를 단정해 done으로
+  // 바꾸는 명령 대신 현재 task 목록을 확인하는 안전한 명령을 안내한다.
+  const stalled = String(a.title || '').match(/^progress-tracker(?: \d+h)? 정체 — task (T-\d{4,}) (?:status 갱신|상태 검토)$/);
+  if (a.icon === '🔄' && stalled) {
+    a.title = `progress-tracker 정체 — task ${stalled[1]} 상태 검토`;
+    a.command = 'leerness task list --path .';
+    a.actionKey = `task-status:${stalled[1]}`;
+  }
+  if (a.icon === '📝' && /버전 변동 task — CHANGELOG\.md \/ README\.md 갱신 확인/.test(String(a.title || ''))) {
+    a.actionKey = 'release-docs';
+  }
+  // 시간값이 제목에 들어가 매 handoff마다 같은 제안이 새 항목으로 쌓였고, command는 아직 만들지
+  // 않은 stress-v(N+1)를 실행해 항상 ENOENT였다. 작업 제안은 유지하되 안정된 제목으로 합치고
+  // 실행 명령은 싣지 않는다(next-action take가 이 제목으로 추적 task를 만든다).
+  const stress = String(a.title || '').match(/^stress-v(\d+) (?:마지막 갱신 \d+h 전 — |오래됨 — )새 stress test 작성 권장$/);
+  if (a.icon === '🧬' && stress) {
+    a.title = `stress-v${stress[1]} 오래됨 — 새 stress test 작성 권장`;
+    delete a.command;
+    a.actionKey = 'stress-refresh';
+  }
+  return a;
+}
+function _nextActionIdentity(action) {
+  const key = String(action && action.actionKey || '').trim();
+  if (key) return `key:${key}`;
+  return `title:${String(action && action.icon || '')}\u0000${String(action && action.title || '')}`;
+}
+function _compactNextActionQueue(queue) {
+  const compacted = [];
+  const seen = new Set();
+  // 최신 항목을 보존한다. stress 버전/경과 시간처럼 표시값이 달라도 actionKey가 같으면 하나다.
+  for (let i = (Array.isArray(queue) ? queue.length : 0) - 1; i >= 0; i--) {
+    const action = _normalizeSuggestedAction(queue[i]);
+    const identity = _nextActionIdentity(action);
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    compacted.unshift(action);
+  }
+  return compacted;
+}
+function _normalizedNextActionState(root) {
+  const state = _loadNextActionQueue(root);
+  return { ...state, queue: _compactNextActionQueue(state.queue) };
+}
 function _enqueueNextActions(root, actions) {
-  if (!Array.isArray(actions) || actions.length === 0) return 0;
+  if (!Array.isArray(actions)) return 0;
   return _withLock(_nextActionQueuePath(root), () => {
     const state = _loadNextActionQueue(root);
-    const existingTitles = new Set(state.queue.map(a => a.title));
+    const before = JSON.stringify(state.queue);
+    state.queue = _compactNextActionQueue(state.queue);
+    const existing = new Map(state.queue.map((a, i) => [_nextActionIdentity(a), i]));
     let added = 0;
-    for (const a of actions) {
-      if (existingTitles.has(a.title)) continue;
-      state.queue.push({ ...a, addedAt: new Date().toISOString() });
-      existingTitles.add(a.title);
-      added++;
+    for (const raw of actions) {
+      const a = _normalizeSuggestedAction(raw);
+      const identity = _nextActionIdentity(a);
+      if (existing.has(identity)) {
+        const i = existing.get(identity);
+        const previous = state.queue[i];
+        // 새 관측값(최신 stress 버전/결정 hit 수)은 같은 위치에서 갱신하되 최초 추가 시각은 보존한다.
+        state.queue[i] = { ...previous, ...a, addedAt: previous.addedAt || a.addedAt || new Date().toISOString() };
+      } else {
+        state.queue.push({ ...a, addedAt: new Date().toISOString() });
+        existing.set(identity, state.queue.length - 1);
+        added++;
+      }
     }
     // 최근 20개만 유지
     if (state.queue.length > 20) state.queue = state.queue.slice(-20);
-    if (added > 0) _writeNextActionQueue(root, state.queue);
+    if (added > 0 || before !== JSON.stringify(state.queue)) _writeNextActionQueue(root, state.queue);
     return added;
   });
 }
@@ -13711,8 +13883,9 @@ function _enqueueNextActions(root, actions) {
 // 1.9.201: next-action CLI 명령 — handoff 가 저장한 queue 에서 take/list/clear
 async function nextActionCmd(root, sub, ...rest) {
   root = absRoot(root);
-  const state = _loadNextActionQueue(root);
   if (!sub || sub === 'list') {
+    // 조회 자체는 쓰지 않지만, 업그레이드 직후에도 legacy 명령/중복을 노출하지 않는다.
+    const state = _normalizedNextActionState(root);
     if (has('--json')) { log(JSON.stringify(state, null, 2)); return; }
     log(`# leerness next-action list (1.9.201)`);
     if (state.queue.length === 0) {
@@ -13732,28 +13905,41 @@ async function nextActionCmd(root, sub, ...rest) {
     return;
   }
   if (sub === 'take') {
-    const n = rest[0] !== undefined ? Number(rest[0]) : state.queue.length - 1;
-    // 1.36.114 (검수 #3, 재현됨): 로더가 손상 파일을 **빈 큐**로 폴백해 "큐 비어있음 — handoff 먼저 실행" 이라고
-    //   오진했다. 사용자는 큐가 비었다고 믿고 handoff 를 다시 돌린다 — 원인(손상)은 끝까지 안 보인다.
-    //   읽기 자체는 종전대로 resilient 하게 두고, **판정 지점에서만** 빈 것과 손상된 것을 가른다.
-    if (state.queue.length === 0) { _assertStoreParsable(_nextActionQueuePath(root), 'next-action-queue'); fail('큐 비어있음 — handoff 먼저 실행'); return process.exit(1); }
-    if (isNaN(n) || n < 0 || n >= state.queue.length) { fail(`잘못된 index: ${n} (0~${state.queue.length - 1})`); return process.exit(1); }
-    const action = state.queue[n];
+    let taken;
+    try {
+      // 1.36.169 (Codex 재검수 P2): 선택을 락 밖에서 하고 제목으로 다시 찾으면, 그 사이 legacy
+      // 정규화가 제목을 바꿨을 때 task는 만들면서 큐에는 항목을 남겼다. 정규화·선택·제거를 한
+      // canonical queue transaction으로 묶고 index도 그 스냅샷에서 해석한다.
+      taken = _withLock(_nextActionQueuePath(root), () => {
+        const fresh = _loadNextActionQueue(root);
+        const queue = _compactNextActionQueue(fresh.queue);
+        // 1.36.114: 로더의 손상→빈 배열 fallback과 실제 빈 큐를 판정 지점에서 구분한다.
+        if (queue.length === 0) {
+          _assertStoreParsable(_nextActionQueuePath(root), 'next-action-queue');
+          return { error: 'empty' };
+        }
+        const n = rest[0] !== undefined ? Number(rest[0]) : queue.length - 1;
+        if (isNaN(n) || n < 0 || n >= queue.length) return { error: 'index', n, max: queue.length - 1 };
+        const action = queue[n];
+        queue.splice(n, 1);
+        if (!_writeNextActionQueue(root, queue)) throw new Error('next-action 큐 저장 실패 — task를 만들지 않습니다');
+        return { action, n };
+      });
+    } catch (e) {
+      if (e && e.code === 'E_STORE_CORRUPT') throw e;
+      fail(`next-action take 실패: ${_lineSafe(e && e.message ? e.message : e)}`);
+      process.exitCode = 1;
+      return;
+    }
+    if (taken.error === 'empty') { fail('큐 비어있음 — handoff 먼저 실행'); process.exitCode = 1; return; }
+    if (taken.error === 'index') { fail(`잘못된 index: ${taken.n} (0~${taken.max})`); process.exitCode = 1; return; }
+    const { action, n } = taken;
     log(`# leerness next-action take [${n}] (1.9.201)`);
     log(`  ${action.icon || '•'} ${_lineSafe(action.title)}`);
     if (action.command) log(`  \`${_lineSafe(action.command)}\``);
     // task add 자동 호출
     try {
       const taskTitle = action.title.replace(/^[^\w가-힣]+/, '').slice(0, 100);
-      // 큐에서 제거 → write
-      // 1.36.108 (T-0097): 락 안에서 **다시 읽고** 제거한다. 함수 머리에서 읽은 state 로 지우면
-      //   그 사이에 handoff 가 큐에 넣은 항목이 통째로 사라진다(handoff 는 자동으로 이 큐를 채운다).
-      _withLock(_nextActionQueuePath(root), () => {
-        const fresh = _loadNextActionQueue(root);
-        const idx = fresh.queue.findIndex(a => a && a.title === action.title);
-        if (idx >= 0) fresh.queue.splice(idx, 1);
-        _writeNextActionQueue(root, fresh.queue);
-      });
       // leerness task add 호출
       const taskResult = cp.spawnSync(process.execPath, [__filename, 'task', 'add', taskTitle, '--path', root], { encoding: 'utf8', timeout: 8000, env: { ...process.env, LEERNESS_INTERNAL: '1' } });
       if (taskResult.status === 0) {
@@ -13773,8 +13959,12 @@ async function nextActionCmd(root, sub, ...rest) {
     return;
   }
   if (sub === 'clear') {
-    _writeNextActionQueue(root, []);
-    ok(`next-action 큐 초기화 (${state.queue.length}건 제거)`);
+    const removed = _withLock(_nextActionQueuePath(root), () => {
+      const fresh = _loadNextActionQueue(root);
+      if (!_writeNextActionQueue(root, [])) throw new Error('next-action 큐 저장 실패');
+      return fresh.queue.length;
+    });
+    ok(`next-action 큐 초기화 (${removed}건 제거)`);
     return;
   }
   if (sub === 'add') {
@@ -13811,7 +14001,7 @@ function _suggestNextActions(root, latestRow, keyword) {
       const blocks = lt.split(/\n### /);
       const hits = blocks.filter(b => fuzzyRe.test(b) && /(실패|fail|롤백|버그|incomplete)/i.test(b));
       if (hits.length > 0) {
-        actions.push({ icon: '🛡', title: `과거 실패 회피 — lessons.md 에 "${keyword}" 관련 ${hits.length}건`, command: `leerness lessons --auto --path .` });
+        actions.push({ actionKey: `lessons:${keyword}`, icon: '🛡', title: `과거 실패 회피 — lessons.md 에 "${keyword}" 관련 ${hits.length}건`, command: `leerness lessons --auto --path .` });
       }
     }
   } catch {}
@@ -13823,7 +14013,7 @@ function _suggestNextActions(root, latestRow, keyword) {
       const milestones = (pt.match(/^### (M-\d{4,})\..*$/gm) || []).filter(l => fuzzyRe.test(l));
       if (milestones.length > 0) {
         const m = milestones[0].match(/M-\d{4,}/);
-        if (m) actions.push({ icon: '🎯', title: `plan.md milestone ${m[0]} 검증 — "${keyword}" 관련`, command: `leerness plan list --filter "${keyword}"` });
+        if (m) actions.push({ actionKey: `plan:${m[0]}`, icon: '🎯', title: `plan.md milestone ${m[0]} 검증 — "${keyword}" 관련`, command: 'leerness plan list --path .' });
       }
     }
   } catch {}
@@ -13835,7 +14025,7 @@ function _suggestNextActions(root, latestRow, keyword) {
       const blocks = _extractDecisionBlocks(dt);
       const hits = blocks.filter(b => fuzzyRe.test(b));
       if (hits.length > 0) {
-        actions.push({ icon: '💭', title: `decisions.md "${keyword}" 관련 결정 ${hits.length}건 영향 확인`, command: `leerness decision list --filter "${keyword}"` });
+        actions.push({ actionKey: `decision:${keyword}`, icon: '💭', title: `decisions.md "${keyword}" 관련 결정 ${hits.length}건 영향 확인`, command: `leerness decision list --query "${keyword}"` });
       }
     }
   } catch {}
@@ -13843,7 +14033,7 @@ function _suggestNextActions(root, latestRow, keyword) {
   // 4) review-evidence.md 부재 → e2e
   try {
     if (!exists(evidencePath(root)) || fs.statSync(evidencePath(root)).size < 100) {
-      actions.push({ icon: '🧪', title: `review-evidence.md 비어있음 — e2e 또는 verify-code 실행`, command: `node ./scripts/e2e.js` });
+      actions.push({ actionKey: 'verification:evidence', icon: '🧪', title: `review-evidence.md 비어있음 — verify-code 실행`, command: `leerness verify-code .` });
     }
   } catch {}
 
@@ -13853,7 +14043,7 @@ function _suggestNextActions(root, latestRow, keyword) {
     if (exists(pp)) {
       const ageHours = Math.floor((Date.now() - fs.statSync(pp).mtimeMs) / 3600000);
       if (ageHours >= 24 && latestRow.id) {
-        actions.push({ icon: '🔄', title: `progress-tracker ${ageHours}h 정체 — task ${latestRow.id} status 갱신`, command: `leerness task update ${latestRow.id} --status completed` });
+        actions.push({ actionKey: `task-status:${latestRow.id}`, icon: '🔄', title: `progress-tracker 정체 — task ${latestRow.id} 상태 검토`, command: `leerness task list --path .` });
       }
     }
   } catch {}
@@ -13861,7 +14051,7 @@ function _suggestNextActions(root, latestRow, keyword) {
   // 6) CHANGELOG / README 버전 일치 확인 (1.9.X bump 후 자주 누락되는 단계)
   try {
     if (/(\d\.\d\.\d+)/.test(taskText) || /(bump|version|release)/i.test(taskText)) {
-      actions.push({ icon: '📝', title: `버전 변동 task — CHANGELOG.md / README.md 갱신 확인`, command: `leerness whats-new .` });
+      actions.push({ actionKey: 'release-docs', icon: '📝', title: `버전 변동 task — CHANGELOG.md / README.md 갱신 확인`, command: `leerness whats-new .` });
     }
   } catch {}
 
@@ -13877,16 +14067,16 @@ function _suggestNextActions(root, latestRow, keyword) {
         const latestFile = path.join(stressDir, `stress-v${latest}.js`);
         const ageHours = Math.floor((Date.now() - fs.statSync(latestFile).mtimeMs) / 3600000);
         if (ageHours >= 24 && /(bump|version|보강|추가|기능)/.test(taskText)) {
-          actions.push({ icon: '🧬', title: `stress-v${latest} 마지막 갱신 ${ageHours}h 전 — 새 stress test 작성 권장`, command: `node _apps/leerness-stress/bin/stress-v${latest+1}.js` });
+          actions.push({ actionKey: 'stress-refresh', icon: '🧬', title: `stress-v${latest} 오래됨 — 새 stress test 작성 권장` });
         }
       }
     }
   } catch {}
 
-  // 중복 제거 (icon+title 기준) + top 3
+  // 중복 제거 (시간/버전과 무관한 actionKey 기준) + top 3
   const seen = new Set();
   return actions.filter(a => {
-    const key = a.icon + a.title.slice(0, 30);
+    const key = _nextActionIdentity(a);
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
@@ -14207,10 +14397,20 @@ function upsertProgress(root, row) {
 }
 
 function planShow(root) { const p = planPath(root); const has_ = exists(p); const content = has_ ? read(p) : ''; if (has('--json')) { const milestones = (content.match(/^### (M-\d{4,})\b.*$/gm) || []).map(l => l.replace(/^###\s*/, '').trim()); log(JSON.stringify({ exists: has_, milestones, raw: content }, null, 2)); return; } log(has_ ? content : 'plan.md not found'); }  // 1.9.428 (UR-0128): plan show --json 구조화
-// plan.md와 progress-tracker.md를 함께 다루는 모든 RMW의 공통 키. plan restore도 이 키를 써야
-// plan add/drop/remove과 같은 스냅샷을 본다 (1.36.152/T-0115).
-function _withPlanTransaction(root, fn) { return _withLock(progressPath(root), fn); }
-function planInit(root) { const goal = arg('--goal', ''); if (!exists(planPath(root))) return install(root); append(planPath(root), `\n## User Goal\n- ${goal || '사용자 목적을 작성하세요.'}\n`); ok('plan goal appended'); }
+// plan.md 단독 RMW의 canonical lock. plan/progress를 함께 바꾸는 경로는 항상
+// progress → plan 순서로 잡아 역순 교착과 서로 다른 락 아래의 lost-update를 함께 막는다.
+function _withPlanLock(root, fn) { return _withLock(planPath(root), fn); }
+function _withPlanTransaction(root, fn) {
+  return _withLock(progressPath(root), () => _withPlanLock(root, fn));
+}
+function planInit(root) {
+  const goal = arg('--goal', '');
+  if (!exists(planPath(root))) return install(root);
+  // 1.36.169 (T-0108): plan add/drop/remove/restore와 같은 plan.md 락을 쓴다.
+  // 종전 append는 성공했어도 동시에 진행된 plan remove의 낡은 전체파일 rename에 지워졌다.
+  _withPlanLock(root, () => append(planPath(root), `\n## User Goal\n- ${goal || '사용자 목적을 작성하세요.'}\n`));
+  ok('plan goal appended');
+}
 // 1.9.119: plan list — plan.md 의 모든 milestone (M-XXXX) 조회 (CLI + --json + MCP)
 function planListCmd(root, opts = {}) {
   root = absRoot(root);
@@ -14895,10 +15095,11 @@ function memoryRestoreCmd(root, surface, target) {
                     : surface === 'lessons'   ? lessonsPath(root)
                     : planPath(root);
   // 1.36.152 (T-0115): restore는 active canonical store와 archive를 함께 RMW한다.
-  // decisions/lessons는 add/drop의 JSON 키, plan은 plan add/drop의 progress 키를 공유해야 한다.
+  // 1.36.169 (T-0108): plan 전용 경로는 progress의 대리 락이 아니라 plan.md canonical 락을 쓴다.
+  // plan+progress 동시 변경은 _withPlanTransaction이 progress → plan 순서로 같은 락에 합류한다.
   const memoryLockPath = surface === 'decisions' ? decisionsJsonPath(root)
                        : surface === 'lessons'   ? lessonsJsonPath(root)
-                       : progressPath(root);
+                       : planPath(root);
   const restoredCount = _withLock(memoryLockPath, () => {
   if (!exists(archivePath)) return fail(`${surface}.archive.md 없음 — 복원할 항목 없음`);
   // 1.36.76 (9차 헌트 #3 P1) → (검수 #2): 잘린/깨진 UTF-8 아카이브가 손상 데이터를 active 로 유입시키던 것.
@@ -15378,7 +15579,7 @@ function verify(root) {
 //   harness 는 deps(VERSION·canonical 메모리 함수·카탈로그·compareVer·harness 경로)를 1회 구성해 위임(thin wrapper). 호출부/동작 무변경.
 const _migrate = require('../lib/migrate');
 function _migrateDeps() {
-  return { VERSION, compareVer, REQUIRED_WORKSPACE_FILES, decisionsPath, decisionsJsonPath, lessonsPath, lessonsJsonPath, _loadDecisions, _saveDecisions, _loadLessons, _saveLessons, harnessPath: __filename };
+  return { VERSION, compareVer, REQUIRED_WORKSPACE_FILES, decisionsPath, decisionsJsonPath, lessonsPath, lessonsJsonPath, _loadDecisions, _saveDecisions, _loadLessons, _saveLessons, _withLock, harnessPath: __filename };
 }
 function migrateAuditCmd(root, opts = {}) { return _migrate.migrateAuditCmd(root, opts, _migrateDeps()); }
 function migrateApplyCmd(root, opts = {}) { return _migrate.migrateApplyCmd(root, opts, _migrateDeps()); }
@@ -17170,6 +17371,8 @@ function handoff(root) {
           if (!has('--no-next-actions') && !has('--quiet') && process.env.LEERNESS_NO_NEXT_ACTIONS !== '1') {
             try {
               const actions = _suggestNextActions(root, latestRow, keyword);
+              // 새 제안이 없어도 legacy queue의 잘못된 명령/시간가변 중복은 정규화한다.
+              const added = _enqueueNextActions(root, actions);
               if (actions.length > 0) {
                 const isTty = process.stdout && process.stdout.isTTY;
                 const grn = s => isTty ? `\x1b[32m${s}\x1b[0m` : s;
@@ -17183,10 +17386,7 @@ function handoff(root) {
                   }
                 }
                 // 1.9.201: queue 자동 저장 — `leerness next-action take` 로 즉시 task add 가능 (토글과 무관: 상태다)
-                try {
-                  const added = _enqueueNextActions(root, actions);
-                  if (added > 0 && _showAdvice) log(dim(`  → 즉시 task add: leerness next-action take  (큐 +${added}건 저장됨, 1.9.201)`));
-                } catch {}
+                if (added > 0 && _showAdvice) log(dim(`  → 즉시 task add: leerness next-action take  (큐 +${added}건 저장됨, 1.9.201)`));
                 if (_showAdvice) { log(dim(`  → 직접 입력: leerness next-action add "<text>"`)); log(''); }
               }
             } catch {}
@@ -22581,6 +22781,15 @@ function captureProjectState(root) {
 
 function verifyRules(root) {
   root = absRoot(root);
+  // 활성 룰이 없으면 읽기 전용으로 끝낸다. cache 디렉터리를 잠금 부작용만으로 만들지 않는다.
+  if (!readRules(root).some(r => r.status === 'active')) return [];
+  // 1.36.169 (T-0108): baseline read → project capture → rule merge → baseline write를 한
+  // cache transaction으로 직렬화한다. 종전에는 오래된 verify가 늦게 끝나 최신 baseline을
+  // 되돌려 다음 세션이 이미 수행한 version/changelog 변경을 다시 pass로 오인할 수 있었다.
+  return _withLock(rulesCachePath(root), () => _verifyRulesLocked(root));
+}
+
+function _verifyRulesLocked(root) {
   const rules = readRules(root);
   const active = rules.filter(r => r.status === 'active');
   if (!active.length) return [];
@@ -27103,7 +27312,8 @@ function contextCmd(root, opts = {}) {
   const _decs = _loadDecisions(root);
   const decisionCount = _decs.length;
   const recentDecisions = _decs.slice(-3).reverse().map(d => ({ date: d.date || null, title: (d.title || '').slice(0, 100) }));
-  const queueState = _loadNextActionQueue(root);
+  // 외부 에이전트 context도 next-action list/take와 같은 정규화 계약을 공유한다.
+  const queueState = _normalizedNextActionState(root);
   const nextActions = (queueState.queue || []).slice(-3).reverse().map(a => ({ title: a.title, command: a.command || null }));
   const memory = {
     tasksInProgress: rows.filter(r => r.status === 'in-progress').length,

package/lib/migrate.js

@@ -38,19 +38,41 @@ function migrateAuditCmd(root, opts = {}, deps = {}) {
 // UR-0075 Phase C (1.9.357): migrate apply — audit가 찾은 '안전 항목'(canonical 백필)만 비파괴 적용.
 // 기본 dry-run(변경 없음) · --yes 로 실제 적용. version-drift/missing-file 은 apply 범위 외(수동 안내).
 function migrateApplyCmd(root, opts = {}, deps = {}) {
-  const { VERSION, compareVer, REQUIRED_WORKSPACE_FILES, decisionsPath, decisionsJsonPath, lessonsPath, lessonsJsonPath, _loadDecisions, _saveDecisions, _loadLessons, _saveLessons } = deps;
+  const { VERSION, compareVer, REQUIRED_WORKSPACE_FILES, decisionsPath, decisionsJsonPath, lessonsPath, lessonsJsonPath, _loadDecisions, _saveDecisions, _loadLessons, _saveLessons, _withLock } = deps;
   root = absRoot(root);
   const apply = !!opts.yes;
+  if (apply && typeof _withLock !== 'function') throw new Error('migrate apply requires the canonical store lock dependency');
+  const withLock = typeof _withLock === 'function' ? _withLock : (_target, fn) => fn();
   const applied = [];   // 안전하게 적용 가능(또는 dry-run 예정): canonical 백필
   const skipped = [];   // apply 범위 외: 수동 조치 필요
   // canonical-pending: MD 항목 존재 + JSON 부재 → load(MD 백필)→save(canonical JSON + MD 정규화). idempotent(UR-0053).
   if (exists(decisionsPath(root)) && !exists(decisionsJsonPath(root)) && _loadDecisions(root).length > 0) {
-    if (apply) _saveDecisions(root, _loadDecisions(root));
-    applied.push({ kind: 'canonical-backfill', detail: 'decisions.md → decisions.json' });
+    let changed = !apply;
+    if (apply) {
+      // 1.36.169 (T-0108): exists/load/save 전체가 decision add/drop/restore와 같은 락 안이어야 한다.
+      // 바깥에서 읽은 legacy snapshot을 락 획득 뒤 쓰면 그 사이 추가된 결정을 지울 수 있다.
+      changed = withLock(decisionsJsonPath(root), () => {
+        if (!exists(decisionsPath(root)) || exists(decisionsJsonPath(root))) return false;
+        const current = _loadDecisions(root);
+        if (!current.length) return false;
+        _saveDecisions(root, current);
+        return true;
+      });
+    }
+    if (changed) applied.push({ kind: 'canonical-backfill', detail: 'decisions.md → decisions.json' });
   }
   if (exists(lessonsPath(root)) && !exists(lessonsJsonPath(root)) && _loadLessons(root).length > 0) {
-    if (apply) _saveLessons(root, _loadLessons(root));
-    applied.push({ kind: 'canonical-backfill', detail: 'lessons.md → lessons.json' });
+    let changed = !apply;
+    if (apply) {
+      changed = withLock(lessonsJsonPath(root), () => {
+        if (!exists(lessonsPath(root)) || exists(lessonsJsonPath(root))) return false;
+        const current = _loadLessons(root);
+        if (!current.length) return false;
+        _saveLessons(root, current);
+        return true;
+      });
+    }
+    if (changed) applied.push({ kind: 'canonical-backfill', detail: 'lessons.md → lessons.json' });
   }
   // version-drift / 누락 파일 — apply 가 안전하게 in-place 처리 불가(npm 재설치/재초기화 필요) → 수동 안내.
   const hvPath = path.join(root, '.leerness', 'HARNESS_VERSION');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.168",
+  "version": "1.36.170",
   "description": "The AI-coding operations layer that makes \"done\" require evidence — persistent memory, evidence-gated completion checks, and clean handoffs for any AI agent (Claude Code, Codex, Cursor). State lives as plain files in your repo. CLI + MCP, 0 runtime dependencies.",
   "keywords": [
     "leerness",
@@ -50,7 +50,8 @@
   "scripts": {
     "test": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js && npm run test:commands && npm run test:installed && node ./scripts/e2e.js",
     "test:core": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js",
-    "test:commands": "node ./scripts/command-flags-probe.js && node ./scripts/claims-baseline-probe.js && node ./scripts/claims-baseline-concurrency-probe.js && node ./scripts/e2e-command-surface.js",
+    "test:commands": "node ./scripts/command-flags-probe.js && node ./scripts/next-action-suggestion-probe.js && node ./scripts/claims-baseline-probe.js && node ./scripts/claims-baseline-concurrency-probe.js && node ./scripts/e2e-command-surface.js",
+    "test:next-actions": "node ./scripts/next-action-suggestion-probe.js",
     "test:installed": "node ./scripts/installed-cleanroom-probe.js",
     "test:handoff": "node ./scripts/handoff-readonly-probe.js",
     "test:fast": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/smoke.js",

package/scripts/e2e-concurrency.js

@@ -44,8 +44,11 @@ function spawn(d, args, stallTarget) {
 }
 
 function waitForStall(d, target) {
-  const re = new RegExp('^' + target.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\.tmp-');
-  const hd = path.join(d, '.leerness');
+  const normalized = target.replace(/\\/g, '/');
+  const targetDir = path.dirname(normalized) === '.' ? '' : path.dirname(normalized);
+  const targetName = path.basename(normalized);
+  const re = new RegExp('^' + targetName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\.tmp-');
+  const hd = path.join(d, '.leerness', targetDir);
   for (let i = 0; i < 800; i++) {
     try { if (fs.readdirSync(hd).some(name => re.test(name))) return true; } catch {}
     nap(10);
@@ -60,6 +63,7 @@ async function race(name, config) {
     if (config.seed) config.seed(d);
     const first = spawn(d, config.first, config.stallTarget);
     const stalled = waitForStall(d, config.stallTarget);
+    if (config.beforeSecond) config.beforeSecond(d);
     const second = spawn(d, config.second);
     const exits = await Promise.all([wait(first), wait(second)]);
     const inspected = config.inspect(d);
@@ -132,6 +136,73 @@ async function race(name, config) {
       return { archived: plan.includes('archived'), survivor: plan.includes('survivor'), preserved: plan.includes('archived') && plan.includes('survivor') };
     }
   }));
+  results.push(await race('plan-init-vs-remove', {
+    stallTarget: 'plan.md',
+    seed: d => run(d, ['plan', 'add', 'victim']),
+    first: ['plan', 'remove', 'victim'],
+    second: ['plan', 'init', '--goal', 'survivor-goal'],
+    inspect: d => {
+      const plan = fs.readFileSync(path.join(d, '.leerness', 'plan.md'), 'utf8');
+      return {
+        victimRemoved: !plan.includes('victim'),
+        survivorPreserved: plan.includes('survivor-goal'),
+        preserved: !plan.includes('victim') && plan.includes('survivor-goal')
+      };
+    }
+  }));
+  results.push(await race('anchors-plan-vs-plan-add', {
+    stallTarget: 'plan.md',
+    seed: d => fs.writeFileSync(path.join(d, 'package.json'), JSON.stringify({ name: 'probe', version: '1.0.0', description: 'coordination probe' })),
+    first: ['anchors', 'draft', '--apply'],
+    second: ['plan', 'add', 'survivor-milestone'],
+    inspect: d => {
+      const plan = fs.readFileSync(path.join(d, '.leerness', 'plan.md'), 'utf8');
+      return { survivorPreserved: plan.includes('survivor-milestone'), preserved: plan.includes('survivor-milestone') };
+    }
+  }));
+  results.push(await race('migrate-decisions-vs-add', {
+    stallTarget: 'decisions.json',
+    seed: d => {
+      run(d, ['decision', 'add', 'legacy-decision']);
+      fs.unlinkSync(path.join(d, '.leerness', 'decisions.json'));
+    },
+    first: ['migrate', 'apply', '--yes'],
+    second: ['decision', 'add', 'survivor-decision'],
+    inspect: d => {
+      const titles = JSON.parse(fs.readFileSync(path.join(d, '.leerness', 'decisions.json'), 'utf8')).map(item => item.title);
+      return { titles, preserved: titles.includes('legacy-decision') && titles.includes('survivor-decision') };
+    }
+  }));
+  results.push(await race('migrate-lessons-vs-save', {
+    stallTarget: 'lessons.json',
+    seed: d => {
+      run(d, ['lesson', 'save', 'legacy-lesson']);
+      fs.unlinkSync(path.join(d, '.leerness', 'lessons.json'));
+    },
+    first: ['migrate', 'apply', '--yes'],
+    second: ['lesson', 'save', 'survivor-lesson'],
+    inspect: d => {
+      const texts = JSON.parse(fs.readFileSync(path.join(d, '.leerness', 'lessons.json'), 'utf8')).map(item => item.text);
+      return { texts, preserved: texts.includes('legacy-lesson') && texts.includes('survivor-lesson') };
+    }
+  }));
+  results.push(await race('rule-cache-verify-vs-verify', {
+    stallTarget: 'cache/rule-state.json',
+    seed: d => {
+      const pkg = version => fs.writeFileSync(path.join(d, 'package.json'), JSON.stringify({ name: 'probe', version }));
+      pkg('1.0.0');
+      run(d, ['rule', 'add', 'version bump required', '--trigger', 'every-update']);
+      run(d, ['rule', 'verify']);
+      pkg('1.0.1');
+    },
+    beforeSecond: d => fs.writeFileSync(path.join(d, 'package.json'), JSON.stringify({ name: 'probe', version: '1.0.2' })),
+    first: ['rule', 'verify'],
+    second: ['rule', 'verify'],
+    inspect: d => {
+      const cached = JSON.parse(fs.readFileSync(path.join(d, '.leerness', 'cache', 'rule-state.json'), 'utf8'));
+      return { cachedVersion: cached.packageVersion, preserved: cached.packageVersion === '1.0.2' };
+    }
+  }));
   const ok = results.every(result => result.ok);
   console.log(JSON.stringify({ ok, results }));
   if (!ok) process.exitCode = 1;

package/scripts/e2e.js

@@ -10688,7 +10688,10 @@ total++;
     if (syncUrl) CASES.push(['provider sync', ['provider', 'sync', syncUrl]]);
     dbg.syncCovered = !!syncUrl;
     const offenders = [], failedCmds = [];
-    const keysByFile = {};   // 파일 → 그 파일을 쓸 때 쥐고 있던 락 키 집합(명령을 가로질러 모은다)
+    // 파일 → 모든 쓰기에서 공통으로 쥔 락 키의 교집합. 보조 락이 더해져도 canonical 락이
+    // 공통이면 상호배제는 유지된다(예: progress → plan 순서의 2파일 transaction).
+    const commonKeysByFile = {};
+    const keySetsByFile = {};
     let lockedSeen = 0, rows = 0;
     for (const [label, argv, seed] of CASES) {
       const d = path.join(sb, label.replace(/[^a-z0-9]+/gi, '_'));
@@ -10713,8 +10716,10 @@ total++;
         byFile[l.file] = (l.file in byFile ? byFile[l.file] : true) && l.locked;
         // 어느 락 키로 지켰는지 모은다 — 파일 자신의 락이 아니면 다른 명령과 서로 배제되지 않는다.
         if (l.locked && !DERIVED.test(l.file) && !EXEMPT[l.file]) {
-          (keysByFile[l.file] = keysByFile[l.file] || new Set());
-          for (const k of (l.heldOn || [])) keysByFile[l.file].add(k);
+          const held = new Set(l.heldOn || []);
+          (keySetsByFile[l.file] = keySetsByFile[l.file] || new Set()).add([...held].sort().join(' + ') || '(none)');
+          if (!commonKeysByFile[l.file]) commonKeysByFile[l.file] = held;
+          else commonKeysByFile[l.file] = new Set([...commonKeysByFile[l.file]].filter(k => held.has(k)));
         }
       }
       for (const [f, lockedOk] of Object.entries(byFile)) {
@@ -10728,11 +10733,12 @@ total++;
     // codex 검수 P2(재현됨): "락을 하나라도 쥐었나" 는 너무 약하다. 상호배제는 **같은 키**를 쥘 때만 성립한다.
     //   session close 는 session-handoff.md.lock 을 쥔 채 current-state.md 를 썼고 audit --fix 는
     //   current-state.md.lock 을 쥐었다 — 둘 다 '락 보유' 인 채로 audit 의 갱신이 덮였다.
-    //   올바른 불변식은 "자기 이름의 락" 이 아니라 **"그 파일의 모든 쓰기가 같은 키를 쓴다"** 이다.
-    //   (decisions.md 를 decisions.json.lock 아래에서 쓰는 것은 정상 — 그 파일을 쓰는 유일한 경로가 거기뿐이면.)
+    //   올바른 불변식은 "자기 이름의 락" 이 아니라 **"그 파일의 모든 쓰기가 적어도 한 canonical 키를 공유한다"** 이다.
+    //   (decisions.md 를 decisions.json.lock 아래에서 쓰는 것은 정상이고, progress→plan transaction처럼
+    //   보조 락이 더해진 쓰기도 공통 plan.md.lock/progress-tracker.md.lock가 남으면 정상이다.)
     const wrongKey = [];
-    for (const [f, keys] of Object.entries(keysByFile)) {
-      if (keys.size !== 1) wrongKey.push(f + ' ← 서로 다른 락 ' + [...keys].sort().join(' / '));
+    for (const [f, common] of Object.entries(commonKeysByFile)) {
+      if (common.size === 0) wrongKey.push(f + ' ← 공통 락 없음 (' + [...keySetsByFile[f]].sort().join(' / ') + ')');
     }
     dbg.wrongKey = wrongKey;
     dbg.offenders = offenders;
@@ -10746,7 +10752,7 @@ total++;
     ok = dbg.probeAlive && dbg.coverage && dbg.syncCovered && offenders.length === 0 && wrongKey.length === 0;
     try { srv.kill(); } catch {}
   } catch (e) { dbg.err = String(e && e.message).slice(0, 200); } finally { try { fs.rmSync(sb, { recursive: true, force: true }); } catch {} }
-  console.log(ok ? `✓ L(1.36.108/T-0097) 사용자 상태 쓰기 ${dbg.rows}건 전부 락 안 + 파일당 락 키 일관 (락 관측 ${dbg.lockedSeen}건 = 계측 살아있음 · 명령 실패 0)`
+  console.log(ok ? `✓ L(1.36.108/T-0097, 1.36.169/T-0108) 사용자 상태 쓰기 ${dbg.rows}건 전부 락 안 + 파일별 canonical 락 교집합 존재 (락 관측 ${dbg.lockedSeen}건 = 계측 살아있음 · 명령 실패 0)`
     : '✗ 1.36.108 락 불변식 위반 ' + JSON.stringify(dbg));
   if (!ok) failed++;
 }
@@ -15527,8 +15533,8 @@ total++;
 }
 
 total++;
-// AO(1.36.152/T-0115) — write 시점의 락 관측만으로는 "읽은 사본도 락 안인가"를 증명할 수 없다.
-// 첫 프로세스의 최종 rename을 강제로 멈추고 두 번째 쓰기를 붙여, 서로 다른 RMW 여섯 쌍이 모두 생존하는지 확인한다.
+// AO(1.36.152/T-0115, 1.36.169/T-0108 확장) — write 시점의 락 관측만으로는 "읽은 사본도 락 안인가"를 증명할 수 없다.
+// 첫 프로세스의 최종 rename을 강제로 멈추고 두 번째 쓰기를 붙여, 서로 다른 RMW 11쌍이 모두 생존하는지 확인한다.
 {
   let ok = false; const dbg = {};
   try {
@@ -15543,9 +15549,9 @@ total++;
     dbg.exit = race.status; dbg.report = report;
     if (!report) dbg.stderr = String(race.stderr || '').slice(0, 500);
     ok = race.status === 0 && !!report && report.ok === true
-      && Array.isArray(report.results) && report.results.length === 6 && report.results.every(r => r.ok === true);
+      && Array.isArray(report.results) && report.results.length === 11 && report.results.every(r => r.ok === true);
   } catch (e) { dbg.err = String(e && e.message || e).slice(0, 200); }
-  console.log(ok ? '✓ AO(1.36.152/T-0115) 지연 경쟁 6쌍 모두 exit 0 + 양쪽 기록 보존'
+  console.log(ok ? '✓ AO(1.36.152/T-0115, 1.36.169/T-0108) 지연 경쟁 11쌍 모두 exit 0 + 양쪽 기록 보존'
     : '✗ 1.36.152 동시 RMW 회귀 ' + JSON.stringify(dbg));
   if (!ok) failed++;
 }

package/scripts/next-action-suggestion-probe.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const cp = require('child_process');
+
+const cliPath = path.join(__dirname, '..', 'bin', 'leerness.js');
+const source = fs.readFileSync(cliPath, 'utf8');
+const start = source.indexOf('function _suggestNextActions(');
+const end = source.indexOf('function _autoInstallQueryFromHandoff(', start);
+if (start < 0 || end <= start) {
+  console.error('next-action-suggestion-probe: generator boundaries not found');
+  process.exit(1);
+}
+
+const generator = source.slice(start, end);
+const resumeBuildStart = source.indexOf('function _buildAutoResumePlan(');
+const resumeBuildEnd = source.indexOf('function resumeCmd(', resumeBuildStart);
+const resumeBuilder = resumeBuildStart >= 0 && resumeBuildEnd > resumeBuildStart
+  ? source.slice(resumeBuildStart, resumeBuildEnd)
+  : '';
+const offenders = [];
+const run = (args, cwd) => cp.spawnSync(process.execPath, [cliPath, ...args], {
+  cwd,
+  encoding: 'utf8',
+  timeout: 15000,
+  env: { ...process.env, LEERNESS_OFFLINE: '1', LEERNESS_NO_PROMPT: '1' }
+});
+const writeQueue = (root, queue) => {
+  const dir = path.join(root, '.leerness');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'next-action-queue.json'), JSON.stringify({ queue, at: new Date().toISOString() }, null, 2), 'utf8');
+};
+const commandArgs = (command) => (String(command).match(/"[^"]*"|\S+/g) || []).map(x => x.startsWith('"') ? x.slice(1, -1) : x);
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+const hasLegacySuggestion = actions => (Array.isArray(actions) ? actions : []).some(a =>
+  /\s--filter(?:\s|$)/.test(String(a.command || ''))
+  || String(a.command || '').includes('./scripts/e2e.js')
+  || /task update .* --status completed/.test(String(a.command || ''))
+  || (/^progress-tracker \d+h 정체/.test(String(a.title || '')))
+  || (/^node _apps\/leerness-stress/.test(String(a.command || '')))
+);
+
+async function reproduceTakeMigrationRace(root) {
+  const queuePath = path.join(root, '.leerness', 'next-action-queue.json');
+  const lockPath = queuePath + '.lock';
+  const oldAction = {
+    icon: '🔄',
+    title: 'progress-tracker 24h 정체 — task T-0001 status 갱신',
+    command: 'leerness task update T-0001 --status completed'
+  };
+  const concurrentAction = { ...oldAction, title: 'progress-tracker 25h 정체 — task T-0001 status 갱신' };
+  writeQueue(root, [oldAction]);
+  fs.mkdirSync(lockPath);
+
+  const child = cp.spawn(process.execPath, [cliPath, 'next-action', 'take', '0', '--path', root], {
+    cwd: root,
+    windowsHide: true,
+    env: { ...process.env, LEERNESS_OFFLINE: '1', LEERNESS_NO_PROMPT: '1' },
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  let stdout = '';
+  let stderr = '';
+  let sawSelection;
+  const selected = new Promise(resolve => { sawSelection = resolve; });
+  child.stdout.on('data', chunk => { stdout += chunk; sawSelection(); });
+  child.stderr.on('data', chunk => { stderr += chunk; });
+  await Promise.race([selected, delay(1000)]);
+
+  // Current buggy take has already selected the 24h title outside the lock. A concurrent
+  // normalizer changes that title while holding the queue lock, so its later title lookup misses.
+  writeQueue(root, [concurrentAction]);
+  fs.rmdirSync(lockPath);
+  const result = await new Promise(resolve => {
+    const timer = setTimeout(() => { try { child.kill(); } catch {} resolve({ code: null, stdout, stderr, timeout: true }); }, 15000);
+    child.on('exit', code => { clearTimeout(timer); resolve({ code, stdout, stderr, timeout: false }); });
+  });
+  const persisted = JSON.parse(fs.readFileSync(queuePath, 'utf8')).queue;
+  return { ...result, remaining: persisted.length };
+}
+
+async function main() {
+  if (generator.includes('leerness decision list --filter')) offenders.push('decision-list-filter');
+  if (generator.includes('leerness plan list --filter')) offenders.push('plan-list-filter');
+  if (/stress-v\$\{latest\+1\}/.test(generator)) offenders.push('missing-stress-execution');
+  if (generator.includes('node ./scripts/e2e.js')) offenders.push('consumer-missing-e2e');
+  if (!resumeBuilder.includes('_normalizedNextActionState(root)')) offenders.push('auto-resume-build-raw-queue');
+
+  const arena = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-next-action-probe-'));
+  try {
+    const listRoot = path.join(arena, 'list-project');
+    const legacy = [
+      { icon: '🎯', title: 'plan.md milestone M-0001 검증 — "install" 관련', command: 'leerness plan list --filter "install"' },
+      { icon: '💭', title: 'decisions.md "install" 관련 결정 1건 영향 확인', command: 'leerness decision list --filter "install"' },
+      { icon: '🧪', title: 'review-evidence.md 비어있음 — e2e 또는 verify-code 실행', command: 'node ./scripts/e2e.js' },
+      { icon: '🧬', title: 'stress-v210 마지막 갱신 47h 전 — 새 stress test 작성 권장', command: 'node _apps/leerness-stress/bin/stress-v211.js' },
+      { icon: '🧬', title: 'stress-v211 마지막 갱신 48h 전 — 새 stress test 작성 권장', command: 'node _apps/leerness-stress/bin/stress-v212.js' },
+      { icon: '🔄', title: 'progress-tracker 24h 정체 — task T-0001 status 갱신', command: 'leerness task update T-0001 --status completed' },
+      { icon: '🔄', title: 'progress-tracker 25h 정체 — task T-0001 status 갱신', command: 'leerness task update T-0001 --status completed' }
+    ];
+    writeQueue(listRoot, legacy);
+    fs.writeFileSync(path.join(listRoot, 'package.json'), JSON.stringify({
+      name: 'next-action-probe-project',
+      private: true,
+      scripts: { test: 'node -e "process.exit(0)"' }
+    }, null, 2), 'utf8');
+
+    const listed = run(['next-action', 'list', '--path', listRoot, '--json'], listRoot);
+    let queue = [];
+    try { queue = JSON.parse(listed.stdout).queue; } catch { offenders.push('list-json-contract'); }
+    if (listed.status !== 0) offenders.push('list-exit');
+    if (queue.some(a => /\s--filter(?:\s|$)/.test(String(a.command || '')))) offenders.push('lazy-filter-migration');
+    if (queue.some(a => String(a.command || '').includes('./scripts/e2e.js'))) offenders.push('lazy-e2e-migration');
+    if (queue.filter(a => a.icon === '🧬').length !== 1) offenders.push('cross-version-stress-dedup');
+    if (queue.filter(a => a.icon === '🔄').length !== 1) offenders.push('hour-changing-progress-dedup');
+    if (queue.some(a => a.icon === '🔄' && /\d+h/.test(String(a.title)))) offenders.push('dynamic-progress-title');
+    if (queue.filter(a => ['🎯', '💭', '🧪', '🧬', '🔄'].includes(a.icon)).some(a => !a.actionKey)) offenders.push('stable-action-key');
+
+    // Every read surface must expose the same normalized contract as next-action list/take.
+    // A published release writes auto-resume-plan from this snapshot, while context is consumed
+    // by external agents; leaking legacy commands through either surface reintroduces the bug.
+    const planRoot = path.join(arena, 'resume-project');
+    fs.mkdirSync(path.join(planRoot, '.leerness'), { recursive: true });
+    fs.writeFileSync(path.join(planRoot, '.leerness', 'auto-resume-plan.json'), JSON.stringify({
+      savedAt: new Date().toISOString(),
+      expectedFireAt: new Date(Date.now() + 60000).toISOString(),
+      nextRoundVersion: 'next after 1.36.169',
+      nextActions: legacy
+    }, null, 2), 'utf8');
+    const resumed = run(['resume', '--path', planRoot, '--json'], planRoot);
+    let resumedActions = [];
+    try { resumedActions = JSON.parse(resumed.stdout).nextActions; } catch { offenders.push('resume-json-contract'); }
+    if (resumed.status !== 0) offenders.push('resume-exit');
+    if (hasLegacySuggestion(resumedActions)) offenders.push('legacy-auto-resume-plan');
+    if ((resumedActions || []).filter(a => a.icon === '🧬').length !== 1
+      || (resumedActions || []).filter(a => a.icon === '🔄').length !== 1) offenders.push('auto-resume-plan-dedup');
+
+    const contextual = run(['context', '--path', listRoot, '--json'], listRoot);
+    let contextActions = [];
+    try { contextActions = JSON.parse(contextual.stdout).nextActions; } catch { offenders.push('context-json-contract'); }
+    if (contextual.status !== 0) offenders.push('context-exit');
+    if (hasLegacySuggestion(contextActions)) offenders.push('context-raw-queue');
+
+    const preWake = run(['pre-wake-audit', '--path', listRoot, '--json'], listRoot);
+    let pendingFinding = null;
+    try {
+      const report = JSON.parse(preWake.stdout);
+      pendingFinding = (report.findings.info || []).find(f => f.kind === 'next-action-pending');
+    } catch { offenders.push('pre-wake-json-contract'); }
+    if (preWake.status !== 0) offenders.push('pre-wake-exit');
+    if (!pendingFinding) offenders.push('pre-wake-missing-next-action');
+    else if (pendingFinding.count !== queue.length) offenders.push('pre-wake-raw-next-action-count');
+
+    // Execute corrected generated commands against an ordinary project. This guards command
+    // existence and flags, rather than merely asserting that selected source strings changed.
+    for (const action of queue.filter(a => ['🎯', '💭', '🧪'].includes(a.icon))) {
+      const args = commandArgs(action.command);
+      if (args.shift() !== 'leerness') { offenders.push(`non-leerness-command:${action.icon}`); continue; }
+      const result = run(args, listRoot);
+      if (result.status !== 0) offenders.push(`generated-command-exit:${action.icon}`);
+    }
+
+    const raceRoot = path.join(arena, 'race-project');
+    const race = await reproduceTakeMigrationRace(raceRoot);
+    if (race.timeout || race.code !== 0) offenders.push('take-race-process');
+    if (race.remaining !== 0) offenders.push('take-race-left-queued');
+  } finally {
+    try { fs.rmSync(arena, { recursive: true, force: true }); } catch {}
+  }
+
+  const required = [
+    'leerness decision list --query',
+    'leerness plan list --path .',
+    'leerness verify-code .',
+    'stress-v${latest} 오래됨 — 새 stress test 작성 권장'
+  ];
+  for (const needle of required) {
+    if (!generator.includes(needle)) offenders.push(`missing:${needle}`);
+  }
+  if (offenders.length) {
+    console.error(`invalid-next-action-suggestion: ${[...new Set(offenders)].join(',')}`);
+    process.exit(1);
+  }
+  console.log('next-action suggestion probe passed: executable commands, lazy migration, stable dedup, atomic take');
+}
+
+main().catch(err => {
+  console.error(`next-action-suggestion-probe: ${err && err.stack ? err.stack : err}`);
+  process.exit(1);
+});