leerness 1.36.180 → 1.36.182

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.36.182 — 2026-08-31
+
+- T-0162: English-mode milestones now contains zero Hangul across stored, environment, and explicit locale paths while preserving Korean and locale-independent JSON contracts. The 39-command aggregate leakage ratchet tightens exactly from 38 to 34 lines. External Codex review findings are covered by UTC-midnight-safe ETA comparison and real CLI coverage of the 500+ terminal branch.
+
+## 1.36.181 — 2026-08-30
+
+- T-0161: English-mode release cadence, idempotency audit, plan list, and round-history now contain zero Hangul across stored, environment, and explicit locale paths. A dedicated edge-state probe preserves Korean output, legacy plan sentinels, locale-independent auto-fix JSON/state writes, and the 39-command leakage ratchet tightens exactly from 58 to 38 lines so improvements cannot mask regressions elsewhere.
+
 ## 1.36.180 — 2026-08-30
 
 - English-mode agents list, insights, and toggle output now contain zero Hangul; a dedicated red/green probe and 39-command ratchet reduce measured leakage from 104 to 58 lines while preserving Korean output.

package/README.md

@@ -138,7 +138,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.180 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.182 하네스를 사용합니다. 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.180는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
+Leerness v1.36.182는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -213,7 +213,7 @@ Leerness v1.36.180는 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.180 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.182 릴리스 태그 이력** (수백 라운드) · _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.180: 2026-08-30
+Last synced by Leerness v1.36.182: 2026-08-31
 <!-- leerness:project-readme:end -->

package/bin/leerness.js

@@ -49,7 +49,7 @@ const {
   migrateLegacyWorkspace,
 } = require('../lib/workspace-dir');
 
-const VERSION = '1.36.180';
+const VERSION = '1.36.182';
 
 // MCP lifecycle 주소 표식은 현재 CLI 호출 한 번에만 유효하다. CLI bootstrap에서 즉시 env에서
 // 떼어 두어 `--no-record`/hook처럼 presence 기록 함수에 도달하지 않는 경로도 후속 child에 유출하지 않는다.
