leerness 1.36.179 → 1.36.181

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 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.
+
 ## 1.36.179 — 2026-08-30
 
 - T-0091: parent-detect selftest를 OS 임시 디렉터리 상위의 외부 .leerness와 격리하고, 두 번째 temp 생성 실패 시 첫 fixture를 정리하도록 셋업 수명을 보강. 동일한 rule-add selftest 형제 경로와 결정론적 회귀 probe를 fast/core/full 게이트에 연결.

package/README.md

@@ -138,7 +138,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.179 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.181 하네스를 사용합니다. 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.179는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
+Leerness v1.36.181는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -213,7 +213,7 @@ Leerness v1.36.179는 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.179 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.181 릴리스 태그 이력** (수백 라운드) · _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.179: 2026-08-30
+Last synced by Leerness v1.36.181: 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.179';
+const VERSION = '1.36.181';
 
 // MCP lifecycle 주소 표식은 현재 CLI 호출 한 번에만 유효하다. CLI bootstrap에서 즉시 env에서
 // 떼어 두어 `--no-record`/hook처럼 presence 기록 함수에 도달하지 않는 경로도 후속 child에 유출하지 않는다.
@@ -11443,19 +11443,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 +11473,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 +13071,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 +13091,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 +13100,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 +13127,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 +13152,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 +13161,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 +13175,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 +13265,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 +13274,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 +13299,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 +13326,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 +14795,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 +14803,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 +14845,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)`));
   }
 }
 
@@ -21608,7 +21623,7 @@ function _dispatchCommand(agentId, task, writeMode, model) {
 
 const _agents = require('../lib/agents');
 // 1.9.424 (UR-0025/UR-0125 큰 핸들러 모듈화 9번째): agentsCmd → lib/agents.js (DI 위임, rest→array)
-function agentsCmd(root, sub, ...args) { return _agents.agentsCmd(root, sub, args, { VERSION, has, arg, _agentSlashHint, _allProviders, _checkAgent, _cliChat, _dispatchCommand, _harnessBrief: _tgl.toggleOn(root, 'delegation-brief') ? _harnessBrief : undefined, _loadEnvFile, _normalizeRole, _policyEnforce, _readUserProviders, _recommendAgent, _recordRun, _resolveRole, lessonsPath, taskLogPath }); }   // 1.36.30: delegation-brief 토글 OFF 면 브리프 미접두(=--raw 경로)
+function agentsCmd(root, sub, ...args) { return _agents.agentsCmd(root, sub, args, { VERSION, has, arg, uiLang: _uiLang(root), _agentSlashHint, _allProviders, _checkAgent, _cliChat, _dispatchCommand, _harnessBrief: _tgl.toggleOn(root, 'delegation-brief') ? _harnessBrief : undefined, _loadEnvFile, _normalizeRole, _policyEnforce, _readUserProviders, _recommendAgent, _recordRun, _resolveRole, lessonsPath, taskLogPath }); }   // 1.36.30: delegation-brief 토글 OFF 면 브리프 미접두(=--raw 경로)
 
 function personaCmd(root, sub, idOrName, ...rest) {
   root = absRoot(root || process.cwd());
@@ -22069,7 +22084,8 @@ function _retroOneLine(agg, lang) {
 // 1.9.169 fix: --include 명시되면 cwd 자동 추가 안 함 (explicit-only).
 //   기존: cwd/.leerness 자동 추가 → 잔존 .leerness 시 의도치 않은 카운트 증가 (e2e flake 원인)
 //   변경: --include 시 사용자가 명시한 경로만 사용. --all-apps 단독은 기존 동작 유지.
-function _collectWorkspacePaths(rootBase) {
+function _collectWorkspacePaths(rootBase, uiLang = 'ko') {
+  const t = (ko, en) => (uiLang === 'en' ? en : ko);
   const set = new Set();
   const include = arg('--include', null);
   // --include 명시 시 cwd 자동 추가 스킵 (explicit-only 보장)
@@ -22094,7 +22110,7 @@ function _collectWorkspacePaths(rootBase) {
     for (const p of String(include).split(',')) {
       const abs = path.resolve(p.trim());
       if (exists(path.join(abs, '.leerness'))) set.add(abs);
-      else warn(`--include 무시: ${abs} (.leerness 없음)`);
+      else warn(t(`--include 무시: ${abs} (.leerness 없음)`, `Ignoring --include: ${abs} (no .leerness directory)`));
     }
   }
   return Array.from(set);
@@ -22221,9 +22237,10 @@ function _retroWorkspace(rootBase, cutoff) {
 
 function insightsCmd(root) {
   root = absRoot(root);
+  const _L = _uiLang(root); const t = (ko, en) => (_L === 'en' ? en : ko);
   // 1.9.15: --all-apps / --include 통합 모드
   if (has('--all-apps') || arg('--include', null)) {
-    return _insightsWorkspace(root);
+    return _insightsWorkspace(root, _L);
   }
   const agg = _retroAggregate(root);   // insights 는 누적 지표 명령 — 기간 필터 없음(retro 만 --days). 1.36.38 광역치환 오적용 교정.
   // 1.9.16: --json
@@ -22233,49 +22250,50 @@ function insightsCmd(root) {
     return;
   }
   const sc = readSessionCounter(root);
-  log(`# Insights — 누적 통계`);
-  log(`\n## 📊 핵심 지표`);
-  log(`  - 누적 task: ${agg.totalTasks} (done ${agg.doneCount}, in-progress ${agg.statusCounts['in-progress']}, planned ${agg.statusCounts.planned})`);
-  log(`  - 누적 결정 (decisions.md): ${agg.decisionBlocks}건`);
-  log(`  - 누적 스킬: ${agg.skillUsage.length}종`);
-  log(`  - 총 스킬 사용: ${agg.totalSkillUsage}회`);
-  log(`  - 총 최적화 누적: ${agg.totalOptimizations}건`);
-  log(`  - 활성 룰: ${agg.activeRules}건 (검증 ${agg.verifiedRules}건)`);
-  log(`  - session close 횟수: ${sc.count}회${sc.lastCloseAt ? ' (마지막: ' + sc.lastCloseAt.slice(0, 16) + ')' : ''}`);
+  log(t(`# Insights — 누적 통계`, `# Insights — cumulative statistics`));
+  log(t(`\n## 📊 핵심 지표`, `\n## 📊 Key metrics`));
+  log(t(`  - 누적 task: ${agg.totalTasks} (done ${agg.doneCount}, in-progress ${agg.statusCounts['in-progress']}, planned ${agg.statusCounts.planned})`, `  - Tasks: ${agg.totalTasks} (done ${agg.doneCount}, in-progress ${agg.statusCounts['in-progress']}, planned ${agg.statusCounts.planned})`));
+  log(t(`  - 누적 결정 (decisions.md): ${agg.decisionBlocks}건`, `  - Decisions (decisions.md): ${agg.decisionBlocks}`));
+  log(t(`  - 누적 스킬: ${agg.skillUsage.length}종`, `  - Skills: ${agg.skillUsage.length}`));
+  log(t(`  - 총 스킬 사용: ${agg.totalSkillUsage}회`, `  - Total skill uses: ${agg.totalSkillUsage}`));
+  log(t(`  - 총 최적화 누적: ${agg.totalOptimizations}건`, `  - Total optimizations: ${agg.totalOptimizations}`));
+  log(t(`  - 활성 룰: ${agg.activeRules}건 (검증 ${agg.verifiedRules}건)`, `  - Active rules: ${agg.activeRules} (${agg.verifiedRules} verified)`));
+  log(t(`  - session close 횟수: ${sc.count}회${sc.lastCloseAt ? ' (마지막: ' + sc.lastCloseAt.slice(0, 16) + ')' : ''}`, `  - Session closes: ${sc.count}${sc.lastCloseAt ? ' (last: ' + sc.lastCloseAt.slice(0, 16) + ')' : ''}`));
 
   if (agg.skillUsage.length) {
-    log(`\n## 🏆 가장 활용도 높은 스킬 (top 5)`);
-    agg.skillUsage.slice(0, 5).forEach((s, i) => log(`  ${i + 1}. ${s.id} (${s.displayNameKo}) — 사용 ${s.count}회, 최적화 ${s.optimizations}건`));
+    log(t(`\n## 🏆 가장 활용도 높은 스킬 (top 5)`, `\n## 🏆 Most-used skills (top 5)`));
+    agg.skillUsage.slice(0, 5).forEach((s, i) => log(t(`  ${i + 1}. ${s.id} (${s.displayNameKo}) — 사용 ${s.count}회, 최적화 ${s.optimizations}건`, `  ${i + 1}. ${s.id} — ${s.count} uses, ${s.optimizations} optimizations`)));
   }
 
   if (agg.durations.length) {
     const total = agg.durations.reduce((a, b) => a + b, 0);
-    log(`\n## ⏱ 검증 시간 (verify-code)`);
-    log(`  - 실행: ${agg.durations.length}회 / 총 ${total}ms / 평균 ${Math.round(total / agg.durations.length)}ms`);
-    log(`  - 최소 ${Math.min(...agg.durations)}ms / 최대 ${Math.max(...agg.durations)}ms`);
+    log(t(`\n## ⏱ 검증 시간 (verify-code)`, `\n## ⏱ Verification time (verify-code)`));
+    log(t(`  - 실행: ${agg.durations.length}회 / 총 ${total}ms / 평균 ${Math.round(total / agg.durations.length)}ms`, `  - Runs: ${agg.durations.length} / total ${total}ms / average ${Math.round(total / agg.durations.length)}ms`));
+    log(t(`  - 최소 ${Math.min(...agg.durations)}ms / 최대 ${Math.max(...agg.durations)}ms`, `  - Minimum ${Math.min(...agg.durations)}ms / maximum ${Math.max(...agg.durations)}ms`));
   }
 
-  log(`\n## 🔁 안정성 지표`);
-  log(`  - pass 시그널: ${agg.passSignals} · fix 시그널: ${agg.fixSignals}`);
+  log(t(`\n## 🔁 안정성 지표`, `\n## 🔁 Stability signals`));
+  log(t(`  - pass 시그널: ${agg.passSignals} · fix 시그널: ${agg.fixSignals}`, `  - Pass signals: ${agg.passSignals} · fix signals: ${agg.fixSignals}`));
   const ratio = agg.fixSignals > 0 ? (agg.passSignals / agg.fixSignals).toFixed(2) : '∞';
-  log(`  - pass/fix 비율: ${ratio}${ratio === '∞' || parseFloat(ratio) > 3 ? ' (안정)' : parseFloat(ratio) < 1 ? ' (디버그 위주)' : ' (보통)'}`);
+  log(t(`  - pass/fix 비율: ${ratio}${ratio === '∞' || parseFloat(ratio) > 3 ? ' (안정)' : parseFloat(ratio) < 1 ? ' (디버그 위주)' : ' (보통)'}`, `  - Pass/fix ratio: ${ratio}${ratio === '∞' || parseFloat(ratio) > 3 ? ' (stable)' : parseFloat(ratio) < 1 ? ' (debug-heavy)' : ' (normal)'}`));
 