@@ -3408,6 +3408,7 @@ function _computeMilestones(root) {
 
 function milestonesCmd(root) {
   root = absRoot(root);
+  const _L = _uiLang(root); const t = (ko, en) => (_L === 'en' ? en : ko);
   const isTty = process.stdout && process.stdout.isTTY;
   const cy = s => isTty ? `\x1b[36m${s}\x1b[0m` : s;
   const gr = s => isTty ? `\x1b[32m${s}\x1b[0m` : s;
@@ -3416,29 +3417,31 @@ function milestonesCmd(root) {
   const data = _computeMilestones(root);
   if (data.gitHistoryState !== 'available') _throwGitHistoryUnavailable(data.gitHistoryError);
   if (has('--json')) { log(JSON.stringify(data, null, 2)); return; }
-  log(cy(`# leerness milestones (1.9.229) — 도달 마일스톤 + 다음 ETA`));
+  log(cy(t(`# leerness milestones (1.9.229) — 도달 마일스톤 + 다음 ETA`, `# leerness milestones (1.9.229) — reached milestones + next ETA`)));
   log('');
-  log(`  📦 총 라운드: ${gr(String(data.totalRounds))}`);
+  log(t(`  📦 총 라운드: ${gr(String(data.totalRounds))}`, `  📦 total rounds: ${gr(String(data.totalRounds))}`));
   if (data.baselineAt) log(`  📍 baseline: ${(data.baselineAt || '').split(' ')[0]}`);
-  if (data.avgRoundsPerDay) log(`  📊 평균: ${gr(data.avgRoundsPerDay + ' rounds/day')}`);
+  if (data.avgRoundsPerDay) log(t(`  📊 평균: ${gr(data.avgRoundsPerDay + ' rounds/day')}`, `  📊 average: ${gr(data.avgRoundsPerDay + ' rounds/day')}`));
   log('');
   if (data.reached.length === 0) {
-    log(dm(`  (도달 마일스톤 없음 — 첫 R25 마일스톤 진행 중)`));
+    log(dm(t(`  (도달 마일스톤 없음 — 첫 R25 마일스톤 진행 중)`, `  (no milestones reached — progressing toward the first R25 milestone)`)));
   } else {
-    log(`  도달 마일스톤 ${data.reached.length}개:`);
+    log(t(`  도달 마일스톤 ${data.reached.length}개:`, `  ${data.reached.length} milestone${data.reached.length === 1 ? '' : 's'} reached:`));
     for (const m of data.reached) {
       log(`    ✓ R${m.milestone} ${gr(`(v${m.version}, ${m.reachedAt}, +${m.daysFromBaseline}d)`)}`);
     }
   }
   log('');
   if (data.next) {
-    log(yl(`  🎯 다음 마일스톤: R${data.next.milestone}`));
-    log(`    • ${data.next.roundsRemaining} 라운드 남음`);
+    log(yl(t(`  🎯 다음 마일스톤: R${data.next.milestone}`, `  🎯 next milestone: R${data.next.milestone}`)));
+    log(t(`    • ${data.next.roundsRemaining} 라운드 남음`, `    • ${data.next.roundsRemaining} rounds remaining`));
     if (data.next.etaDays != null) {
-      log(`    • ETA: ${data.next.etaDate} (~${data.next.etaDays}일 후, 현재 속도 기준)`);
+      log(t(`    • ETA: ${data.next.etaDate} (~${data.next.etaDays}일 후, 현재 속도 기준)`, `    • ETA: ${data.next.etaDate} (~${data.next.etaDays} days from now, based on current pace)`));
     }
   } else {
-    log(data && (data.roundCount || data.totalRounds) ? gr(`  🎉 모든 마일스톤 달성 (500+)`) : dm(`  (이 저장소 계보의 릴리스 태그 이력 없음)`));   // 1.36.38 (#4): 이력 0 인데 달성 축하 금지
+    log(data && (data.roundCount || data.totalRounds)
+      ? gr(t(`  🎉 모든 마일스톤 달성 (500+)`, `  🎉 all milestones reached (500+)`))
+      : dm(t(`  (이 저장소 계보의 릴리스 태그 이력 없음)`, `  (no release-tag history for this repository lineage)`)));   // 1.36.38 (#4): 이력 0 인데 달성 축하 금지
   }
 }
 
@@ -11443,19 +11446,28 @@ function commandsCmd(root) {
 // 1.9.374 (UR-0074): release cadence — 릴리스 빈도 진단 + 권장 (외부리뷰 반복 지적 "릴리스 케이던스 과다" 가시화). git tag 재사용, 읽기 전용.
 function releaseCadenceCmd(root) {
   root = absRoot(root);
+  const _L = _uiLang(root); const t = (ko, en) => (_L === 'en' ? en : ko);
   const rh = _computeRoundHistory(root);
   if (rh.gitHistoryState !== 'available') _throwGitHistoryUnavailable(rh.gitHistoryError);
   const a = _cadenceAssessment(rh.avgRoundsPerDay, rh.roundCount, rh.daysActive);
   if (has('--json')) { log(JSON.stringify({ version: VERSION, cliVersion: rh.cliVersion, harnessVersion: rh.harnessVersion, harnessVersionState: rh.harnessVersionState, currentVersion: rh.currentVersion, currentVersionScope: rh.currentVersionScope, baselineVersion: rh.baselineVersion, latestTagVersion: rh.latestTagVersion, gitHistoryState: rh.gitHistoryState, gitHistoryError: rh.gitHistoryError, ...a }, null, 2)); return; }
-  log(`# leerness release cadence (1.9.374, UR-0074) — 릴리스 빈도 진단 (읽기 전용)`);
-  const observedRate = a.dataSufficient ? `${a.releasesPerDay}/day` : '관측 불가 (서로 다른 시각의 태그 2개 이상 필요)';
-  log(`  누적 릴리스: ${a.total}  ·  활동일: ${a.daysActive}일  ·  빈도: ${observedRate}`);
-  log(`  수준: ${a.level}`);
-  log(`  권장: ${a.recommendation}`);
-  log(`\n  관련: leerness release channel (stable/next 정책)  ·  leerness install-safety (공급망 신뢰)`);
+  const recommendationEn = {
+    'insufficient-data': 'Defer the cadence assessment until at least two release tags have distinct timestamps.',
+    'very-high': 'Strongly consider batched minor releases: group related patches into one or two minor releases per week, separate stable/next channels, and recommend stable to users.',
+    high: 'Cadence is high: group related changes to reduce publish frequency and document runtime and verification evidence in each release note.',
+    moderate: 'Cadence is moderate; consider batching into minor releases when stability is the priority.',
+    healthy: 'Cadence is healthy.',
+  }[a.level] || a.recommendation;
+  log(t(`# leerness release cadence (1.9.374, UR-0074) — 릴리스 빈도 진단 (읽기 전용)`, `# leerness release cadence (1.9.374, UR-0074) — release-frequency diagnosis (read-only)`));
+  const observedRate = a.dataSufficient ? `${a.releasesPerDay}/day` : t('관측 불가 (서로 다른 시각의 태그 2개 이상 필요)', 'unavailable (requires at least two tags with distinct timestamps)');
+  log(t(`  누적 릴리스: ${a.total}  ·  활동일: ${a.daysActive}일  ·  빈도: ${observedRate}`, `  total releases: ${a.total}  ·  active days: ${a.daysActive}  ·  frequency: ${observedRate}`));
+  log(t(`  수준: ${a.level}`, `  level: ${a.level}`));
+  log(t(`  권장: ${a.recommendation}`, `  recommendation: ${recommendationEn}`));
+  log(t(`\n  관련: leerness release channel (stable/next 정책)  ·  leerness install-safety (공급망 신뢰)`, `\n  related: leerness release channel (stable/next policy)  ·  leerness install-safety (supply-chain trust)`));
 }
 function roundHistoryCmd(root) {
   root = absRoot(root);
+  const _L = _uiLang(root); const t = (ko, en) => (_L === 'en' ? en : ko);
   const isTty = process.stdout && process.stdout.isTTY;
   const cy = s => isTty ? `\x1b[36m${s}\x1b[0m` : s;
   const gr = s => isTty ? `\x1b[32m${s}\x1b[0m` : s;
@@ -11464,25 +11476,27 @@ function roundHistoryCmd(root) {
   const data = _computeRoundHistory(root);
   if (data.gitHistoryState !== 'available') _throwGitHistoryUnavailable(data.gitHistoryError);
   if (has('--json')) { log(JSON.stringify(data, null, 2)); return; }
-  log(cy(`# leerness round-history (1.9.226) — 자율 라운드 통계`));
+  log(cy(t(`# leerness round-history (1.9.226) — 자율 라운드 통계`, `# leerness round-history (1.9.226) — autonomous-round statistics`)));
   log('');
   log(`  📦 leerness CLI: ${gr(data.cliVersion)}`);
-  if (data.harnessVersion) log(`  🧩 프로젝트 하네스: ${gr(data.harnessVersion)}`);
-  else if (data.harnessVersionState === 'invalid' || data.harnessVersionState === 'unreadable') log(yl(`  🧩 프로젝트 하네스: 판독 불가 (${data.harnessVersionState})`));
-  else if (data.harnessVersionState === 'missing') log(yl(`  🧩 프로젝트 하네스: 없음 (missing)`));
-  if (data.latestTagVersion) log(`  🏷️ 저장소 최근 태그: v${data.latestTagVersion}`);
-  log(`  🔄 누적 라운드: ${gr(String(data.roundCount))}`);
+  if (data.harnessVersion) log(t(`  🧩 프로젝트 하네스: ${gr(data.harnessVersion)}`, `  🧩 project harness: ${gr(data.harnessVersion)}`));
+  else if (data.harnessVersionState === 'invalid' || data.harnessVersionState === 'unreadable') log(yl(t(`  🧩 프로젝트 하네스: 판독 불가 (${data.harnessVersionState})`, `  🧩 project harness: unreadable (${data.harnessVersionState})`)));
+  else if (data.harnessVersionState === 'missing') log(yl(t(`  🧩 프로젝트 하네스: 없음 (missing)`, `  🧩 project harness: missing`)));
+  if (data.latestTagVersion) log(t(`  🏷️ 저장소 최근 태그: v${data.latestTagVersion}`, `  🏷️ latest repository tag: v${data.latestTagVersion}`));
+  log(t(`  🔄 누적 라운드: ${gr(String(data.roundCount))}`, `  🔄 total rounds: ${gr(String(data.roundCount))}`));
   if (data.baselineVersion) log(`  📍 baseline: v${data.baselineVersion} (${(data.firstTagAt || '').split('T')[0]})`);
-  if (data.latestTagAt) log(`  ⏰ 최근 tag: ${(data.latestTagAt || '').split('T')[0]}`);
-  if (data.daysActive > 0) log(`  📊 활동: ${data.daysActive}일 / 평균 ${gr(data.avgRoundsPerDay + ' rounds/day')}`);
+  if (data.latestTagAt) log(t(`  ⏰ 최근 tag: ${(data.latestTagAt || '').split('T')[0]}`, `  ⏰ latest tag: ${(data.latestTagAt || '').split('T')[0]}`));
+  if (data.daysActive > 0) log(t(`  📊 활동: ${data.daysActive}일 / 평균 ${gr(data.avgRoundsPerDay + ' rounds/day')}`, `  📊 activity: ${data.daysActive} days / average ${gr(data.avgRoundsPerDay + ' rounds/day')}`));
   log('');
   if (data.nextMilestone != null) {
-    log(yl(`  🎯 다음 마일스톤: R${data.nextMilestone} (${data.roundsToNextMilestone} 라운드 남음)`));
+    log(yl(t(`  🎯 다음 마일스톤: R${data.nextMilestone} (${data.roundsToNextMilestone} 라운드 남음)`, `  🎯 next milestone: R${data.nextMilestone} (${data.roundsToNextMilestone} rounds remaining)`)));
   } else {
-    log(data && (data.roundCount || data.totalRounds) ? gr(`  🎉 모든 마일스톤 달성 (500+)`) : dm(`  (이 저장소 계보의 릴리스 태그 이력 없음)`));   // 1.36.38 (#4): 이력 0 인데 달성 축하 금지
+    log(data && (data.roundCount || data.totalRounds)
+      ? gr(t(`  🎉 모든 마일스톤 달성 (500+)`, `  🎉 all milestones reached (500+)`))
+      : dm(t(`  (이 저장소 계보의 릴리스 태그 이력 없음)`, `  (no release-tag history for this repository lineage)`)));   // 1.36.38 (#4): 이력 0 인데 달성 축하 금지
   }
   log('');
-  log(`  최근 10 tags:`);
+  log(t(`  최근 10 tags:`, `  latest 10 tags:`));
   data.latestTags.forEach(t => log(`    • v${t.version} (${t.date})`));
 }
 
@@ -13060,7 +13074,9 @@ function migrateWorkspaceDirCmd(root) {
 //     3. user-requests.json — 동일 텍스트 + open (1.9.207 자체 dedup 검증)
 //     4. active-wakeups.json — 동일 expectedFireAt 중복 (1.9.205 dedup 검증)
 //     5. next-action-queue.json — 동일 title 중복 (1.9.201 dedup 검증)
-function _runIdempotencyAudit(root) {
+function _runIdempotencyAudit(root, lang = 'ko') {
+  const t = (ko, en) => (lang === 'en' ? en : ko);
+  const auditError = (area, error) => t(String(error && (error.message || error) || 'audit error'), `Could not audit ${area} safely (${String(error && error.code || 'read-error')})`);
   const audit = {
     auditedAt: new Date().toISOString(),
     auditVersion: VERSION,
@@ -13078,7 +13094,7 @@ function _runIdempotencyAudit(root) {
         audit.violations.push({
           kind: 'rule-duplicate',
           location: '.leerness/rules.md',
-          detail: `중복 룰: ${r.id} == ${seen.get(key)} (${r.trigger}: ${r.rule.slice(0, 60)})`,
+          detail: t(`중복 룰: ${r.id} == ${seen.get(key)} (${r.trigger}: ${r.rule.slice(0, 60)})`, `Duplicate rule: ${r.id} == ${seen.get(key)} (${r.trigger}: ${r.rule.slice(0, 60)})`),
           severity: 'medium',
           fix: `leerness rule remove ${r.id}`
         });
@@ -13087,9 +13103,9 @@ function _runIdempotencyAudit(root) {
       }
     }
     if (audit.violations.filter(v => v.kind === 'rule-duplicate').length === 0) {
-      audit.verified.push({ kind: 'rules', detail: `${active.length} active rules, 중복 0건` });
+      audit.verified.push({ kind: 'rules', detail: t(`${active.length} active rules, 중복 0건`, `${active.length} active rules, 0 duplicates`) });
     }
-  } catch (e) { audit.violations.push({ kind: 'audit-error', area: 'rules', detail: String(e.message || e), severity: 'low' }); }
+  } catch (e) { audit.violations.push({ kind: 'audit-error', area: 'rules', detail: auditError('rules', e), severity: 'low' }); }
 
   // 2) progress-tracker.md 중복 request 검사
   //    포맷: | T-XXXX | status | request | evidence | nextAction | date |
@@ -13114,19 +13130,19 @@ function _runIdempotencyAudit(root) {
           audit.violations.push({
             kind: 'task-duplicate-request',
             location: '.leerness/progress-tracker.md',
-            detail: `중복 request: "${text.slice(0, 50)}…" (${prev.id} & ${id})`,
+            detail: t(`중복 request: "${text.slice(0, 50)}…" (${prev.id} & ${id})`, `Duplicate request: "${text.slice(0, 50)}…" (${prev.id} & ${id})`),
             severity: 'medium',
-            fix: `중복 task 중 하나를 leerness task drop <id> 처리`
+            fix: t(`중복 task 중 하나를 leerness task drop <id> 처리`, `drop one duplicate with leerness task drop <id>`)
           });
         } else {
           requests.set(text, { id, status, line: i + 1 });
         }
       }
       if (audit.violations.filter(v => v.kind === 'task-duplicate-request').length === 0) {
-        audit.verified.push({ kind: 'tasks', detail: `${requests.size} active tasks, request 중복 0건` });
+        audit.verified.push({ kind: 'tasks', detail: t(`${requests.size} active tasks, request 중복 0건`, `${requests.size} active tasks, 0 duplicate requests`) });
       }
     }
-  } catch (e) { audit.violations.push({ kind: 'audit-error', area: 'tasks', detail: String(e.message || e), severity: 'low' }); }
+  } catch (e) { audit.violations.push({ kind: 'audit-error', area: 'tasks', detail: auditError('tasks', e), severity: 'low' }); }
 
   // 3) user-requests.json 자체 dedup 검증 (1.9.207)
   try {
@@ -13139,7 +13155,7 @@ function _runIdempotencyAudit(root) {
         audit.violations.push({
           kind: 'user-request-duplicate',
           location: '.leerness/user-requests.json',
-          detail: `중복 open 요청: ${r.id} == ${seen.get(k)} ("${k.slice(0, 50)}…")`,
+          detail: t(`중복 open 요청: ${r.id} == ${seen.get(k)} ("${k.slice(0, 50)}…")`, `Duplicate open request: ${r.id} == ${seen.get(k)} ("${k.slice(0, 50)}…")`),
           severity: 'low',
           fix: `leerness requests drop ${r.id}`
         });
@@ -13148,9 +13164,9 @@ function _runIdempotencyAudit(root) {
       }
     }
     if (audit.violations.filter(v => v.kind === 'user-request-duplicate').length === 0) {
-      audit.verified.push({ kind: 'user-requests', detail: `${seen.size} open requests, 중복 0건 (1.9.207 dedup OK)` });
+      audit.verified.push({ kind: 'user-requests', detail: t(`${seen.size} open requests, 중복 0건 (1.9.207 dedup OK)`, `${seen.size} open requests, 0 duplicates (1.9.207 dedup OK)`) });
     }
-  } catch (e) { audit.violations.push({ kind: 'audit-error', area: 'user-requests', detail: String(e.message || e), severity: 'low' }); }
+  } catch (e) { audit.violations.push({ kind: 'audit-error', area: 'user-requests', detail: auditError('user-requests', e), severity: 'low' }); }
 
   // 4) active-wakeups.json 검증 (1.9.205)
   try {
@@ -13162,16 +13178,16 @@ function _runIdempotencyAudit(root) {
         audit.violations.push({
           kind: 'wakeup-duplicate',
           location: '.leerness/active-wakeups.json',
-          detail: `동일 expectedFireAt 중복: ${w.expectedFireAt}`,
+          detail: t(`동일 expectedFireAt 중복: ${w.expectedFireAt}`, `Duplicate expectedFireAt: ${w.expectedFireAt}`),
           severity: 'high',
-          fix: `leerness 자동 _recordWakeup filter dedup 검토 필요`
+          fix: t(`leerness 자동 _recordWakeup filter dedup 검토 필요`, `inspect the automatic leerness _recordWakeup dedup filter`)
         });
       } else {
         seenT.set(w.expectedFireAt, true);
       }
     }
     if (audit.violations.filter(v => v.kind === 'wakeup-duplicate').length === 0) {
-      audit.verified.push({ kind: 'wakeups', detail: `${pending.length} pending wakeups, 중복 0건 (1.9.205 dedup OK)` });
+      audit.verified.push({ kind: 'wakeups', detail: t(`${pending.length} pending wakeups, 중복 0건 (1.9.205 dedup OK)`, `${pending.length} pending wakeups, 0 duplicates (1.9.205 dedup OK)`) });
     }
   } catch {}
 
@@ -13252,6 +13268,7 @@ function _autoFixIdempotency(root) {
 }
 function idempotencyCmd(root, sub) {
   root = absRoot(root);
+  const _L = _uiLang(root); const t = (ko, en) => (_L === 'en' ? en : ko);
   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;
@@ -13260,23 +13277,22 @@ function idempotencyCmd(root, sub) {
   const dim = s => isTty ? `\x1b[2m${s}\x1b[0m` : s;
 
   if (!sub || sub === 'help' || sub === '--help') {
-    const _L = _uiLang(root); const _t = (ko, en) => _L === 'en' ? en : ko;  // 1.23.2 (UR-0010 Phase 7)
-    log(_t(`# leerness idempotency (1.9.212) — 멱등성 위반 탐지`, `# leerness idempotency — detect idempotency violations`));
+    log(t(`# leerness idempotency (1.9.212) — 멱등성 위반 탐지`, `# leerness idempotency — detect idempotency violations`));
     log('');
-    log(_t(`  audit               → 워크스페이스 멱등성 점검 (rules / tasks / user-requests / wakeups)  (--json 가능)`, `  audit               → check workspace idempotency (rules / tasks / user-requests / wakeups)  (--json)`));
-    log(_t(`  audit --auto-fix    → task 완전중복 행 제거 + active 동일텍스트 dropped 처리 + user-request open 중복 정리 (1.9.293)`, `  audit --auto-fix    → remove exact-duplicate tasks + mark same-text active as dropped + dedup open user-requests`));
+    log(t(`  audit               → 워크스페이스 멱등성 점검 (rules / tasks / user-requests / wakeups)  (--json 가능)`, `  audit               → check workspace idempotency (rules / tasks / user-requests / wakeups)  (--json)`));
+    log(t(`  audit --auto-fix    → task 완전중복 행 제거 + active 동일텍스트 dropped 처리 + user-request open 중복 정리 (1.9.293)`, `  audit --auto-fix    → remove exact-duplicate tasks + mark same-text active as dropped + dedup open user-requests`));
     log('');
-    log(dim(_t(`  dedup 적용 영역: ruleAdd / taskAdd (1.9.212) + _recordUserRequest (1.9.207) + _recordWakeup (1.9.205)`, `  dedup applies to: ruleAdd / taskAdd + _recordUserRequest + _recordWakeup`)));
-    log(dim(_t(`  --auto-fix 안전: 완전 동일 행만 제거 / 동일텍스트는 status=dropped 로 보존(id 유지) / git 회복 가능 / 멱등`, `  --auto-fix safety: removes only exact dupes / same-text kept as status=dropped (id preserved) / git-recoverable / idempotent`)));
-    log(dim(_t(`  자동화: drift check --auto-fix 가 idempotency 중복도 자동 정리 (1.9.293)`, `  automation: drift check --auto-fix also dedups idempotency violations`)));
-    log(dim(_t(`  opt-out: --force 플래그로 dedup 우회 가능`, `  opt-out: pass --force to bypass dedup`)));
+    log(dim(t(`  dedup 적용 영역: ruleAdd / taskAdd (1.9.212) + _recordUserRequest (1.9.207) + _recordWakeup (1.9.205)`, `  dedup applies to: ruleAdd / taskAdd + _recordUserRequest + _recordWakeup`)));
+    log(dim(t(`  --auto-fix 안전: 완전 동일 행만 제거 / 동일텍스트는 status=dropped 로 보존(id 유지) / git 회복 가능 / 멱등`, `  --auto-fix safety: removes only exact dupes / same-text kept as status=dropped (id preserved) / git-recoverable / idempotent`)));
+    log(dim(t(`  자동화: drift check --auto-fix 가 idempotency 중복도 자동 정리 (1.9.293)`, `  automation: drift check --auto-fix also dedups idempotency violations`)));
+    log(dim(t(`  opt-out: --force 플래그로 dedup 우회 가능`, `  opt-out: pass --force to bypass dedup`)));
     return;
   }
 
   if (sub === 'audit') {
     const autoFix = has('--auto-fix');
     const fixes = autoFix ? _autoFixIdempotency(root) : [];
-    const audit = _runIdempotencyAudit(root);  // auto-fix 후 상태 반영
+    const audit = _runIdempotencyAudit(root, has('--json') ? 'ko' : _L);  // JSON 은 기존 canonical payload, 사람 출력만 locale 적용
     if (autoFix) audit.autoFixed = fixes;
     // 1.36.131 (검수 P1): --json 도 같은 계약 — auto-fix 가 실패했으면 성공 종료코드로 나가지 않는다.
     if (autoFix && fixes.some(f => f.action === 'error')) { audit.autoFixFailed = fixes.filter(f => f.action === 'error').length; process.exitCode = 1; }
@@ -13286,9 +13302,9 @@ function idempotencyCmd(root, sub) {
     log('');
     const s = audit.summary;
     if (s.overall === 'clean') {
-      log(grn(`  ✓ 멱등성 위반 없음 — verified ${s.verifiedAreas} 영역`));
+      log(grn(t(`  ✓ 멱등성 위반 없음 — verified ${s.verifiedAreas} 영역`, `  ✓ no idempotency violations — verified ${s.verifiedAreas} areas`)));
     } else {
-      log(red(`  ⚠ ${s.totalViolations} 위반 발견 (high: ${s.highSeverity}, medium: ${s.mediumSeverity}, low: ${s.lowSeverity})`));
+      log(red(t(`  ⚠ ${s.totalViolations} 위반 발견 (high: ${s.highSeverity}, medium: ${s.mediumSeverity}, low: ${s.lowSeverity})`, `  ⚠ ${s.totalViolations} violations found (high: ${s.highSeverity}, medium: ${s.mediumSeverity}, low: ${s.lowSeverity})`)));
     }
     log('');
     if (audit.verified.length) {
@@ -13313,18 +13329,18 @@ function idempotencyCmd(root, sub) {
       const _applied = fixes.filter(f => f.action !== 'error');
       const _failedFix = fixes.filter(f => f.action === 'error');
       if (_applied.length) {
-        log(grn(`## 🔧 auto-fix 적용 (${_applied.length})`));
+        log(grn(t(`## 🔧 auto-fix 적용 (${_applied.length})`, `## 🔧 auto-fix applied (${_applied.length})`)));
         _applied.forEach(f => {
-          if (f.kind === 'task-duplicate-request') log(`  - [tasks] 완전중복 ${f.removedExact || 0}행 제거 · 동일텍스트 ${f.droppedSameText || 0}건 dropped 처리`);
-          else if (f.kind === 'user-request-duplicate') log(`  - [user-requests] open 중복 ${f.count || 0}건 dropped 처리`);
+          if (f.kind === 'task-duplicate-request') log(t(`  - [tasks] 완전중복 ${f.removedExact || 0}행 제거 · 동일텍스트 ${f.droppedSameText || 0}건 dropped 처리`, `  - [tasks] removed ${f.removedExact || 0} exact duplicate rows · marked ${f.droppedSameText || 0} same-text tasks as dropped`));
+          else if (f.kind === 'user-request-duplicate') log(t(`  - [user-requests] open 중복 ${f.count || 0}건 dropped 처리`, `  - [user-requests] marked ${f.count || 0} duplicate open requests as dropped`));
           else log(dim(`  - [${f.kind}] ${f.action}${f.detail ? ' — ' + f.detail : ''}`));
         });
       } else if (!_failedFix.length) {
-        log(dim('  🔧 auto-fix: 적용할 중복 없음 (이미 정합)'));
+        log(dim(t('  🔧 auto-fix: 적용할 중복 없음 (이미 정합)', '  🔧 auto-fix: no duplicates to apply (already consistent)')));
       }
       if (_failedFix.length) {
-        log(red(`## ❌ auto-fix 실패 (${_failedFix.length}) — 고쳐지지 않았다. 수동 확인 필요`));
-        _failedFix.forEach(f => log(`  - [${f.kind}] ${f.detail || '원인 미상'}`));
+        log(red(t(`## ❌ auto-fix 실패 (${_failedFix.length}) — 고쳐지지 않았다. 수동 확인 필요`, `## ❌ auto-fix failed (${_failedFix.length}) — state was not repaired; inspect it manually`)));
+        _failedFix.forEach(f => log(`  - [${f.kind}] ${_L === 'en' ? 'could not repair safely' : (f.detail || '원인 미상')}`));
         process.exitCode = 1;
       }
     }
@@ -14782,6 +14798,7 @@ function planInit(root) {
 // 1.9.119: plan list — plan.md 의 모든 milestone (M-XXXX) 조회 (CLI + --json + MCP)
 function planListCmd(root, opts = {}) {
   root = absRoot(root);
+  const _L = _uiLang(root); const t = (ko, en) => (_L === 'en' ? en : ko);
   const jsonMode = !!opts.json || has('--json');
   const pp = planPath(root);
   if (!exists(pp)) {
@@ -14789,7 +14806,7 @@ function planListCmd(root, opts = {}) {
       process.stdout.write(JSON.stringify({ version: VERSION, root, total: 0, milestones: [] }, null, 2) + '\n');
       return;
     }
-    return ok('plan.md 없음 — leerness plan add "<text>" 로 첫 milestone 등록');
+    return ok(t('plan.md 없음 — leerness plan add "<text>" 로 첫 milestone 등록', 'plan.md not found — add the first milestone with leerness plan add "<text>"'));
   }
   // 1.36.21 (codex #8a, 전수 sweep 3 에이전트 수렴): CRLF plan.md 에서 모든 마일스톤의 tasks 가 조용히 [] 로 증발하던 것 수정.
   //   체크박스 정규식(/^-\s*\[([\sx])\]\s*(.+)$/)이 /m 없이 후행 \r 앞에서 $ 를 못 잡아 실패 — id/title/status/progress 는 /m 이라 정상 파싱되어
@@ -14831,14 +14848,15 @@ function planListCmd(root, opts = {}) {
     return;
   }
   log(`# 🗺  Plan (1.9.119)\n`);
-  if (!milestones.length) return ok('plan milestones 비어있음');
-  log(`총 ${milestones.length}개 milestone:`);
+  if (!milestones.length) return ok(t('plan milestones 비어있음', 'plan milestones are empty'));
+  log(t(`총 ${milestones.length}개 milestone:`, `${milestones.length} milestones:`));
   for (const m of milestones) {
     log(`\n[${m.id}] ${m.title}`);
     if (m.status) log(`  Status: ${m.status}`);
     if (m.progress) log(`  Progress: ${m.progress}`);
-    log(`  완료기준(Done-When): ${m.doneWhen || '⚠ 미정 — plan add ... --done-when "<검증가능 조건>" 권장 (Karpathy 원칙4)'}`);
-    if (m.tasks.length) log(`  Tasks: ${m.tasks.length}개 (${m.tasks.filter(t => t.done).length} 완료)`);
+    const doneWhen = _L === 'en' && m.doneWhen === '(미정)' ? '(unset)' : m.doneWhen;
+    log(t(`  완료기준(Done-When): ${doneWhen || '⚠ 미정 — plan add ... --done-when "<검증가능 조건>" 권장 (Karpathy 원칙4)'}`, `  Done-When: ${doneWhen || '⚠ unset — consider plan add ... --done-when "<verifiable condition>" (Karpathy principle 4)'}`));
+    if (m.tasks.length) log(t(`  Tasks: ${m.tasks.length}개 (${m.tasks.filter(task => task.done).length} 완료)`, `  Tasks: ${m.tasks.length} (${m.tasks.filter(task => task.done).length} done)`));
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.180",
+  "version": "1.36.182",
   "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",
@@ -48,19 +48,19 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/handoff-readonly-probe.js && node ./scripts/mcp-presence-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/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/handoff-readonly-probe.js && node ./scripts/mcp-presence-probe.js",
+    "test": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && node ./scripts/i18n-next-cluster-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/handoff-readonly-probe.js && node ./scripts/mcp-presence-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/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && node ./scripts/i18n-next-cluster-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/handoff-readonly-probe.js && node ./scripts/mcp-presence-probe.js",
     "test:commands": "node ./scripts/command-flags-probe.js && node ./scripts/dead-flags-probe.js && node ./scripts/false-claim-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/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/mcp-presence-probe.js && node ./scripts/false-claim-probe.js && node ./scripts/smoke.js",
+    "test:fast": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && node ./scripts/i18n-next-cluster-probe.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/mcp-presence-probe.js && node ./scripts/false-claim-probe.js && node ./scripts/smoke.js",
     "test:false-claims": "node ./scripts/false-claim-probe.js",
     "test:workspace-lock-order": "node ./scripts/workspace-dir-lock-order-probe.js",
     "test:mcp-presence": "node ./scripts/mcp-presence-probe.js",
     "test:smoke": "node ./scripts/smoke.js",
     "test:parent-detect": "node ./scripts/parent-detect-selftest-probe.js",
-    "test:i18n": "node ./scripts/i18n-priority-surface-probe.js",
+    "test:i18n": "node ./scripts/i18n-priority-surface-probe.js && node ./scripts/i18n-next-cluster-probe.js",
     "lint": "node ./scripts/lint.js",
     "prepack": "node ./bin/leerness.js readme sync . && node ./bin/leerness.js --version"
   },

package/scripts/e2e.js

@@ -11006,7 +11006,7 @@ total++;
       ['provider', 'list'], ['skill', 'list'], ['next-action', 'list'], ['session-resume'],
       ['idempotency', 'audit'], ['context', 'budget'], ['drift', 'check'], ['verify'],
       ['encoding', 'check'], ['scan', 'secrets'], ['which'], ['glossary'], ['release', 'cadence']];
-    let leaky = 0, produced = 0; const worst = [], silent = [];
+    let leaky = 0, produced = 0; const worst = [], silent = [], measured = new Map();
     for (const a of CMDS) {
       const r = R(a);
       const out = String(r.stdout || '') + String(r.stderr || '');
@@ -11015,6 +11015,7 @@ total++;
       if (r.status === 0 && out.trim()) produced++; else silent.push(a.join(' ') + '(exit=' + r.status + ')');
       const n = out.split('\n').filter(l => HANGUL.test(l)).length;
       leaky += n;
+      measured.set(a.join(' '), n);
       if (n) worst.push(a.join(' ') + ':' + n);
     }
     dbg.leaky = leaky; dbg.produced = produced; dbg.worst = worst.slice(0, 8); dbg.silent = silent;
@@ -11028,12 +11029,18 @@ total++;
     //   갚은 만큼만 낮춘다 — 여유를 남기면 그 안에서 조용히 썩는다(1.36.82 의 자기참조 가드에서 겪은 형태).
     // 1.36.174: provider list 영어 모드의 요약/안내 두 줄을 영어화해 104로 조임(39개 명령 실측).
     // 1.36.180: agents list(18) + insights(17) + toggle list(11) 우선 표면을 영어화해 58로 조임.
-    const BASELINE = 58;
+    // 1.36.181: 공동 최상위 release cadence/idempotency audit/plan list/round-history(각 5)를 영어화해 38로 조임.
+    // 1.36.182: milestones 빈 이력 표면 4줄을 영어화해 34로 조임. 도달/ETA 분기도 전용 probe가 고정한다.
+    const BASELINE = 34;
     dbg.baseline = BASELINE;
-    dbg.withinRatchet = leaky <= BASELINE;
+    // 합계가 우연히 낮아진 뒤 다른 명령의 회귀가 그 여유를 소비하지 못하게 exact 로 잠근다.
+    // 번역이 더 진행되면 실측값과 BASELINE을 같은 변경에서 함께 낮춰야 한다.
+    dbg.exactRatchet = leaky === BASELINE;
     // 이번 라운드가 고친 표면은 **0 이어야** 한다 — 래칫과 별개로 회귀를 직접 막는다.
     const cmdOut = String(R(['commands']).stdout || '');
     dbg.commandsClean = cmdOut.split('\n').filter(l => HANGUL.test(l)).length === 0;
+    dbg.nextClusterClean = ['release cadence', 'idempotency audit', 'plan list', 'round-history', 'milestones']
+      .every(cmd => measured.get(cmd) === 0);
     // 한국어 사용자가 보던 것은 **바뀌면 안 된다**. 영어화하면서 `개` 단위를 양쪽에서 없애는 회귀를 냈고
     //   직전 커밋과의 바이트 비교가 잡았다. 여기서는 한국어 출력이 여전히 한국어 관례를 지키는지 단언한다.
     const koEnv = Object.assign({}, ENV, { LEERNESS_LANG: 'ko' });
@@ -11046,9 +11053,9 @@ total++;
       && Object.values(cj.categories).every(list => list.every(e => typeof e.cmd === 'string' && typeof e.desc === 'string'
         && e.descEn === undefined && e.cmdEn === undefined))     // 내부 번역 키가 payload 로 새면 70% 부풀었다(검수 P1 실측)
       && cj.lang === 'en';                                        // 로케일 의존을 **명시**한다 — 암묵적으로 흔들리지 않는다
-    ok = dbg.gitInit && dbg.probeAlive && dbg.coverage && dbg.withinRatchet && dbg.commandsClean && dbg.koIntact && dbg.jsonContract;
+    ok = dbg.gitInit && dbg.probeAlive && dbg.coverage && dbg.exactRatchet && dbg.commandsClean && dbg.nextClusterClean && dbg.koIntact && dbg.jsonContract;
   } catch (e) { dbg.err = String(e && e.message).slice(0, 200); } finally { try { fs.rmSync(sb, { recursive: true, force: true }); } catch {} }
-  console.log(ok ? `✓ O(1.36.111/T-0092) 영어 누출 ${dbg.leaky}줄 ≤ 래칫 ${dbg.baseline} · commands 표면 0 · 한국어 출력 불변 · --json 계약 유지 · 계측 살아있음`
+  console.log(ok ? `✓ O(1.36.111/T-0092) 영어 누출 ${dbg.leaky}줄 = exact 래칫 ${dbg.baseline} · commands/next-cluster 표면 0 · 한국어 출력 불변 · --json 계약 유지 · 계측 살아있음`
     : '✗ 1.36.111 i18n 래칫 위반 ' + JSON.stringify(dbg));
   if (!ok) failed++;
 }

package/scripts/i18n-next-cluster-probe.js

@@ -0,0 +1,290 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const cp = require('child_process');
+
+const CLI = path.resolve(__dirname, '..', 'bin', 'leerness.js');
+const HANGUL = /[가-힣ㄱ-ㆎ]/;
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-i18n-next-'));
+const project = path.join(tmp, 'project');
+
+const baseEnv = {
+  ...process.env,
+  TMPDIR: tmp,
+  TEMP: tmp,
+  TMP: tmp,
+  LEERNESS_INTERNAL: '1',
+  LEERNESS_NO_BANNER: '1',
+  LEERNESS_NO_STALE_CHECK: '1',
+  LEERNESS_OFFLINE: '1',
+};
+delete baseEnv.LEERNESS_LANG;
+
+function run(args, env = baseEnv) {
+  return cp.spawnSync(process.execPath, [CLI, ...args], {
+    cwd: project,
+    env,
+    encoding: 'utf8',
+    timeout: 300000,
+  });
+}
+
+function git(args, extraEnv = {}, input) {
+  return cp.spawnSync('git', args, {
+    cwd: project,
+    env: { ...baseEnv, ...extraEnv },
+    encoding: 'utf8',
+    timeout: 30000,
+    input,
+  });
+}
+
+function outputOf(result) {
+  return String(result.stdout || '') + String(result.stderr || '');
+}
+
+function requireSuccess(label, result) {
+  const output = outputOf(result);
+  if (result.status !== 0 || !output.trim()) {
+    throw new Error(`${label} probe command failed or was silent (exit ${result.status}): ${output.slice(0, 500)}`);
+  }
+  return output;
+}
+
+function requireGitSuccess(label, result) {
+  if (result.status !== 0) {
+    throw new Error(`${label} failed (exit ${result.status}): ${outputOf(result).slice(0, 500)}`);
+  }
+}
+
+function hangulLines(output) {
+  return String(output).split(/\r?\n/).filter(line => HANGUL.test(line));
+}
+
+function requireNoHangul(label, result) {
+  const output = requireSuccess(label, result);
+  const lines = hangulLines(output);
+  if (lines.length) {
+    throw new Error(`${label} leaked ${lines.length} Hangul line(s): ${lines.slice(0, 4).join(' | ')}`);
+  }
+  return output;
+}
+
+function normalizedJson(label, result) {
+  const output = requireSuccess(label, result);
+  let parsed;
+  try { parsed = JSON.parse(output); } catch (error) {
+    throw new Error(`${label} did not return one JSON document: ${error.message}`);
+  }
+  if (parsed && typeof parsed === 'object') delete parsed.auditedAt;
+  // Milestone ETA is intentionally based on the wall clock. English and Korean
+  // probes run in separate processes, so they can legitimately straddle UTC
+  // midnight. Validate the public date shape, then remove only that volatility
+  // before comparing the locale-independent payloads.
+  if (parsed && parsed.next && Object.prototype.hasOwnProperty.call(parsed.next, 'etaDate')) {
+    const etaDate = parsed.next.etaDate;
+    if (etaDate !== null && !/^\d{4}-\d{2}-\d{2}$/.test(String(etaDate))) {
+      throw new Error(`${label} returned an invalid milestone etaDate: ${etaDate}`);
+    }
+    if (etaDate !== null) parsed.next.etaDate = '<clock-derived-date>';
+  }
+  return parsed;
+}
+
+function cloneProjectState(target) {
+  fs.mkdirSync(target, { recursive: true });
+  fs.copyFileSync(path.join(project, 'package.json'), path.join(target, 'package.json'));
+  fs.cpSync(path.join(project, '.leerness'), path.join(target, '.leerness'), { recursive: true });
+}
+
+const surfaces = [
+  ['release cadence', ['release', 'cadence', '--path', project]],
+  ['idempotency audit', ['idempotency', 'audit', '--path', project]],
+  ['plan list', ['plan', 'list', '--path', project]],
+  ['round-history', ['round-history', '--path', project]],
+  ['milestones', ['milestones', '--path', project]],
+];
+
+try {
+  fs.mkdirSync(project, { recursive: true });
+  fs.writeFileSync(path.join(project, 'package.json'), '{"name":"i18n-next-probe","version":"0.1.0"}\n');
+  requireSuccess('init', run(['init', project, '--yes', '--language', 'en']));
+  requireGitSuccess('git init', git(['init', '-q']));
+  requireGitSuccess('git user name', git(['config', 'user.name', 'Leerness Probe']));
+  requireGitSuccess('git user email', git(['config', 'user.email', 'probe@example.invalid']));
+
+  requireSuccess('task add', run(['task', 'add', 'Implement the parser', '--path', project]));
+  requireSuccess('decision add', run(['decision', 'add', 'Use JSON storage', '--reason', 'simplest', '--path', project]));
+  requireSuccess('plan add', run(['plan', 'add', 'Ship the parser', '--path', project]));
+
+  // Stored project language, environment override, and explicit flag must all
+  // reach the same English renderer. Flip the stored language to Korean before
+  // checking overrides so a disconnected env/flag path cannot pass by falling
+  // back to the already-English manifest.
+  for (const [label, args] of surfaces) {
+    requireNoHangul(`${label} (stored language)`, run(args));
+  }
+  const manifestFile = path.join(project, '.leerness', 'manifest.json');
+  const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+  manifest.language = 'ko';
+  fs.writeFileSync(manifestFile, JSON.stringify(manifest, null, 2) + '\n');
+  for (const [label, args] of surfaces) {
+    requireNoHangul(`${label} (environment language)`, run(args, { ...baseEnv, LEERNESS_LANG: 'en' }));
+    requireNoHangul(`${label} (explicit language)`, run([...args, '--language', 'en'], { ...baseEnv, LEERNESS_LANG: 'ko' }));
+  }
+  manifest.language = 'en';
+  fs.writeFileSync(manifestFile, JSON.stringify(manifest, null, 2) + '\n');
+
+  // Missing and milestone-free plans have separate human branches.
+  const planFile = path.join(project, '.leerness', 'plan.md');
+  const originalPlan = fs.readFileSync(planFile, 'utf8');
+  fs.rmSync(planFile);
+  requireNoHangul('plan list missing file', run(['plan', 'list', '--path', project]));
+  fs.writeFileSync(planFile, '# Plan\n\n## Milestones\n');
+  requireNoHangul('plan list without milestones', run(['plan', 'list', '--path', project]));
+  const legacyPlan = originalPlan.replace('Done-When: (unset)', 'Done-When: (미정)');
+  if (legacyPlan === originalPlan) throw new Error('plan fixture did not contain the English unset sentinel');
+  fs.writeFileSync(planFile, legacyPlan);
+  const legacyPlanOutput = requireNoHangul('plan list legacy Korean sentinel', run(['plan', 'list', '--path', project]));
+  if (!legacyPlanOutput.includes('Done-When: (unset)')) {
+    throw new Error('plan list did not translate the legacy (미정) sentinel to (unset)');
+  }
+  fs.writeFileSync(planFile, originalPlan);
+
+  // Public add commands normally deduplicate; --force deliberately creates
+  // realistic duplicate rows so the violation renderer and auto-fix summary
+  // cannot remain Korean while the empty-state probe passes.
+  requireSuccess('duplicate rule A', run(['rule', 'add', 'Run tests', '--trigger', 'every-session', '--force', '--path', project]));
+  requireSuccess('duplicate rule B', run(['rule', 'add', 'Run tests', '--trigger', 'every-session', '--force', '--path', project]));
+  requireSuccess('duplicate task A', run(['task', 'add', 'Resolve duplicate work', '--status', 'in-progress', '--force', '--path', project]));
+  requireSuccess('duplicate task B', run(['task', 'add', 'Resolve duplicate work', '--status', 'in-progress', '--force', '--path', project]));
+  requireSuccess('duplicate user request seed', run(['requests', 'add', 'Resolve duplicate request', '--path', project]));
+  const requestFile = path.join(project, '.leerness', 'user-requests.json');
+  const requestState = JSON.parse(fs.readFileSync(requestFile, 'utf8'));
+  const requestSeed = requestState.requests[requestState.requests.length - 1];
+  requestState.requests.push({ ...requestSeed, id: 'UR-9000', recordedAt: '2026-08-30T00:00:00.000Z' });
+  fs.writeFileSync(requestFile, JSON.stringify(requestState, null, 2) + '\n');
+  requireNoHangul('idempotency violation report', run(['idempotency', 'audit', '--path', project]));
+
+  // --auto-fix mutates its target, so compare two byte-identical fresh clones.
+  // This catches locale-dependent JSON fields as well as locale-dependent state
+  // writes that a post-fix clean audit would miss.
+  const autoFixEnProject = path.join(tmp, 'autofix-en');
+  const autoFixKoProject = path.join(tmp, 'autofix-ko');
+  cloneProjectState(autoFixEnProject);
+  cloneProjectState(autoFixKoProject);
+  const autoFixEn = normalizedJson('idempotency auto-fix English JSON', run(
+    ['idempotency', 'audit', '--auto-fix', '--json', '--path', autoFixEnProject],
+    { ...baseEnv, LEERNESS_LANG: 'en' }
+  ));
+  const autoFixKo = normalizedJson('idempotency auto-fix Korean JSON', run(
+    ['idempotency', 'audit', '--auto-fix', '--json', '--path', autoFixKoProject],
+    { ...baseEnv, LEERNESS_LANG: 'ko' }
+  ));
+  if (JSON.stringify(autoFixEn) !== JSON.stringify(autoFixKo)) {
+    throw new Error('idempotency auto-fix JSON contract changed with UI language');
+  }
+  const enProgress = fs.readFileSync(path.join(autoFixEnProject, '.leerness', 'progress-tracker.md'));
+  const koProgress = fs.readFileSync(path.join(autoFixKoProject, '.leerness', 'progress-tracker.md'));
+  if (!enProgress.equals(koProgress)) throw new Error('idempotency auto-fix wrote locale-dependent progress-tracker.md');
+  const enRequests = JSON.parse(fs.readFileSync(path.join(autoFixEnProject, '.leerness', 'user-requests.json'), 'utf8'));
+  const koRequests = JSON.parse(fs.readFileSync(path.join(autoFixKoProject, '.leerness', 'user-requests.json'), 'utf8'));
+  delete enRequests.updatedAt;
+  delete koRequests.updatedAt;
+  if (JSON.stringify(enRequests) !== JSON.stringify(koRequests)) {
+    throw new Error('idempotency auto-fix wrote locale-dependent user-requests.json');
+  }
+  requireNoHangul('idempotency auto-fix report', run(['idempotency', 'audit', '--auto-fix', '--path', project]));
+
+  // Two annotated tags with distinct creation times exercise measured cadence
+  // and non-empty round history rather than only the insufficient-data branch.
+  requireGitSuccess('git add first snapshot', git(['add', '-A']));
+  const firstDate = '2026-08-28T00:00:00+09:00';
+  requireGitSuccess('git commit first snapshot', git(['commit', '-qm', 'first'], {
+    GIT_AUTHOR_DATE: firstDate,
+    GIT_COMMITTER_DATE: firstDate,
+  }));
+  requireGitSuccess('git tag first snapshot', git(['tag', '-a', 'v1.0.0', '-m', 'v1.0.0'], {
+    GIT_COMMITTER_DATE: firstDate,
+  }));
+  fs.writeFileSync(path.join(project, 'history.txt'), 'second\n');
+  requireGitSuccess('git add second snapshot', git(['add', 'history.txt']));
+  const secondDate = '2026-08-29T00:00:00+09:00';
+  requireGitSuccess('git commit second snapshot', git(['commit', '-qm', 'second'], {
+    GIT_AUTHOR_DATE: secondDate,
+    GIT_COMMITTER_DATE: secondDate,
+  }));
+  requireGitSuccess('git tag second snapshot', git(['tag', '-a', 'v1.0.1', '-m', 'v1.0.1'], {
+    GIT_COMMITTER_DATE: secondDate,
+  }));
+  // Reach R25 without manufacturing another 23 commits. Annotated tags have
+  // independent creation times, which is exactly the evidence milestones
+  // consumes, and exercise reached/next/ETA rendering in one small fixture.
+  for (let i = 2; i < 25; i++) {
+    const version = `v1.0.${i}`;
+    const tagDate = `2026-08-29T00:${String(i).padStart(2, '0')}:00+09:00`;
+    requireGitSuccess(`git tag ${version}`, git(['tag', '-a', version, '-m', version], {
+      GIT_COMMITTER_DATE: tagDate,
+    }));
+  }
+  requireNoHangul('release cadence with measured history', run(['release', 'cadence', '--path', project]));
+  requireNoHangul('round-history with tags', run(['round-history', '--path', project]));
+  requireNoHangul('milestones with reached history', run(['milestones', '--path', project]));
+
+  // Machine payloads remain the canonical, locale-independent contract. The
+  // idempotency timestamp is intentionally volatile and is normalized only
+  // for this equality assertion.
+  for (const [label, args] of surfaces) {
+    const en = normalizedJson(`${label} English JSON`, run([...args, '--json']));
+    const ko = normalizedJson(`${label} Korean JSON`, run([...args, '--json'], { ...baseEnv, LEERNESS_LANG: 'ko' }));
+    if (JSON.stringify(en) !== JSON.stringify(ko)) {
+      throw new Error(`${label} JSON contract changed with UI language`);
+    }
+  }
+
+  const koEnv = { ...baseEnv, LEERNESS_LANG: 'ko' };
+  const koreanAnchors = new Map([
+    ['release cadence', ['릴리스 빈도 진단', '누적 릴리스', '권장:']],
+    ['idempotency audit', ['위반 발견', '중복 룰']],
+    ['plan list', ['완료기준(Done-When)', 'Tasks:', '완료)']],
+    ['round-history', ['자율 라운드 통계', '누적 라운드', '최근 10 tags']],
+    ['milestones', ['도달 마일스톤', '총 라운드', '다음 마일스톤', '라운드 남음']],
+  ]);
+  for (const [label, args] of surfaces) {
+    const output = requireSuccess(`${label} Korean control`, run(args, koEnv));
+    const missing = koreanAnchors.get(label).filter(anchor => !output.includes(anchor));
+    if (missing.length) throw new Error(`${label} Korean control lost anchors: ${missing.join(', ')}`);
+  }
+
+  // Exercise the terminal 500+ renderer without spawning another 475 `git tag`
+  // processes. Lightweight semver refs are valid release tags and one atomic
+  // update-ref process gives the real CLI a 500-tag history.
+  const headResult = git(['rev-parse', 'HEAD']);
+  requireGitSuccess('git resolve terminal milestone fixture', headResult);
+  const head = String(headResult.stdout || '').trim();
+  const refs = [];
+  for (let i = 25; i < 500; i++) refs.push(`create refs/tags/v1.0.${i} ${head}`);
+  requireGitSuccess('git create terminal milestone fixture', git(['update-ref', '--stdin'], {}, refs.join('\n') + '\n'));
+  const terminalEn = requireNoHangul('milestones all reached (English)', run(['milestones', '--path', project, '--language', 'en']));
+  if (!terminalEn.includes('all milestones reached (500+)')) {
+    throw new Error('milestones English terminal branch lost its 500+ completion marker');
+  }
+  const terminalKo = requireSuccess('milestones all reached (Korean)', run(['milestones', '--path', project], koEnv));
+  if (!terminalKo.includes('모든 마일스톤 달성 (500+)')) {
+    throw new Error('milestones Korean terminal branch lost its 500+ completion marker');
+  }
+  const terminalJson = normalizedJson('milestones terminal JSON', run(['milestones', '--path', project, '--json']));
+  if (terminalJson.totalRounds !== 500 || terminalJson.next !== null
+      || !Array.isArray(terminalJson.reached) || terminalJson.reached.at(-1)?.milestone !== 500) {
+    throw new Error('milestones terminal JSON did not preserve the 500-round contract');
+  }
+
+  console.log('✓ Five next-cluster English surfaces contain no Hangul across locale paths and edge states; 5/5 Korean controls and JSON contracts remain intact');
+} catch (error) {
+  console.error(`✗ ${error && error.message ? error.message : error}`);
+  process.exitCode = 1;
+} finally {
+  try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {}
+}