-  log(`\n## 📈 권장`);
-  if (agg.totalOptimizations === 0) log(`  - 스킬에 최적화 누적 없음 — \`leerness skill optimize <id> --before --after\`로 더 나은 방법 기록`);
-  if (sc.count >= 5 && sc.count % 5 === 0) log(`  - 5세션마다 자동 깊은 회고가 예정되어 있습니다 — session close가 자동 호출`);
-  if (agg.statusCounts.blocked > 0) log(`  - blocked 작업 ${agg.statusCounts.blocked}건 — \`leerness lessons --query "blocked"\`로 과거 패턴 회수`);
+  log(t(`\n## 📈 권장`, `\n## 📈 Recommendations`));
+  if (agg.totalOptimizations === 0) log(t(`  - 스킬에 최적화 누적 없음 — \`leerness skill optimize <id> --before --after\`로 더 나은 방법 기록`, `  - No skill optimizations recorded — use \`leerness skill optimize <id> --before --after\` to record a better method`));
+  if (sc.count >= 5 && sc.count % 5 === 0) log(t(`  - 5세션마다 자동 깊은 회고가 예정되어 있습니다 — session close가 자동 호출`, `  - An automatic deep retrospective is scheduled every five sessions and runs during session close`));
+  if (agg.statusCounts.blocked > 0) log(t(`  - blocked 작업 ${agg.statusCounts.blocked}건 — \`leerness lessons --query "blocked"\`로 과거 패턴 회수`, `  - ${agg.statusCounts.blocked} blocked task(s) — use \`leerness lessons --query "blocked"\` to retrieve past patterns`));
 }
 
-function _insightsWorkspace(rootBase) {
-  const paths = _collectWorkspacePaths(rootBase);
-  if (!paths.length) return fail('대상 프로젝트 없음. --include 또는 --all-apps 사용.');
+function _insightsWorkspace(rootBase, uiLang = _uiLang(rootBase)) {
+  const t = (ko, en) => (uiLang === 'en' ? en : ko);
+  const paths = _collectWorkspacePaths(rootBase, uiLang);
+  if (!paths.length) return fail(t('대상 프로젝트 없음. --include 또는 --all-apps 사용.', 'No target projects. Use --include or --all-apps.'));
   // 1.9.16: --json
   if (has('--json')) {
     const projects = paths.map(p => ({ project: path.basename(p), path: p, data: _retroJsonData(_retroAggregate(p)) }));
     log(JSON.stringify({ projects, projectCount: paths.length }, null, 2));
     return;
   }
-  log(`# Workspace Insights — ${paths.length}개 프로젝트`);
+  log(t(`# Workspace Insights — ${paths.length}개 프로젝트`, `# Workspace Insights — ${paths.length} project(s)`));
   log(`\n| Project | Task | Done % | Decisions | Skills | Usage | Opts | Pass/Fix |`);
   log(`|---|---|---|---|---|---|---|---|`);
   const totals = { tasks: 0, done: 0, decisions: 0, skills: 0, usage: 0, opts: 0, pass: 0, fix: 0 };
@@ -22291,11 +22309,11 @@ function _insightsWorkspace(rootBase) {
   const tpf = totals.fix ? (totals.pass / totals.fix).toFixed(1) : '∞';
   const tDonePct = totals.tasks ? Math.round(totals.done / totals.tasks * 100) : 0;
   log(`| **TOTAL** | **${totals.tasks}** | **${tDonePct}%** | **${totals.decisions}** | **${totals.skills}** | **${totals.usage}** | **${totals.opts}** | **${totals.pass}/${totals.fix} (${tpf})** |`);
-  log(`\n## 📈 평가`);
-  if (totals.pass > totals.fix * 3) log(`  - 안정성: 우수 (pass÷fix = ${tpf})`);
-  else if (totals.pass > totals.fix) log(`  - 안정성: 보통 (pass÷fix = ${tpf})`);
-  else if (totals.fix > 0) log(`  - 안정성: 주의 (fix가 pass보다 많음) — verify-code 자동화 검토`);
-  if (totals.opts === 0) log(`  - 최적화 누적 없음 — \`leerness skill optimize\` 활용 권장`);
+  log(t(`\n## 📈 평가`, `\n## 📈 Assessment`));
+  if (totals.pass > totals.fix * 3) log(t(`  - 안정성: 우수 (pass÷fix = ${tpf})`, `  - Stability: strong (pass÷fix = ${tpf})`));
+  else if (totals.pass > totals.fix) log(t(`  - 안정성: 보통 (pass÷fix = ${tpf})`, `  - Stability: moderate (pass÷fix = ${tpf})`));
+  else if (totals.fix > 0) log(t(`  - 안정성: 주의 (fix가 pass보다 많음) — verify-code 자동화 검토`, `  - Stability: caution (more fix than pass signals) — consider automating verify-code`));
+  if (totals.opts === 0) log(t(`  - 최적화 누적 없음 — \`leerness skill optimize\` 활용 권장`, `  - No optimizations recorded — consider using \`leerness skill optimize\``));
 }
 
 // 1.9.16: brainstorm 핵심 로직 분리 — 단일 프로젝트 결과 반환
@@ -31603,7 +31621,7 @@ async function main() {
   if (cmd === 'anchors')                           return anchorsCmd(arg('--path', null) || _taskPositionalPath(args, 1) || process.cwd(), args[1] && !args[1].startsWith('-') ? args[1] : null);   // 1.36.36: 정체성앵커 초안
   // 1.36.108 (T-0097): _withLock 을 넘긴다 — lib 모듈이 락을 deps 로 받는 기존 관례(clarify·referee·routing·bugfix)에
   //   toggles 만 빠져 있어 `toggle set` 이 락 밖 read-modify-write 였다(런타임 계측으로 실측).
-  if (cmd === 'toggle')                            return _tgl.toggleCmd(arg('--path', process.cwd()), args[1], args[2], args[3], { has, VERSION, _withLock });   // 1.36.30: 기능 토글 (그래프 ⚙ 탭 연동)
+  if (cmd === 'toggle')                            return _tgl.toggleCmd(arg('--path', process.cwd()), args[1], args[2], args[3], { has, VERSION, uiLang: _uiLang(arg('--path', process.cwd())), _withLock });   // 1.36.30: 기능 토글 (그래프 ⚙ 탭 연동)
   // 1.36.53 (UR-0062): 기술 프로필 · 1.36.67 (F15): 변경 시 기존 leerness.html 동반 갱신(있을 때만)
   if (cmd === 'tech')                              return _tech.techCmd(arg('--path', null) || _taskPositionalPath(args, 1) || process.cwd(), _optSub(args), { has, regenGraph: (r) => { if (exists(path.join(r, 'leerness.html'))) _graph.graphHtmlCmd(r, { _roadmapData, _loadDecisions, _loadLessons, _parseFeatureGraph, _loadToggles: _tgl.loadToggles, _toggleRegistry: _tgl.TOGGLE_REGISTRY, _loadTechProfile: _tech.loadTechProfile, quiet: true }); } });
   // 1.36.98 (P-0013): 재사용 인벤토리 — 새 화면 조각을 만들기 전에 '이미 있는 것' 을 먼저 본다(reuse-map 의 UI 판).

package/lib/agents.js

@@ -44,6 +44,8 @@ function agentsCmd(root, sub, args = [], deps = {}) {
   const { VERSION, has, arg, _agentSlashHint, _allProviders, _checkAgent, _cliChat, _dispatchCommand, _harnessBrief, _loadEnvFile, _normalizeRole, _policyEnforce, _readUserProviders, _recommendAgent, _recordRun, _resolveRole, lessonsPath, taskLogPath } = deps;
   const _spawnPortable = deps._spawnPortable || spawnPortable;
   root = absRoot(root || process.cwd());
+  const en = deps.uiLang === 'en';
+  const t = (ko, enText) => (en ? enText : ko);
   // 1.9.435 (11th 외부평가 Codex P2, UR-0137): dispatch/multi task 파싱 — flag 값이 task 본문에 흡수되던 버그 수정.
   //   상위(bin)에서 args 는 '--to' flag 만 제거되고 값(codex)은 positional 로 남아 기존 filter 가 task 에 흡수시켰음.
   //   → flag 에서 break + lib 가 소비하는 값-flag(--to/--model/--role/--only) 값을 제외. 명시 task 는 --task 폴백.
@@ -63,36 +65,66 @@ function agentsCmd(root, sub, args = [], deps = {}) {
     const userIds = new Set(_readUserProviders(root).map(u => u.id));
     const checks = providers.map(a => ({ ...(_checkAgent(a)), source: userIds.has(a.id) ? 'user' : 'builtin' }));
     if (has('--json')) { log(JSON.stringify({ agents: checks }, null, 2)); return; }
-    log(`# 외부 AI CLI 오케스트레이션 (1.9.30)`);
+    log(t(`# 외부 AI CLI 오케스트레이션 (1.9.30)`, `# External AI CLI orchestration (1.9.30)`));
     log('');
-    log(`| Agent | source | env (${'env=1 활성'}) | 설치 | 버전 | 상태 |`);
+    log(t(`| Agent | source | env (${'env=1 활성'}) | 설치 | 버전 | 상태 |`, `| Agent | source | env (env=1 enabled) | installed | version | status |`));
     log(`|---|---|---|---|---|---|`);
     for (const c of checks) {
       const envMark = c.enabled ? '✓' : '✗';
       const instMark = c.installed ? '✓' : '✗';
-      const statusEmoji = c.status === 'ready' ? '🟢 ready' : c.status === 'not-installed' ? '⚪ 미설치' : c.status === 'disabled' ? '🟡 비활성' : '❓';
+      const statusEmoji = c.status === 'ready' ? '🟢 ready'
+        : c.status === 'not-installed' ? t('⚪ 미설치', '⚪ not installed')
+          : c.status === 'disabled' ? t('🟡 비활성', '🟡 disabled') : '❓';
       log(`| ${c.id} | ${c.source} | ${envMark} ${c.envFlag} | ${instMark} | ${c.version || '-'} | ${statusEmoji} |`);
     }
     //   1.36.94: 무시한 설정을 **평문에서도** 말한다 — JSON 에만 넣으면 사람은 왜 미설치로 보이는지 모른다.
     const _rejected = checks.filter(c => c.binRejected || c.versionArgsRejected);
     if (_rejected.length) {
       log('');
-      _rejected.forEach(c => log(`⚠ ${c.id}: ${c.binRejected || c.versionArgsRejected}`));
+      _rejected.forEach(c => {
+        // Rejection reasons are canonical diagnostic fields and remain unchanged
+        // in --json. Human English output uses a semantic rendering so Korean
+        // sanitizer text (including provider-specific reasons) cannot leak.
+        const reason = en
+          ? (c.binRejected
+            ? 'providers.json bin is not a safe executable name/path, so it was not run'
+            : 'providers.json versionArgs contain unsafe shell syntax, so they were ignored and --version was used')
+          : (c.binRejected || c.versionArgsRejected);
+        log(`⚠ ${c.id}: ${reason}`);
+      });
     }
     const ready = checks.filter(c => c.status === 'ready');
     log('');
-    log(`## 활성 (${ready.length}/${checks.length}): ${ready.map(c => c.id).join(', ') || '(없음)'}`);
+    log(t(
+      `## 활성 (${ready.length}/${checks.length}): ${ready.map(c => c.id).join(', ') || '(없음)'}`,
+      `## Active (${ready.length}/${checks.length}): ${ready.map(c => c.id).join(', ') || '(none)'}`,
+    ));
     if (!ready.length) {
       log('');
-      log(`💡 활성화 방법:`);
-      log(`  1) CLI 설치 (예: \`npm i -g @openai/codex-cli\`, \`npm i -g @google/antigravity-cli\`)`);
-      log(`  2) .env 또는 환경변수: LEERNESS_ENABLE_CODEX=1, LEERNESS_ENABLE_AGY=1`);
-      log(`  3) \`leerness agents check\`로 재확인`);
-      log(`  💡 1.9.157: 빌트인 외 CLI 추가: \`leerness provider add <id> --bin <cmd>\``);
+      log(t(`💡 활성화 방법:`, `💡 How to enable:`));
+      log(t(
+        `  1) CLI 설치 (예: \`npm i -g @openai/codex-cli\`, \`npm i -g @google/antigravity-cli\`)`,
+        `  1) Install a CLI (for example, \`npm i -g @openai/codex-cli\` or \`npm i -g @google/antigravity-cli\`)`,
+      ));
+      log(t(
+        `  2) .env 또는 환경변수: LEERNESS_ENABLE_CODEX=1, LEERNESS_ENABLE_AGY=1`,
+        `  2) Set .env or environment variables: LEERNESS_ENABLE_CODEX=1, LEERNESS_ENABLE_AGY=1`,
+      ));
+      log(t(`  3) \`leerness agents check\`로 재확인`, `  3) Run \`leerness agents check\` to check again`));
+      log(t(
+        `  💡 1.9.157: 빌트인 외 CLI 추가: \`leerness provider add <id> --bin <cmd>\``,
+        `  💡 1.9.157: Add a CLI beyond the built-ins: \`leerness provider add <id> --bin <cmd>\``,
+      ));
     } else {
       log('');
-      log(`💡 메인 에이전트가 sub-agent 분배 시 위 ${ready.length}개 CLI 활용 가능:`);
-      log(`   \`leerness agents dispatch "<task>" --to <id>\` 로 프롬프트 전달`);
+      log(t(
+        `💡 메인 에이전트가 sub-agent 분배 시 위 ${ready.length}개 CLI 활용 가능:`,
+        `💡 The primary agent can use the ${ready.length} enabled CLI(s) for sub-agent delegation:`,
+      ));
+      log(t(
+        `   \`leerness agents dispatch "<task>" --to <id>\` 로 프롬프트 전달`,
+        `   Pass a prompt with \`leerness agents dispatch "<task>" --to <id>\``,
+      ));
     }
     return;
   }

package/lib/toggles.js

@@ -27,6 +27,17 @@ const TOGGLE_REGISTRY = {
   'double-verify': { desc: '완료 전 재확인 지시문(같은 것을 다시 확인하라는 안내) — 끄면 안내만 생략된다 (gate/verify-claim 실행은 그대로)', affects: 'handoff · lens 안내' },
   'full-reread': { desc: '매 세션 관련 문서 전체 재독 지시문 — 끄면 "필요할 때 읽어라" 로 바뀐다 (문서와 상태는 그대로 남는다)', affects: 'handoff 안내' },
 };
+const TOGGLE_REGISTRY_EN = {
+  'gate': { desc: 'completion gate (integrated verify+audit+scan+encoding+lazy checks)', affects: 'leerness gate' },
+  'lens': { desc: 'quality-lens self-questions (domain checks before claiming completion)', affects: 'leerness lens' },
+  'auto-graph': { desc: 'automatically refresh the ontology graph (leerness.html) on install/session-close', affects: 'install · session close' },
+  'delegation-brief': { desc: 'prepend the Leerness protocol brief when delegating to a background AI', affects: 'agents dispatch · agents multi' },
+  'bugfix-receipt': { desc: 'bugfix completion gate — tasks with a registered probe must pass it and record root cause/sibling scope before done (OFF by default)', affects: 'task update --status done · task sync --from' },
+  'difficulty-routing': { desc: 'route work by difficulty — allows --confirm for leerness agents route; high-risk work still requires --approved-by (OFF by default)', affects: 'leerness agents route --confirm' },
+  'workflow-distribute': { desc: 'the distribute (sub-agent) instruction in the session workflow; disabling it removes only the instruction, not evidence checks', affects: 'handoff · session-workflow guidance' },
+  'double-verify': { desc: 'the instruction to recheck work before completion; disabling it omits only the guidance, not gate/verify-claim execution', affects: 'handoff · lens guidance' },
+  'full-reread': { desc: 'the instruction to reread every related document each session; disabling it changes the wording to read when needed', affects: 'handoff guidance' },
+};
 const _hasToggle = (id) => Object.prototype.hasOwnProperty.call(TOGGLE_REGISTRY, id);
 // P-0009 경계 계약: 토글로 끌 수 있는 것은 '지시문' 뿐이다. 아래 목록은 **어떤 토글 조합에서도** 살아 있어야 하며,
 //   변이 테스트가 이 계약을 고정한다(계약이 깨지면 토글을 출하하지 않는다는 것이 승인 조건이었다).
@@ -100,6 +111,11 @@ function saveToggles(root, toggles) {
 function toggleCmd(root, sub, id, val, deps = {}) {
   const { has, VERSION } = deps;
   root = absRoot(root);
+  const en = deps.uiLang === 'en';
+  const t = (ko, enText) => (en ? enText : ko);
+  const reasonText = reason => (en
+    ? (reason === '최상위가 객체가 아닙니다' ? 'top level is not an object' : reason === 'JSON 파싱 실패' ? 'JSON parse failed' : reason)
+    : reason);
   // 1.36.108 (T-0097): 변경 하위명령은 읽기~쓰기 전체를 락으로 직렬화한다 — clarify/referee/routing 과 같은 관례.
   //   종전엔 이 모듈만 관례에서 빠져 있어 동시 `toggle set` 이 서로의 값을 덮었다(런타임 계측으로 실측: 락 X).
   //   재진입 플래그(_locked)로 자기 재호출을 한 번만 감싼다.
@@ -111,17 +127,24 @@ function toggleCmd(root, sub, id, val, deps = {}) {
   const cur = _chk.toggles;
   if (!sub || sub === 'list') {
     if (json) { log(JSON.stringify({ version: VERSION, toggles: cur, corrupt: !!_chk.corrupt, corruptReason: _chk.reason, registry: TOGGLE_REGISTRY }, null, 2)); return; }
-    log(`# leerness toggle — 기능 토글 (온톨로지 그래프 뷰 ⚙ 탭과 연동)`);
+    log(t(`# leerness toggle — 기능 토글 (온톨로지 그래프 뷰 ⚙ 탭과 연동)`, `# leerness toggle — feature toggles (synced with the ontology graph ⚙ tab)`));
     // 손상 시 "그냥 OFF" 로 보이면 켜 뒀던 게이트가 꺼진 줄 모른다 — 사실을 먼저 알린다(헌트 #5).
-    if (_chk.corrupt) log(`  ⚠ toggles.json 손상(${_chk.reason}) — 아래는 **저장값이 아니라 기본값**입니다. 켜 두었던 토글이 꺼져 보일 수 있습니다: ${_togglesPath(root)}`);
+    if (_chk.corrupt) log(t(
+      `  ⚠ toggles.json 손상(${_chk.reason}) — 아래는 **저장값이 아니라 기본값**입니다. 켜 두었던 토글이 꺼져 보일 수 있습니다: ${_togglesPath(root)}`,
+      `  ⚠ toggles.json is corrupt (${reasonText(_chk.reason)}) — values below are **defaults, not stored values**. A previously enabled toggle may appear disabled: ${_togglesPath(root)}`,
+    ));
     for (const [k, meta] of Object.entries(TOGGLE_REGISTRY)) {
-      log(`  ${cur[k] ? '🟢 ON ' : '⚪ OFF'}  ${k.padEnd(17)} ${meta.desc}  [${meta.affects}]`);
+      const shown = en ? TOGGLE_REGISTRY_EN[k] : meta;
+      log(`  ${cur[k] ? '🟢 ON ' : '⚪ OFF'}  ${k.padEnd(17)} ${shown.desc}  [${shown.affects}]`);
     }
-    log(`\n  변경: leerness toggle set <id> on|off  ·  그래프 뷰: leerness graph --html → leerness.html 의 ⚙ 탭`);
+    log(t(
+      `\n  변경: leerness toggle set <id> on|off  ·  그래프 뷰: leerness graph --html → leerness.html 의 ⚙ 탭`,
+      `\n  Change: leerness toggle set <id> on|off  ·  Graph view: leerness graph --html → the ⚙ tab in leerness.html`,
+    ));
     return;
   }
   if (sub === 'get') {
-    if (!_hasToggle(id)) { fail(`알 수 없는 토글: ${id} (가능: ${Object.keys(TOGGLE_REGISTRY).join(', ')})`); process.exitCode = 1; return; }
+    if (!_hasToggle(id)) { fail(t(`알 수 없는 토글: ${id} (가능: ${Object.keys(TOGGLE_REGISTRY).join(', ')})`, `Unknown toggle: ${id} (valid: ${Object.keys(TOGGLE_REGISTRY).join(', ')})`)); process.exitCode = 1; return; }
     const payload = {
       ok: true,
       id,
@@ -135,29 +158,29 @@ function toggleCmd(root, sub, id, val, deps = {}) {
       meta: TOGGLE_REGISTRY[id],
     };
     if (json) { log(JSON.stringify(payload, null, 2)); return payload; }
-    if (_chk.corrupt) log(`  ⚠ toggles.json 손상(${_chk.reason}) — 아래 값은 저장값이 아니라 기본값입니다: ${_togglesPath(root)}`);
-    if (payload.unreadable) log(`  ⚠ ${id} 저장값을 해석할 수 없어 기본값으로 표시합니다.`);
-    log(`${payload.value ? '🟢 ON' : '⚪ OFF'}  ${id} — ${TOGGLE_REGISTRY[id].desc}  [${payload.source}]`);
+    if (_chk.corrupt) log(t(`  ⚠ toggles.json 손상(${_chk.reason}) — 아래 값은 저장값이 아니라 기본값입니다: ${_togglesPath(root)}`, `  ⚠ toggles.json is corrupt (${reasonText(_chk.reason)}) — the value below is a default, not a stored value: ${_togglesPath(root)}`));
+    if (payload.unreadable) log(t(`  ⚠ ${id} 저장값을 해석할 수 없어 기본값으로 표시합니다.`, `  ⚠ The stored value for ${id} is unreadable, so the default is shown.`));
+    log(`${payload.value ? '🟢 ON' : '⚪ OFF'}  ${id} — ${(en ? TOGGLE_REGISTRY_EN[id] : TOGGLE_REGISTRY[id]).desc}  [${payload.source}]`);
     return payload;
   }
   if (sub === 'set') {
-    if (!_hasToggle(id)) { fail(`알 수 없는 토글: ${id} (가능: ${Object.keys(TOGGLE_REGISTRY).join(', ')})`); process.exitCode = 1; return; }
+    if (!_hasToggle(id)) { fail(t(`알 수 없는 토글: ${id} (가능: ${Object.keys(TOGGLE_REGISTRY).join(', ')})`, `Unknown toggle: ${id} (valid: ${Object.keys(TOGGLE_REGISTRY).join(', ')})`)); process.exitCode = 1; return; }
     const on = String(val).toLowerCase();
-    if (on !== 'on' && on !== 'off') { fail(`값은 on|off (받음: ${val})`); process.exitCode = 1; return; }
+    if (on !== 'on' && on !== 'off') { fail(t(`값은 on|off (받음: ${val})`, `Value must be on|off (received: ${val})`)); process.exitCode = 1; return; }
     // 1.36.49 (codex 6차 #5): 손상 toggles.json 위에 set 하면 loadToggles 의 기본값 폴백이 저장돼
     //   무관한 토글(예: gate:false)이 무언 ON 으로 리셋됐다 — 변경 진입점은 fail-closed (1.36.28 스토어 손상 클래스).
     const f = _togglesPath(root);
     if (exists(f)) {
       try { JSON.parse(read(f)); }
-      catch { fail(`toggles.json 손상(JSON 파싱 실패) — 덮어쓰기 거부: ${f}\n  복구하거나 삭제(전 토글 기본 ON 복원) 후 재시도`); process.exitCode = 1; return; }
+      catch { fail(t(`toggles.json 손상(JSON 파싱 실패) — 덮어쓰기 거부: ${f}\n  복구하거나 삭제(전 토글 기본 ON 복원) 후 재시도`, `toggles.json is corrupt (JSON parse failed) — refusing to overwrite: ${f}\n  Repair it or delete it to restore defaults, then retry`)); process.exitCode = 1; return; }
     }
     cur[id] = on === 'on';
     saveToggles(root, cur);
     if (json) { log(JSON.stringify({ ok: true, id, value: cur[id], toggles: cur }, null, 2)); return; }
-    ok(`toggle ${id} = ${on.toUpperCase()}${cur[id] ? '' : ' — 관련 명령이 스킵 동작으로 전환됩니다'}`);
+    ok(`toggle ${id} = ${on.toUpperCase()}${cur[id] ? '' : t(' — 관련 명령이 스킵 동작으로 전환됩니다', ' — related commands will switch to skip behavior')}`);
     return;
   }
-  fail(`알 수 없는 하위명령: ${sub} (가능: list, get, set)`); process.exitCode = 1;
+  fail(t(`알 수 없는 하위명령: ${sub} (가능: list, get, set)`, `Unknown subcommand: ${sub} (valid: list, get, set)`)); process.exitCode = 1;
 }
 
 module.exports = { TOGGLE_REGISTRY, SCAFFOLD_TOGGLES, EVIDENCE_COMMANDS, loadToggles, loadTogglesChecked, toggleOn, saveToggles, toggleCmd, _togglesPath, _coerceToggle };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.179",
+  "version": "1.36.181",
   "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,18 +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 ./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 ./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/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 && 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;
@@ -11027,12 +11028,18 @@ total++;
     // 1.36.112: 106 으로 조인다. `context budget` 을 손대는 김에 영어화해 5줄을 갚았다(111 → 106, 실측).
     //   갚은 만큼만 낮춘다 — 여유를 남기면 그 안에서 조용히 썩는다(1.36.82 의 자기참조 가드에서 겪은 형태).
     // 1.36.174: provider list 영어 모드의 요약/안내 두 줄을 영어화해 104로 조임(39개 명령 실측).
-    const BASELINE = 104;
+    // 1.36.180: agents list(18) + insights(17) + toggle list(11) 우선 표면을 영어화해 58로 조임.
+    // 1.36.181: 공동 최상위 release cadence/idempotency audit/plan list/round-history(각 5)를 영어화해 38로 조임.
+    const BASELINE = 38;
     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']
+      .every(cmd => measured.get(cmd) === 0);
     // 한국어 사용자가 보던 것은 **바뀌면 안 된다**. 영어화하면서 `개` 단위를 양쪽에서 없애는 회귀를 냈고
     //   직전 커밋과의 바이트 비교가 잡았다. 여기서는 한국어 출력이 여전히 한국어 관례를 지키는지 단언한다.
     const koEnv = Object.assign({}, ENV, { LEERNESS_LANG: 'ko' });
@@ -11045,9 +11052,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,242 @@
+'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 = {}) {
+  return cp.spawnSync('git', args, {
+    cwd: project,
+    env: { ...baseEnv, ...extraEnv },
+    encoding: 'utf8',
+    timeout: 30000,
+  });
+}
+
+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;
+  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]],
+];
+
+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,
+  }));
+  requireNoHangul('release cadence with measured history', run(['release', 'cadence', '--path', project]));
+  requireNoHangul('round-history with tags', run(['round-history', '--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']],
+  ]);
+  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(', ')}`);
+  }
+
+  console.log('✓ Four next-cluster English surfaces contain no Hangul across locale paths and edge states; 4/4 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 {}
+}

package/scripts/i18n-priority-surface-probe.js

@@ -0,0 +1,145 @@
+'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-priority-'));
+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',
+};
+// The English assertions must be driven by the project manifest written by
+// `init --language en`; an inherited env override would make that path untested.
+delete baseEnv.LEERNESS_LANG;
+for (const key of [
+  'LEERNESS_ENABLE_CLAUDE', 'LEERNESS_ENABLE_CODEX', 'LEERNESS_ENABLE_AGY',
+  'LEERNESS_ENABLE_GROK', 'LEERNESS_ENABLE_OPENCODE', 'LEERNESS_ENABLE_QWEN',
+  'LEERNESS_ENABLE_AIDER', 'LEERNESS_ENABLE_GOOSE', 'LEERNESS_ENABLE_COPILOT',
+  'LEERNESS_ENABLE_OLLAMA',
+]) baseEnv[key] = '0';
+
+function run(args, env = baseEnv) {
+  return cp.spawnSync(process.execPath, [CLI, ...args], {
+    cwd: project,
+    env,
+    encoding: 'utf8',
+    timeout: 300000,
+  });
+}
+
+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 requireFailure(label, result) {
+  const output = outputOf(result);
+  if (result.status === 0 || !output.trim()) {
+    throw new Error(`${label} probe command unexpectedly succeeded or was silent (exit ${result.status}): ${output.slice(0, 500)}`);
+  }
+  return output;
+}
+
+function hangulLines(output) {
+  return String(output).split(/\r?\n/).filter(line => HANGUL.test(line));
+}
+
+try {
+  fs.mkdirSync(project, { recursive: true });
+  fs.writeFileSync(path.join(project, 'package.json'), '{"name":"i18n-probe","version":"0.1.0"}\n');
+  requireSuccess('init', run(['init', project, '--yes', '--language', 'en']));
+
+  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('lesson save', run(['lesson', 'save', 'Keep outputs deterministic', '--tag', 'test', '--path', project]));
+  requireSuccess('plan add', run(['plan', 'add', 'Ship the parser', '--path', project]));
+
+  // Exercise the rejected-provider branch without executing an unsafe command.
+  // `provider add` creates the canonical store; the fixture then simulates a
+  // hand-edited/remote catalog that the production sanitizer must reject.
+  requireSuccess('provider add unsafe-bin', run(['provider', 'add', 'unsafe-bin', '--bin', 'missing-i18n-bin', '--path', project]));
+  requireSuccess('provider add unsafe-args', run(['provider', 'add', 'unsafe-args', '--bin', 'missing-i18n-args', '--path', project]));
+  const providersFile = path.join(project, '.leerness', 'providers.json');
+  const providersRaw = JSON.parse(fs.readFileSync(providersFile, 'utf8'));
+  const providers = Array.isArray(providersRaw) ? providersRaw : providersRaw.providers;
+  const unsafeBin = providers.find(p => p.id === 'unsafe-bin');
+  const unsafeArgs = providers.find(p => p.id === 'unsafe-args');
+  if (!unsafeBin || !unsafeArgs) throw new Error('provider rejection fixtures were not persisted');
+  unsafeBin.bin = 'unsafe provider bin';
+  unsafeArgs.versionArgs = ['--version', '&', 'never-run'];
+  fs.writeFileSync(providersFile, JSON.stringify(providersRaw, null, 2) + '\n');
+
+  const surfaces = [
+    ['agents list', ['agents', 'list', '--path', project]],
+    ['insights', ['insights', '--path', project]],
+    ['insights workspace', ['insights', '--include', project, '--path', project]],
+    ['toggle list', ['toggle', 'list', '--path', project]],
+    ['toggle get', ['toggle', 'get', 'gate', '--path', project]],
+    ['toggle set', ['toggle', 'set', 'gate', 'off', '--path', project]],
+  ];
+  const leaks = [];
+  for (const [label, args] of surfaces) {
+    const output = requireSuccess(label, run(args));
+    const lines = hangulLines(output);
+    if (lines.length) leaks.push(`${label}=${lines.length} (${lines.slice(0, 2).join(' | ')})`);
+  }
+
+  const koEnv = { ...baseEnv, LEERNESS_LANG: 'ko' };
+  for (const [label, args] of [
+    ['agents list Korean control', ['agents', 'list', '--path', project]],
+    ['insights Korean control', ['insights', '--path', project]],
+    ['toggle list Korean control', ['toggle', 'list', '--path', project]],
+  ]) {
+    const output = requireSuccess(label, run(args, koEnv));
+    if (!HANGUL.test(output)) throw new Error(`${label} lost Hangul; the probe cannot distinguish locales`);
+  }
+
+  const unknownOutput = requireFailure('toggle unknown English error', run(['toggle', 'get', 'missing-toggle', '--path', project]));
+  const unknownLines = hangulLines(unknownOutput);
+  if (unknownLines.length) leaks.push(`toggle unknown error=${unknownLines.length} (${unknownLines.slice(0, 2).join(' | ')})`);
+
+  const toggleFile = path.join(project, '.leerness', 'toggles.json');
+  fs.writeFileSync(toggleFile, '{broken json\n');
+  const corruptList = requireSuccess('toggle corrupt list', run(['toggle', 'list', '--path', project]));
+  const corruptSet = requireFailure('toggle corrupt set', run(['toggle', 'set', 'gate', 'on', '--path', project]));
+  for (const [label, output] of [['toggle corrupt list', corruptList], ['toggle corrupt set', corruptSet]]) {
+    const lines = hangulLines(output);
+    if (lines.length) leaks.push(`${label}=${lines.length} (${lines.slice(0, 2).join(' | ')})`);
+  }
+
+  // Machine output remains locale-neutral in shape: do not expose the private
+  // English projection or replace the canonical registry payload.
+  fs.rmSync(toggleFile, { force: true });
+  const toggleJson = JSON.parse(requireSuccess('toggle JSON contract', run(['toggle', 'list', '--path', project, '--json'])));
+  if (!toggleJson.registry || !toggleJson.registry.gate || toggleJson.registry.gate.descEn !== undefined
+    || !HANGUL.test(toggleJson.registry.gate.desc || '')) {
+    throw new Error('toggle JSON registry no longer exposes the canonical shape');
+  }
+
+  if (leaks.length) throw new Error(`English UI leaked Hangul: ${leaks.join('; ')}`);
+  console.log('✓ English priority surfaces and edge paths contain no Hangul; 3/3 Korean controls and JSON shape 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 {}
+}