leerness 1.36.124 → 1.36.126

package/README.md

@@ -122,7 +122,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.124 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.126 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### 정체성 — AI 에이전트 운영 레이어 (UR-0030)
 
@@ -176,7 +176,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.36.124는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
+Leerness v1.36.126는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -197,7 +197,7 @@ Leerness v1.36.124는 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.124 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.126 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
 
 ### 성능 가이드
 
@@ -235,5 +235,5 @@ leerness release pack --close --auto-main-push
 - `.harness/session-handoff.md`: 다음 세션 인수인계 (자동 작성)
 - `.harness/lessons.md` / `decisions.md` / `rules.md`: 영구 메모리 (5 surface)
 
-Last synced by Leerness v1.36.124: 2026-08-16
+Last synced by Leerness v1.36.126: 2026-08-16
 <!-- leerness:project-readme:end -->

package/bin/leerness.js

@@ -34,7 +34,7 @@ const { CAPABILITY_SURFACE, POWERFUL_COMMANDS, ADAPTERS, REUSE_CATEGORIES, REUSE
 const { tokenizeForRank: _tokenizeForRank, expandQuery: _expandQuery, scoreHits: _scoreHits, suggestTerms: _suggestTerms } = require('../lib/search-core');  // 1.36.23: memory search 랭킹 코어(순수·0-deps)
 const { findCorruptedStateJson: _findCorruptedStateJson } = require('../lib/state-integrity');  // 1.36.1 (클린룸 리뷰 FN): .harness/*.json 상태 무결성 (audit/health/check 공유)
 
-const VERSION = '1.36.124';
+const VERSION = '1.36.126';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -3748,7 +3748,8 @@ function _selfTestCases() {
         } catch {}   // 심링크 생성 권한 없는 환경 → 소스 불변식만으로 판정(false-BLOCK 회피)
         if (_linked) {
           try {
-            const _rep = _migrateWorkspaceDir(_st, { dryRun: true });
+            // 1.36.126: CLI 는 fail-closed 지만 복사 구현의 안전 속성은 계속 시험한다(내부 통로).
+            const _rep = _migrateWorkspaceDir(_st, { dryRun: true, allowUnsupported: true });
             const _skipped = _rep.skippedFiles.some(f => /^loop\b/.test(f) && f.includes('symlink'));
             const _notFollowed = !_rep.copiedFiles.some(f => /^loop[\\/]/.test(f));
             symlinkGuard = symlinkGuard && _skipped && _notFollowed;
@@ -4261,7 +4262,7 @@ function _selfTestCases() {
     { name: 'UR-0074: _cadenceAssessment 릴리스 빈도 평가 (임계값) 행위 (1.9.374)', run: () => { const m = require('../lib/pure-utils'); if (typeof _cadenceAssessment !== 'function' || m._cadenceAssessment !== _cadenceAssessment || typeof releaseCadenceCmd !== 'function') return false; return _cadenceAssessment(7, 1, 1).level === 'very-high' && _cadenceAssessment(3, 1, 1).level === 'high' && _cadenceAssessment(1, 1, 1).level === 'moderate' && _cadenceAssessment(0.2, 1, 1).level === 'healthy' && _cadenceAssessment(7, 1, 1).recommendation.length > 0; } },
     { name: 'UR-0084: _withLock 획득/재진입/해제 + maxWaitMs 하드닝(10s) 행위 (1.9.375)', run: () => { if (typeof _withLock !== 'function') return false; const src = read(__filename); const hardened = /maxWaitMs = opts\.maxWaitMs \|\| 10000/.test(src); const tmp = fs.mkdtempSync(path.join(os.tmpdir(), '__leerness_lock_')); try { const target = path.join(tmp, 'f.md'); let reentrant = false; const lockSeen = _withLock(target, () => { const exists = fs.existsSync(target + '.lock'); reentrant = (_withLock(target, () => 42) === 42); return exists; }); const cleaned = !fs.existsSync(target + '.lock'); return hardened && lockSeen === true && reentrant === true && cleaned; } finally { try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {} } } },
     { name: 'UR-0073 Phase D: _teamDeployGate 이중 게이트 (dry-run 기본/env 게이트/실행) 행위 (1.9.376)', run: () => { const m = require('../lib/pure-utils'); if (typeof _teamDeployGate !== 'function' || m._teamDeployGate !== _teamDeployGate) return false; const team = { id: 'd', deployCommand: 'echo hi' }; const noCmd = _teamDeployGate({ id: 'x' }, { yes: true, envOn: true }).mode === 'no-command'; const dry = _teamDeployGate(team, { yes: false, envOn: true }).mode === 'dry-run'; const gated = _teamDeployGate(team, { yes: true, envOn: false }).mode === 'gated'; const exec = _teamDeployGate(team, { yes: true, envOn: true }).mode === 'execute'; return noCmd && dry && gated && exec; } },
-    { name: 'UR-0025: _renderWorkspaceReferenceGuide 모듈 분리 + 빌더 동작 (1.9.377)', run: () => { const m = require('../lib/pure-utils'); if (typeof _renderWorkspaceReferenceGuide !== 'function' || m._renderWorkspaceReferenceGuide !== _renderWorkspaceReferenceGuide) return false; const g = _renderWorkspaceReferenceGuide('.leerness', '9.9.9', '2026-01-01T00:00:00.000Z'); const wrapperThin = read(__filename).includes('return _renderWorkspaceReferenceGuide(dirName, VERSION, new Date().toISOString())'); return g.includes('.leerness/progress-tracker.md') && g.includes('9.9.9') && g.includes('자주 묻는 위치') && g.includes('마이그레이션 안내') && wrapperThin; } },
+    { name: 'UR-0025: _renderWorkspaceReferenceGuide 모듈 분리 + 빌더 동작 (1.9.377)', run: () => { const m = require('../lib/pure-utils'); if (typeof _renderWorkspaceReferenceGuide !== 'function' || m._renderWorkspaceReferenceGuide !== _renderWorkspaceReferenceGuide) return false; const g = _renderWorkspaceReferenceGuide('.leerness', '9.9.9', '2026-01-01T00:00:00.000Z'); const wrapperThin = read(__filename).includes('return _renderWorkspaceReferenceGuide(dirName, VERSION, new Date().toISOString())'); /* 1.36.126 (T-0107): 제목 리터럴('마이그레이션 안내')을 붙잡던 자리 — 그 절이 바로 **AI 를 죽은 사본으로 안내**하고 있었다. 제목이 아니라 계약을 건다: ① `.leerness` 상황을 다루는 절이 여전히 있고 ② 그 절이 "우선 사용/가야 함" 같은 **지시**를 하지 않는다(생성 결과 문자열에 대한 행위 단언 — 소스 자기참조가 아니다). */ const guideSafe = /\.leerness/.test(g) && !/우선 사용/.test(g) && !/로 가야 함/.test(g) && /읽지 마십시오/.test(g); return g.includes('.leerness/progress-tracker.md') && g.includes('9.9.9') && g.includes('자주 묻는 위치') && guideSafe && wrapperThin; } },
     { name: 'UR-0073: team MCP 도구 2종(read-only) 정의 + dispatch 와이어 (1.9.378)', run: () => { const tools = require('../lib/mcp-tools'); const src = read(__filename); const tl = tools.find(t => t.name === 'leerness_team_list'); const tp = tools.find(t => t.name === 'leerness_team_preview'); const defsOk = tl && tl.requiredTier === 'read-only' && tp && tp.requiredTier === 'read-only' && tp.inputSchema.required && tp.inputSchema.required.includes('id'); const wired = src.includes("case " + "'leerness_team_list':") && src.includes("case " + "'leerness_team_preview':") && /cliArgs = \['team', 'list'/.test(src) && /cliArgs = \['team', 'preview'/.test(src); return !!defsOk && wired; } },
     { name: 'UR-0025 심화: pulse 렌더 코어 분리 — _memorySurface + _renderPulseLine 행위 (1.9.379)', run: () => { const m = require('../lib/pure-utils'); if (typeof _memorySurface !== 'function' || typeof _renderPulseLine !== 'function' || m._memorySurface !== _memorySurface || m._renderPulseLine !== _renderPulseLine) return false; const ms = _memorySurface({ tasks: 1, decisions: 2, rules: 3, milestones: 4, lessons: 5 }) === 'T1/D2/R3/P4/L5' && _memorySurface({}) === 'T0/D0/R0/P0/L0'; const base = _renderPulseLine({ version: '1.0.0', roundCount: 7, mcpTools: 85, memorySurface: 'T0/D1/R0/P2/L0' }); const ln = base.includes('v1.0.0') && base.includes('R7') && base.includes('MCP 85') && base.includes('T0/D1/R0/P2/L0') && !base.includes('🎯') && !base.includes('abnormal'); const full = _renderPulseLine({ version: '1.0.0', roundCount: 7, mcpTools: 85, memorySurface: 'x', nextMilestone: 400, etaDays: 6, abnormalShutdown: 'high' }); const ln2 = full.includes('🎯 R400 (6d)') && full.includes('abnormal:high'); const wired = read(__filename).includes('const line = _renderPulseLine(data)') && read(__filename).includes('data.memorySurface = _memorySurface('); return ms && ln && ln2 && wired; } },
     { name: 'UR-0025: REQUIRED_WORKSPACE_FILES 단일출처 — verify/migrate audit·apply 3중 중복 제거 (1.9.380)', run: () => { const c = require('../lib/catalogs'); if (REQUIRED_WORKSPACE_FILES !== c.REQUIRED_WORKSPACE_FILES) return false; const listOk = Array.isArray(c.REQUIRED_WORKSPACE_FILES) && c.REQUIRED_WORKSPACE_FILES.length === 9 && c.REQUIRED_WORKSPACE_FILES.includes('AGENTS.md') && c.REQUIRED_WORKSPACE_FILES.includes('.harness/plan.md'); const harnessUses = (read(__filename).match(/const required = REQUIRED_WORKSPACE_FILES;/g) || []).length >= 1; const migUses = (read(path.join(path.dirname(__filename), '..', 'lib', 'migrate.js')).match(/const required = REQUIRED_WORKSPACE_FILES;/g) || []).length >= 2; return listOk && harnessUses && migUses; } },
@@ -4920,7 +4921,12 @@ function _selfTestCases() {
       const sigOpts = /function verifyClaimCmd\(root, taskId, opts = \{\}\)/.test(src);
       const fn = /function verifyClaimAllCmd\(root\)/.test(src);
       const doneFilter = src.includes("rows.filter(r => /done|완료|completed/i.test(String(r.status || '')))");
-      const reuse = src.includes("doneRows.map(r => verifyClaimCmd(root, r.id, { collect: true }))");
+      //   1.36.125: 여기에 `runMemo` 가 함께 넘어가는 것도 이제 **계약**이다 — 빠지면 같은 테스트 스위트를
+      //   done 행 수만큼 반복 실행한다(100주장 × 300초). 그래서 리터럴을 갱신만 하지 않고 메모 배선까지 건다.
+      //   ⚠ 실행 횟수 자체는 소스가 아니라 e2e U 블록이 **실제로 세어** 판정한다(소스가드는 배선 유무만).
+      const reuse = src.includes("doneRows.map(r => verifyClaimCmd(root, r.id, { collect: true, runMemo }))")
+        && src.includes('const runMemo = {};')
+        && src.includes('if (_runMemo) _runMemo.result = runResult;');
       // collect 게이팅 부울이 --json/human 경로와 동일 출처(분기 없음) — 정밀 검사를 일괄 모드에서도 그대로 재사용
       const collectGate = src.includes('if (opts.collect) {') && src.includes("if (!filesAllExist) reasons.push('files-missing')") && src.includes("if (claimsChecked && !strictOk) reasons.push('optimism/honesty')") && src.includes("if (!gitClaimOk) reasons.push('git-mismatch')") && src.includes("if (claimsChecked && stubFiles.length > 0) reasons.push('stub-impl')");
       const routed = src.includes("if (args[1] === '--all' || has('--all')) return verifyClaimAllCmd(_p)");
@@ -6633,10 +6639,155 @@ function _selfTestCases() {
           && s.includes('const lang = detectLanguageValue(root, ') && s.includes("managedMerge(key, tmpl, cur, null, { lang, root })")   // 1.36.124: 대상 루트 전달이 계약이다(검수 P1);
         return f13ok && skipOk && f7ok && f11ok && guards;
       } finally { try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {} }
-    } }
+    } },
+    // 1.36.125 (검수 P2 클래스 스윕): MCP 호출 예산은 **그 명령이 스스로 거는 내부 타임아웃보다 커야** 한다.
+    //   1.36.124 는 `selftest` 이름 하나만 구제했고, 그 사이 verify-claim --run-tests(내부 300초)·
+    //   referee verify(600초)·api-skill add(최대 110초)는 60초에 잘려 **정상 동작을 거짓 실패로** 보고했다.
+    //   이 가드는 소스 문자열이 아니라 **실제 `_mcpTimeoutFor()` 호출**로 판정한다(문자열 가드는 표가 바뀌면 조용히 죽는다).
+    //   그리고 내부 한도는 손으로 적은 숫자가 아니라 **해당 파일에서 실제로 읽어** 대조한다 — 내부 한도를
+    //   올리고 표를 안 고치면 여기서 깨진다(허용목록이 소비자보다 뒤처지는 것을 막는 유일한 기제).
+    { name: '1.36.125 (검수 P2): MCP 긴 예산 표 — 실제 예산 > 각 경로의 내부 타임아웃 + 대조군(무관 명령은 기본값)', run: () => {
+      if (!Array.isArray(MCP_LONG_PATHS) || MCP_LONG_PATHS.length < 5) return false;
+      const saved = process.env.LEERNESS_MCP_TIMEOUT_MS;
+      delete process.env.LEERNESS_MCP_TIMEOUT_MS;   // override 가 켜져 있으면 표를 재는 것이 아니다
+      try {
+        // ① 표의 각 경로가 실제로 그 예산을 받는가 + 예산이 내부 한도를 넘는가
+        const probes = {
+          'selftest': ['selftest', '--json'],
+          'task-done-probe': ['task', 'update', 'T-1', '--status', 'done'],
+          'verify-claim-run-tests': ['verify-claim', 'T-1', '--path', '.', '--run-tests'],
+          'referee-verify': ['referee', 'verify', 'r1', '--path', '.', '--json'],
+          'api-skill-add': ['api-skill', 'add', '--path', '.', '--url', 'https://example.com', '--json'],
+        };
+        for (const p of MCP_LONG_PATHS) {
+          const args = probes[p.id];
+          if (!args) return false;                                   // 표에 새 항목이 생기면 프로브도 함께 적어야 한다
+          const got = _mcpTimeoutFor(args);
+          if (got !== p.budgetMs) return false;                      // 술어가 그 인자를 실제로 집어내는가
+          if (!(got > p.mustExceedMs)) return false;                 // 예산이 내부 한도를 넘는가
+          if (p.src) {                                               // 내부 한도를 **소스에서 실제로 읽어** 대조
+            const raw = read(path.join(__dirname, '..', p.src.file));
+            const m = p.src.re.exec(raw);
+            if (!m) return false;                                    // 리터럴을 못 찾으면 공허통과가 아니라 실패
+            const actual = Number(m[1]) * (p.src.scale || 1);
+            if (!Number.isFinite(actual) || actual !== p.mustExceedMs) return false;   // 소스가 바뀌면 표도 바뀌어야
+            if (!(got > actual)) return false;
+          }
+        }
+        // ② 대조군 — 무관한 명령은 기본값을 받는다(긴 예산이 옆으로 새면 서버가 11분씩 얼어붙는다)
+        const ctrl = [['health', '--json'], ['task', 'list'], ['task', 'update', 'T-1', '--status', 'in_progress'],
+          ['verify-claim', 'T-1', '--path', '.'], ['referee', 'list', '--path', '.'], ['api-skill', 'list', '--path', '.']];
+        if (!ctrl.every(a => _mcpTimeoutFor(a) === MCP_TIMEOUT_DEFAULT_MS)) return false;
+        // ③ 타임아웃 사유 한 줄은 **그 호출에만** 붙고, 다른 경로의 사유가 새지 않는다
+        const hintSelf = _mcpTimeoutHint(['selftest', '--json']);
+        if (!/긴 예산\(300초\)/.test(hintSelf) || !hintSelf.includes('실측 116초')) return false;
+        if (/실측 116초/.test(_mcpTimeoutHint(['referee', 'verify', 'r1']))) return false;   // 옆 경로 사유가 새면 실패
+        if (_mcpTimeoutHint(['health', '--json']) !== '') return false;                       // 무관한 도구엔 아무 사유도 없다
+        // ④ 명시 override 는 여전히 최우선이고, 그때는 **표의 사유를 말하지 않는다**(5초에 잘린 사용자에게
+        //    "긴 예산 300초를 받습니다" 라고 하면 거짓말이다 — 1.36.125 에서 실제로 그렇게 쓸 뻔했다)
+        process.env.LEERNESS_MCP_TIMEOUT_MS = '7000';
+        const overridden = _mcpTimeoutFor(['selftest', '--json']) === 7000 && _mcpTimeoutFor(['health']) === 7000
+          && _mcpTimeoutHint(['selftest', '--json']) === '';
+        delete process.env.LEERNESS_MCP_TIMEOUT_MS;
+        return overridden;
+      } finally { if (saved !== undefined) process.env.LEERNESS_MCP_TIMEOUT_MS = saved; else delete process.env.LEERNESS_MCP_TIMEOUT_MS; }
+    } },
+    // 1.36.125: 측정 통제 자체의 가드 — 목록이 비거나 배선이 끊기면 selftest 는 다시 사용자 설정에 휘둘린다.
+    // 1.36.126 (T-0107): `.leerness` 를 살아 있는 저장소로 **주장하지 않는다**.
+    //   ⚠ 이 케이스는 **행위검사만** 한다(자기 소스 읽기 금지 — 1.36.84 메타가드). 상수와 하드코딩 수의
+    //     모순 금지 불변식은 e2e V 블록이 소스를 읽어 건다. 여기서는 실제 함수를 불러 결과를 본다.
+    { name: '1.36.126 (T-0107): 워크스페이스 대체 디렉터리 — 해석기가 살아 있는 저장소를 말함 + 무시 고지 + 대조군 침묵 (행위검사)', run: () => {
+      // 행위 ① 해석기는 env·마커가 있어도 살아 있는 저장소를 말한다(예전엔 `.leerness` 를 말해 미초기화 오판을 냈다)
+      const arena = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-ws126-'));
+      const savedEnv = process.env.LEERNESS_WORKSPACE_DIR;
+      try {
+        fs.mkdirSync(path.join(arena, '.leerness'), { recursive: true });
+        fs.writeFileSync(path.join(arena, '.leerness', 'MIGRATED_FROM_HARNESS'), 'x');
+        fs.mkdirSync(path.join(arena, '.harness'), { recursive: true });
+        fs.writeFileSync(path.join(arena, '.harness', 'HARNESS_VERSION'), VERSION);
+        process.env.LEERNESS_WORKSPACE_DIR = '.leerness';
+        if (_workspaceDirName(arena) !== '.harness') return false;
+        if (!_workspaceDirAbs(arena).endsWith('.harness')) return false;
+        // 마커가 있어도 초기화된 프로젝트로 인식해야 한다(예전엔 여기서 "미초기화" 오판이 났다)
+        if (_isInitialized(arena) !== true) return false;
+        // 행위 ② 무시한 설정은 **말한다** — env·마커 각각, 그리고 아무것도 없으면 침묵(오탐 0)
+        const both = _workspaceDirAltIgnored(arena);
+        if (!both || both.env !== '.leerness' || both.marker !== true || both.effective !== '.harness') return false;
+        delete process.env.LEERNESS_WORKSPACE_DIR;
+        const markerOnly = _workspaceDirAltIgnored(arena);
+        if (!markerOnly || markerOnly.env !== null || markerOnly.marker !== true) return false;
+        const clean = path.join(arena, 'clean'); fs.mkdirSync(clean, { recursive: true });
+        if (_workspaceDirAltIgnored(clean) !== null) return false;   // 대조군 — 평범한 프로젝트는 조용하다
+        // 행위 ③ 코어가 실제로 거부하는가 — CLI 인자 없이 함수를 직접 불러 판정(문자열이 아니라 결과로)
+        const blocked = _migrateWorkspaceDir(arena, { dryRun: true });
+        if (blocked.blocked !== true || blocked.blockedReason !== 'workspace-dir-alt-unsupported') return false;
+        if ((blocked.copiedFiles || []).length !== 0) return false;
+        // 그리고 내부 시험 통로는 여전히 복사 구현을 태운다(안전 속성이 도달 불가로 썩지 않게)
+        const seam = _migrateWorkspaceDir(arena, { dryRun: true, allowUnsupported: true });
+        if (seam.blocked === true) return false;
+        return true;
+      } catch { return false; }
+      finally {
+        if (savedEnv !== undefined) process.env.LEERNESS_WORKSPACE_DIR = savedEnv; else delete process.env.LEERNESS_WORKSPACE_DIR;
+        try { fs.rmSync(arena, { recursive: true, force: true }); } catch {}
+      }
+    } },
+    { name: '1.36.125 (검수 P2): selftest 측정 통제 — 통제 목록 실재 + 실제 삭제 + 무시 사실 보고(조용한 무시 금지)', run: () => {
+      const must = ['LEERNESS_MCP_PROFILE', 'LEERNESS_WORKSPACE_DIR', 'LEERNESS_LANG', 'LEERNESS_MCP_TIMEOUT_MS'];
+      if (!must.every(k => _SELFTEST_CONTROLLED_ENV.includes(k))) return false;
+      // 하네스가 일부러 켜는 것은 통제 목록에 들어가면 안 된다(측정 계약을 스스로 지우는 셈)
+      if (['LEERNESS_OFFLINE', 'LEERNESS_INTERNAL'].some(k => _SELFTEST_CONTROLLED_ENV.includes(k))) return false;
+      const savedP = process.env.LEERNESS_MCP_PROFILE, savedL = process.env.LEERNESS_LANG;
+      try {
+        process.env.LEERNESS_MCP_PROFILE = 'core'; process.env.LEERNESS_LANG = 'en';
+        const dropped = _controlSelftestEnv();
+        const gone = process.env.LEERNESS_MCP_PROFILE === undefined && process.env.LEERNESS_LANG === undefined;
+        const told = dropped.some(s => s.startsWith('LEERNESS_MCP_PROFILE=')) && dropped.some(s => s.startsWith('LEERNESS_LANG='));
+        // 검수 P1: "검증 중에만" 이라고 말했으면 **끝나면 되돌려 놔야** 한다(export 된 함수라 호출자 설정이 영구히 사라졌다)
+        dropped.restore();
+        const restored = process.env.LEERNESS_MCP_PROFILE === 'core' && process.env.LEERNESS_LANG === 'en';
+        // 대조군 — 설정이 없으면 아무것도 보고하지 않는다(빈 컬렉션 공허참으로 통과하지 않게 위에서 실제 값을 넣었다)
+        delete process.env.LEERNESS_MCP_PROFILE; delete process.env.LEERNESS_LANG;
+        const quiet = _controlSelftestEnv().length === 0;
+        return gone && told && restored && quiet;
+      } finally {
+        if (savedP !== undefined) process.env.LEERNESS_MCP_PROFILE = savedP; else delete process.env.LEERNESS_MCP_PROFILE;
+        if (savedL !== undefined) process.env.LEERNESS_LANG = savedL; else delete process.env.LEERNESS_LANG;
+      }
+    } },
   ];
 }
+// 1.36.125 (검수 P2 + 클래스 스윕 실측): selftest 는 **자기가 재는 환경을 스스로 통제해야** 한다.
+//   실측(대조군 무설정 343/343 통과) — 공개 설정 하나를 켜 두기만 해도 설치 검증 도구가 거짓 실패를 냈다:
+//     LEERNESS_MCP_PROFILE=core        → 342/343 (프로브가 프로필을 상속해 없는 도구를 호출)
+//     LEERNESS_WORKSPACE_DIR=.leerness → 339/343 + stderr 722B ("미초기화 디렉토리" 오판)
+//     LEERNESS_LANG=en                 → 341/343 (픽스처가 정한 언어를 env 가 덮어써 ko 기대값이 어긋남)
+//   즉 "설치가 손상됐다" 는 보고가 사실은 **사용자 설정 때문**이었다 — 진단 도구가 낼 수 있는 최악의 거짓말이다.
+//   같은 방식으로 잰 AUTONOMOUS·ENFORCE_POLICY·HOOK·SKILL_AUTO_INSTALL·TZ 5종은 **343/343 무해**여서 넣지 않는다
+//   (손 분류로 목록을 부풀리지 않는다 — 깨지는 것만 넣고, 안 깨지는 것은 안 깨진다고 적는다).
+//   1.36.124 는 이 클래스를 프로브 2개에만(_probeEnv) 적용했다. 프로브마다 지우면 새 프로브가 빠지므로
+//   병목에서 한 번 지운다 — 여기서 지우면 이 프로세스가 띄우는 **모든 자식**이 통제된 환경을 물려받는다.
+//   ⚠ LEERNESS_OFFLINE / LEERNESS_INTERNAL 등 하네스가 **일부러 켜는** 것은 지우지 않는다(측정 계약의 일부).
+//   ⚠ LANG 을 지워도 영어 커버리지는 죽지 않는다 — en 경로는 `_selftestFixture('en')`(init --language en)이
+//      따로 검증한다. 지우는 목적은 "언어의 출처를 픽스처 하나로 되돌리는" 것이지 en 을 안 보는 것이 아니다.
+const _SELFTEST_CONTROLLED_ENV = ['LEERNESS_MCP_PROFILE', 'LEERNESS_WORKSPACE_DIR', 'LEERNESS_MCP_TIMEOUT_MS', 'LEERNESS_LANG'];
+function _controlSelftestEnv() {
+  const dropped = [], saved = {};
+  for (const k of _SELFTEST_CONTROLLED_ENV) {
+    if (process.env[k] !== undefined) { dropped.push(`${k}=${process.env[k]}`); saved[k] = process.env[k]; delete process.env[k]; }
+  }
+  //   1.36.125 (검수 P1): `selfTestCmd` 는 **export 된 라이브러리 함수**다. CLI/MCP 는 자식이 끝나며 격리되지만
+  //   직접 호출하면 호출자 프로세스의 설정이 **영구히** 사라진다(실측: en/.leerness → undefined).
+  //   게다가 우리 출력은 "검증 중에만 무시" 라고 말한다 — 복원하지 않으면 그 안내 자체가 거짓이 된다.
+  const restore = () => { for (const k of Object.keys(saved)) process.env[k] = saved[k]; };
+  // 조용히 지우지 않는다 — 무엇을 무시했는지 사람과 JSON 소비자 모두에게 말한다.
+  return Object.assign(dropped, { restore });
+}
 function selfTestCmd(opts = {}) {
+  const droppedEnv = _controlSelftestEnv();
+  try { return _selfTestCmdInner(opts, droppedEnv); } finally { droppedEnv.restore(); }
+}
+function _selfTestCmdInner(opts, droppedEnv) {
   const isTty = process.stdout && process.stdout.isTTY;
   const gr = s => isTty ? `\x1b[32m${s}\x1b[0m` : s;
   const rd = s => isTty ? `\x1b[31m${s}\x1b[0m` : s;
@@ -6651,12 +6802,18 @@ function selfTestCmd(opts = {}) {
   const pass = results.filter(r => r.ok).length;
   const fail = results.length - pass;
   if (opts.json) {
-    log(JSON.stringify({ version: VERSION, total: results.length, pass, fail, ok: fail === 0, results }, null, 2));
+    log(JSON.stringify({ version: VERSION, total: results.length, pass, fail, ok: fail === 0, controlledEnv: droppedEnv, results }, null, 2));
     if (fail > 0) process.exitCode = 1;
     return;
   }
   log(cy(`# leerness selftest (1.9.258) — 코어 함수 무결성 검증 (v${VERSION})`));
   log('');
+  // 무시한 설정은 반드시 보인다 — 사용자가 켜 둔 것이 안 먹었다는 사실을 숨기면 그 자체가 거짓 보고다(1.36.125).
+  if (droppedEnv.length) {
+    log(dm(`  ⓘ 측정 통제: 검증 중에만 ${droppedEnv.length}개 환경설정을 무시합니다 — ${droppedEnv.join(', ')}`));
+    log(dm(`     (이 설정들이 켜져 있으면 selftest 가 "설치 손상" 을 거짓 보고했습니다 — 실제 제품 동작은 그대로입니다)`));
+    log('');
+  }
   results.forEach(r => {
     if (r.ok) log(`  ${gr('✓')} ${r.name}`);
     else log(`  ${rd('✗')} ${r.name}${r.err ? dm(' — ' + r.err) : ''}`);
@@ -8339,9 +8496,14 @@ function _p0097AsyncLockOk() {
   finally { try { fs.rmSync(arena, { recursive: true, force: true }); } catch {} }
 }
 // 1.36.124 (살아 있는 MCP 통신 실측): selftest 프로브가 `process.env` 를 그대로 상속했다 —
-//   MCP 래퍼는 `LEERNESS_NO_WORKFLOW_GUIDE` 등으로 **안내 출력을 일부러 끄고** 자식을 띄우므로,
-//   "안내가 뜬다" 를 단언하는 프로브가 MCP 경유에서만 실패했다. 그 결과 `leerness_selftest` 가
+//   MCP 래퍼는 자식을 띄울 때 안내·점검 계열 변수를 **일부러 켜 두는데**, 그 환경에서 도는 프로브가
+//   "그 동작이 살아 있다" 를 단언하다 MCP 경유에서만 실패했다. 그 결과 `leerness_selftest` 가
 //   AI 에게 "설치가 깨졌다" 고 **거짓 보고**했다(343 중 1 실패). 프로브는 억제 변수를 걷어낸 환경에서 돈다.
+//   1.36.125 (검수 P3, 주석 정정): 직접 원인은 workflow guide 의 stdout 이 아니다 — reminder 쪽은
+//   `LEERNESS_NO_DRIFT_CHECK`, usage 쪽은 `LEERNESS_INTERNAL` 이었다. 원인을 잘못 적어 두면 다음 회귀
+//   분석이 엉뚱한 곳을 판다. 목록 전체를 걷어내는 처방 자체는 그대로 유효하다.
+//   ⚠ 이 목록은 **프로브 단위** 처방이다. 프로필·워크스페이스·언어처럼 제품 의미를 바꾸는 설정은
+//     프로브마다 지우면 새 프로브가 빠지므로 selftest 진입점에서 통제한다(_SELFTEST_CONTROLLED_ENV).
 const _PROBE_SUPPRESS_ENV = ['LEERNESS_INTERNAL', 'LEERNESS_NO_BANNER', 'LEERNESS_NO_PROMPT',
   'LEERNESS_NO_WORKFLOW_GUIDE', 'LEERNESS_NO_STALE_CHECK', 'LEERNESS_NO_DRIFT_CHECK',
   'LEERNESS_NO_HEADLINE', 'LEERNESS_NO_LAZY_WARN'];
@@ -9079,7 +9241,7 @@ function commandsCmd(root) {
       { cmd: 'migrate [path] [--dry-run]', desc: '업데이트 마이그레이션', descEn: 'update migration' },
       { cmd: 'update [--check|--yes|--force]', desc: '자가 업데이트', descEn: 'self-update' },
       { cmd: 'wakeup-interval get|set|auto|history|record', desc: 'adaptive wakeup (1.9.210)', descEn: 'adaptive wakeup interval (1.9.210)' },
-      { cmd: 'workspace-dir get|guide', desc: '워크스페이스 디렉토리 (1.9.211)', descEn: 'workspace directory (1.9.211)' },
+      { cmd: 'workspace-dir get|guide', desc: '워크스페이스 디렉토리 확인 — 이 빌드는 .harness 만 사용 (migrate-workspace-dir 는 1.36.126 부터 거부, T-0107)', descEn: 'show the workspace directory — this build uses .harness only (migrate-workspace-dir refuses since 1.36.126, T-0107)' },
       { cmd: 'parent detect|adopt [--select <kinds>] [--apply]', desc: '상위 leerness 부모 탐지 + 자산 게이트형 adopt (1.30.2~3)', descEn: 'detect a parent leerness above + gated asset adoption (1.30.2~3)' },
       { cmd: 'intent classify|expand|domains "<request>"', desc: '의도 파악 + scope (1.9.213)', descEn: 'infer intent + scope (1.9.213)' },
       { cmd: 'constraints list|check|add', desc: '플랫폼/API 제약 (1.9.208)', descEn: 'platform/API constraints (1.9.208)' },
@@ -9634,20 +9796,49 @@ function _computeAdaptiveInterval(root) {
 //   - LEERNESS_WORKSPACE_DIR env 또는 .leerness/MARKER 존재 시 .leerness 사용
 //   - leerness migrate-workspace-dir CLI: .harness → .leerness copy + AI reference guide 생성
 //   - AI 참조 가이드: WHERE_TO_FIND.md (디렉토리 구조 + 파일별 역할 + 마이그레이션 history)
-function _workspaceDirName(root) {
-  // 1) env override
-  if (process.env.LEERNESS_WORKSPACE_DIR) {
-    const v = process.env.LEERNESS_WORKSPACE_DIR.trim();
-    if (v) return v;
-  }
-  // 2) .leerness 마이그레이션 마커 존재 시 .leerness 우선
+// 1.36.126 (T-0107 실측): 이 해석기는 **소수파**였다. 실측 —
+//   해석기 소비처 9곳 vs `.harness` 경로 구성 252곳(bin 215 · lib 37) + 안내/템플릿 문자열 634곳.
+//   그래서 env 나 마커로 `.leerness` 를 고르게 해도 **쓰기는 전부 `.harness` 로 갔다**(실측:
+//   migrate 후 `task add` 가 `.leerness` 에 안 남음. env 를 켜도 동일). 결과는 두 가지 해악이었다:
+//     ① `_isInitialized` 만 `.leerness` 를 봐서 정상 프로젝트를 "미초기화" 로 오판(실측 selftest 4건 실패)
+//     ② `.leerness` 는 마이그레이션 시점에 얼어붙은 **죽은 사본**이 되고 WHERE_TO_FIND.md 가 AI 를 그리로 안내
+//   즉 소수파를 따르는 것은 "다르게 동작" 이 아니라 **틀리게 동작**이었다. 살아 있는 저장소를 그대로 말한다.
+//   ⚠ 이 상수를 true 로 바꾸려면 하드코딩 252곳을 먼저 없애야 한다 — selftest 가 그 순서를 강제한다.
+const WORKSPACE_DIR_ALT_SUPPORTED = false;
+// 거부 사유로 대는 숫자는 **실행 시** 센다 — 손으로 적으면 다음 편집에서 곧바로 낡는다(검수 P2 실측: 252→255).
+//   거부 경로에서만 불리므로 비용은 문제되지 않는다. 세다가 실패하면 숫자를 지어내지 말고 null 로 둔다.
+function _measureWorkspaceHardcoding() {
+  const out = { resolverConsumers: null, hardcodedPathSites: null, hardcodedTextMentions: null };
   try {
-    if (root && exists(path.join(root, '.leerness', 'MIGRATED_FROM_HARNESS'))) {
-      return '.leerness';
+    let src = read(__filename);
+    const libDir = path.join(__dirname, '..', 'lib');
+    for (const f of fs.readdirSync(libDir)) if (f.endsWith('.js')) src += '\n' + read(path.join(libDir, f));
+    out.hardcodedPathSites = (src.match(/path\.join\([^)]*'\.harness'/g) || []).length;
+    out.hardcodedTextMentions = (src.match(/\.harness\/[A-Za-z0-9_.-]+/g) || []).length;
+    out.resolverConsumers = (src.match(/_workspaceDir(?:Name|Abs)\(/g) || []).length;
+  } catch { /* 셀 수 없으면 null — 지어내지 않는다 */ }
+  return out;
+}
+// 사용자가 켠 설정이 **안 먹는다는 사실**은 반드시 말해야 한다(조용한 무시 금지 — 1.36.125 와 같은 원칙).
+function _workspaceDirAltIgnored(root) {
+  if (WORKSPACE_DIR_ALT_SUPPORTED) return null;
+  const env = (process.env.LEERNESS_WORKSPACE_DIR || '').trim();
+  let marker = false;
+  try { marker = !!(root && exists(path.join(root, '.leerness', 'MIGRATED_FROM_HARNESS'))); } catch {}
+  if (!env && !marker) return null;
+  return { env: env || null, marker, effective: '.harness' };
+}
+function _workspaceDirName(root) {
+  if (WORKSPACE_DIR_ALT_SUPPORTED) {
+    if (process.env.LEERNESS_WORKSPACE_DIR) {
+      const v = process.env.LEERNESS_WORKSPACE_DIR.trim();
+      if (v) return v;
     }
-  } catch {}
-  // 3) default
-  return '.harness';
+    try {
+      if (root && exists(path.join(root, '.leerness', 'MIGRATED_FROM_HARNESS'))) return '.leerness';
+    } catch {}
+  }
+  return '.harness';   // 살아 있는 저장소 — 위 주석의 실측대로 이 빌드에서는 항상 여기다
 }
 function _workspaceDirAbs(root) {
   return path.join(root, _workspaceDirName(root));
@@ -9666,7 +9857,12 @@ function _findParentWorkspace(root, opts = {}) {
       const hasHarness = exists(path.join(cur, '.harness'));
       const hasLeerness = exists(path.join(cur, '.leerness'));
       if (hasHarness || hasLeerness) {
-        const wd = (hasLeerness && exists(path.join(cur, '.leerness', 'MIGRATED_FROM_HARNESS'))) ? '.leerness' : (hasHarness ? '.harness' : '.leerness');
+        // 1.36.126 (T-0107): 여기는 해석기를 안 쓰고 **자체 로직으로 `.leerness` 를 우선**하고 있었다 —
+        //   부모가 옛 migrate 를 돌렸다면 그 `.leerness` 는 죽은 사본이므로, 자식이 **낡은 자산**
+        //   (design-system·reuse-map·skills)을 물려받는다. 살아 있는 저장소가 있으면 그쪽이 먼저다.
+        //   `.leerness` 만 있는 경우(사용자가 믿고 `.harness` 를 지운 상태)는 부모 탐지 자체를 잃는 것보다
+        //   읽어 주는 편이 낫다 — 읽기 전용 자산 탐지이고, 그 프로젝트는 audit 이 미초기화로 따로 알린다.
+        const wd = hasHarness ? '.harness' : '.leerness';
         const wsAbs = path.join(cur, wd);
         const assets = {
           designSystem: exists(path.join(wsAbs, 'design-system.md')),
@@ -9699,6 +9895,24 @@ function _migrateWorkspaceDir(root, opts = {}) {
     errors: [],
     dryRun
   };
+  // 1.36.126 (T-0107): 이 명령은 **배달할 수 없는 것을 배달했다고 말하고 있었다**. 실측 —
+  //   복사(58파일)는 성공하고 "✓ 마이그레이션 완료 → 다음 handoff부터 .leerness 우선 사용" 이라고 찍는데,
+  //   그 직후 `task add` 는 여전히 `.harness` 에 쓴다. 결과물은 마이그레이션이 아니라 **얼어붙은 사본**이고,
+  //   같이 만들어지는 WHERE_TO_FIND.md 는 AI 를 그 낡은 상태로 안내한다 — 우리가 막으려는 바로 그 실패다.
+  //   그래서 복사를 하지 않는다. 반쯤 된 상태를 만들 바에는 **아무것도 만들지 않는 편이 낫다**(fail-closed).
+  //   되살리려면 하드코딩 252곳을 해석기로 바꾸는 것이 선행 조건이다(T-0107).
+  //   ⚠ `allowUnsupported` 는 **내부 시험 전용 통로**다. 복사 구현(심링크 미추종 등 1.36.33 안전 속성)을
+  //     도달 불가로 만들면 그 보호가 조용히 썩는다 — T-0107 이 풀리면 다시 살아날 코드이므로 계속 시험한다.
+  //     CLI 경로는 이 옵션을 절대 넘기지 않는다(e2e 가 호출부를 열거해 단언한다).
+  if (!WORKSPACE_DIR_ALT_SUPPORTED && opts.allowUnsupported !== true) {
+    report.blocked = true;
+    report.blockedReason = 'workspace-dir-alt-unsupported';
+    //   ⚠ 이 숫자를 손으로 적어 뒀더니 곧바로 낡았다(적을 땐 252, 이 라운드 편집 후 실제 255 — 검수 P2).
+    //     "실측" 이라 말하면서 낡은 수를 보여 주는 것은 이 라운드가 고치는 결함과 같은 클래스다. 실행 시 센다.
+    report.measured = _measureWorkspaceHardcoding();
+    report.errors.push('이 빌드는 .leerness 를 살아 있는 저장소로 쓰지 못합니다 — 복사하면 죽은 사본이 됩니다');
+    return report;
+  }
   if (!report.srcExists) {
     report.errors.push('source .harness not found');
     return report;
@@ -10516,6 +10730,7 @@ function workspaceDirCmd(root, sub) {
   const isTty = process.stdout && process.stdout.isTTY;
   const cyan = s => isTty ? `\x1b[36m${s}\x1b[0m` : s;
   const grn = s => isTty ? `\x1b[32m${s}\x1b[0m` : s;
+  const yel = s => isTty ? `\x1b[33m${s}\x1b[0m` : s;
   const dim = s => isTty ? `\x1b[2m${s}\x1b[0m` : s;
 
   if (!sub || sub === 'get') {
@@ -10524,19 +10739,37 @@ function workspaceDirCmd(root, sub) {
     const hasHarness = exists(path.join(root, '.harness'));
     const hasLeerness = exists(path.join(root, '.leerness'));
     const migrated = exists(path.join(root, '.leerness', 'MIGRATED_FROM_HARNESS'));
-    const result = { current: dirName, abs: dirAbs, hasHarness, hasLeerness, migrated };
+    // 1.36.126 (T-0107): `migrated: true` 를 그대로 보여 주면 "옮겨졌다" 는 **거짓 인상**을 준다 —
+    //   실제로는 그 뒤 모든 쓰기가 .harness 로 간다. 마커의 의미를 사실대로 옮겨 적는다.
+    const ignored = _workspaceDirAltIgnored(root);
+    // 1.36.126 (검수 P2): 마커가 지워진 사본도 잡되, 남의 `.leerness` 는 건드리지 않는다 —
+    //   두 번째 신호는 **우리 생성물의 서명**(가이드 헤더). audit 과 같은 술어를 쓴다.
+    let ourGuide = false;
+    try { ourGuide = exists(path.join(root, '.leerness', 'WHERE_TO_FIND.md'))
+      && /by leerness \d+\.\d+\.\d+/.test(read(path.join(root, '.leerness', 'WHERE_TO_FIND.md'))); } catch {}
+    const staleCopy = (migrated || ourGuide) && dirName === '.harness';
+    const result = { current: dirName, abs: dirAbs, hasHarness, hasLeerness, migrated,
+      altSupported: WORKSPACE_DIR_ALT_SUPPORTED, ignoredSetting: ignored, staleCopy };
     if (has('--json')) { log(JSON.stringify(result, null, 2)); return; }
-    log(cyan(`# leerness workspace-dir (1.9.211)`));
-    log(`  현재 디렉토리: ${grn(dirName + '/')}`);
+    log(cyan(`# leerness workspace-dir (1.36.126)`));
+    log(`  현재 디렉토리: ${grn(dirName + '/')}  ${dim('(읽기·쓰기가 실제로 일어나는 곳)')}`);
     log(`  abs: ${dirAbs}`);
     log(`  .harness 존재: ${hasHarness ? '✓' : '✗'}`);
     log(`  .leerness 존재: ${hasLeerness ? '✓' : '✗'}`);
-    log(`  마이그레이션 완료: ${migrated ? '✓' : '✗'}`);
+    log(`  .leerness 마커: ${migrated ? '✓' : '✗'}`);
     log('');
-    if (hasHarness && !hasLeerness) {
-      log(dim(`  → 마이그레이션: leerness migrate-workspace-dir`));
-    } else if (migrated) {
-      log(dim(`  → AI 참조 가이드: leerness workspace-dir guide`));
+    if (ignored) {
+      log(yel(`  ⚠ ${ignored.env ? `LEERNESS_WORKSPACE_DIR=${ignored.env}` : '.leerness/MIGRATED_FROM_HARNESS 마커'} 는 이 빌드에서 적용되지 않습니다.`));
+      log(`     실제 저장소는 ${grn(ignored.effective + '/')} 입니다 — 설정을 켜 두어도 동작은 바뀌지 않습니다(T-0107).`);
+    }
+    if (staleCopy) {
+      log('');
+      log(yel(`  ⚠ .leerness/ 는 **죽은 사본**입니다 — 마이그레이션 시점에 멈춰 있고 이후 변경이 반영되지 않습니다.`));
+      log(`     .leerness/WHERE_TO_FIND.md 를 AI 에게 주지 마세요(낡은 상태로 안내합니다).`);
+      log(dim(`     안전하게 지우려면: 내용을 .harness 와 비교해 필요한 것이 없는지 확인한 뒤 직접 삭제하세요.`));
+      log(dim(`     (leerness 는 사용자 데이터를 대신 지우지 않습니다)`));
+    } else if (hasHarness && !hasLeerness) {
+      log(dim(`  → 이 빌드는 .harness 만 사용합니다(디렉터리 이름 변경은 T-0107 이후).`));
     }
     return;
   }
@@ -10679,7 +10912,29 @@ function migrateWorkspaceDirCmd(root) {
   const force = has('--force');
   const report = _migrateWorkspaceDir(root, { dryRun, force });
 
-  if (has('--json')) { log(JSON.stringify(report, null, 2)); return; }
+  if (has('--json')) { log(JSON.stringify(report, null, 2)); if (report.blocked) process.exitCode = 1; return; }
+  // 1.36.126: 못 하는 일을 했다고 말하지 않는다 — 사유와 **실측 근거**를 함께 준다.
+  if (report.blocked) {
+    const m = report.measured || {};
+    log(cyan(`# leerness migrate-workspace-dir (1.36.126)`));
+    log('');
+    log(red(`  ✗ 이 빌드는 .leerness 로 옮길 수 없습니다 — 복사만 하면 죽은 사본이 됩니다.`));
+    log('');
+    if (m.hardcodedPathSites != null) {
+      log(`  왜: leerness 내부에서 워크스페이스 경로를 만드는 곳 ${m.hardcodedPathSites}곳이 '.harness' 를 그대로 쓰고,`);
+      log(`      경로 해석기를 거치는 곳은 ${m.resolverConsumers}곳뿐입니다(안내 문구 ${m.hardcodedTextMentions}곳은 별도).`);
+    } else {
+      log(`  왜: leerness 내부 대부분이 '.harness' 경로를 그대로 쓰고 있어, 복사해도 그쪽으로는 아무것도 쓰이지 않습니다.`);
+      log(`      (이 실행에서는 소스를 세지 못해 정확한 수를 대지 못합니다 — 판정 자체는 바뀌지 않습니다.)`);
+    }
+    log(`      그래서 복사한 뒤에도 모든 쓰기는 .harness 로 갑니다 — .leerness 는 복사 시점에 멈춘 사본이 되고,`);
+    log(`      함께 만들어지던 WHERE_TO_FIND.md 가 AI 를 그 낡은 상태로 안내합니다.`);
+    log('');
+    log(dim(`  지금 할 수 있는 것: 그대로 .harness 를 쓰시면 됩니다(기능 차이 없음 — 디렉터리 이름만 다릅니다).`));
+    log(dim(`  진행 상황: 이 제약은 T-0107 로 등록돼 있습니다 — 해결되면 이 명령이 다시 동작합니다.`));
+    process.exitCode = 1;
+    return;
+  }
   log(cyan(`# leerness migrate-workspace-dir (1.9.211)${dryRun ? ' [DRY-RUN]' : ''}`));
   log(`  src: ${report.src}  ${report.srcExists ? '✓' : red('✗ 없음')}`);
   log(`  dst: ${report.dst}  ${report.dstExists ? yel('⚠ 이미 존재') : '(생성)'}`);
@@ -15674,7 +15929,17 @@ function verifyClaimCmd(root, taskId, opts = {}) {
   //   이전엔 npm test 하드코딩 → 비-JS(파이썬 등) 프로젝트에서 npm init 잔재 placeholder("no test specified"&&exit 1)가 실행돼
   //   테스트 전부 통과한 작업을 "주장 불일치 FAIL"로 오판(5축 클린룸 실증 P1). placeholder 는 테스트가 아니므로 skip 처리.
   let runResult = null;
-  if (has('--run-tests')) {
+  // 1.36.125 (검수 P2): `verify-claim --all --run-tests` 는 done 행마다 verifyClaimCmd 를 부르고
+  //   `--run-tests` 는 전역 플래그다 → **같은 테스트 스위트를 task 수만큼 반복 실행**했다.
+  //   한 번의 호출 안에서 같은 root·같은 명령의 결과는 정의상 동일하다(주장별로 달라질 수 없다).
+  //   그래서 --all 스윕이 넘겨준 메모를 재사용한다. 효과는 두 가지 —
+  //   ① N×300초가 1×300초가 되어 MCP 예산(660초) 안에 들어온다(거짓 타임아웃 제거)
+  //   ② 우리 자신처럼 스위트가 79분인 프로젝트에서 N번 도는 낭비가 사라진다.
+  //   ⚠ 메모는 **호출자가 명시로 넘길 때만** 쓴다(모듈 전역 캐시로 두면 장수 프로세스에서 낡은 결과를 재사용한다).
+  const _runMemo = opts && opts.runMemo && typeof opts.runMemo === 'object' ? opts.runMemo : null;
+  if (has('--run-tests') && _runMemo && Object.prototype.hasOwnProperty.call(_runMemo, 'result')) {
+    runResult = _runMemo.result;
+  } else if (has('--run-tests')) {
     let testCmd = arg('--test-cmd', null);
     if (!testCmd) {
       try { const cfg = JSON.parse(read(path.join(root, '.harness', 'leerness-config.json'))); if (cfg && typeof cfg.testCommand === 'string' && cfg.testCommand.trim()) testCmd = cfg.testCommand.trim(); } catch {}
@@ -15713,6 +15978,8 @@ function verifyClaimCmd(root, taskId, opts = {}) {
         }
       }
     }
+    // 이 호출에서 실제로 실행한 결과를 메모에 남긴다 — 다음 주장부터는 재실행하지 않는다(검수 P2).
+    if (_runMemo) _runMemo.result = runResult;
   }
 
   // 1.9.309 (UR-0048, 설치리뷰 Opus critical): done 주장은 evidence(파일+테스트) 기본 강제 — 거짓완료 차단을 기본값·MCP·json 모두에서 작동.
@@ -16020,7 +16287,10 @@ function _verifyClaimsAll(root) {
   root = absRoot(root);
   const rows = readProgressRows(root);
   const doneRows = rows.filter(r => /done|완료|completed/i.test(String(r.status || '')));
-  const results = doneRows.map(r => verifyClaimCmd(root, r.id, { collect: true }));
+  // 1.36.125 (검수 P2): `--run-tests` 는 전역 플래그라 종전엔 스위트를 done 행 수만큼 반복 실행했다
+  //   (100개 주장 × 300초 = 8시간 — MCP 예산으로는 어떤 값도 못 덮는다). 한 스윕 = 한 번 실행.
+  const runMemo = {};
+  const results = doneRows.map(r => verifyClaimCmd(root, r.id, { collect: true, runMemo }));
   const failed = results.filter(x => x && !x.ok);
   return { ok: failed.length === 0, total: doneRows.length, failed: failed.length, results };
 }
@@ -22017,6 +22287,68 @@ function _mcpToCliArgs(name, args, targetPath) {
 }
 
 // 프로토콜: MCP 표준 (JSON-RPC 2.0). 메서드: initialize, tools/list, tools/call
+// 1.36.93 (헌트 #8): 래퍼 타임아웃(60s)이 bugfix probe 예산(600s)보다 짧아, 버그를 **진짜 고치고**
+//   영수증까지 채운 사용자가 MCP 표면에서는 done 을 영영 기록하지 못했다. 게다가 stdout 이 비어 있어
+//   응답이 `(no output)` 뿐 — 차단 사유도, 타임아웃이라는 사실도 전달되지 않았다(진단 단서 0).
+//   ① 기본값을 probe 예산 위로 올리고 ② env 로 조절 가능하게 하며 ③ 타임아웃을 **사실대로** 보고한다.
+//   (MCP 클라이언트 자체 타임아웃은 leerness 가 어쩌지 못한다 — 그래서 메시지에 CLI 대안을 함께 준다.)
+//   codex 33차 #2: 한도를 **전역으로** 올리면 `spawnSync` 가 단일 스레드 서버를 그만큼 얼린다 —
+//   무관한 도구가 멎어도 11분간 ping·취소 통지조차 못 읽는다. 그래서 긴 예산은 그 예산이 필요한 호출에만 준다.
+const MCP_TIMEOUT_DEFAULT_MS = 60000;
+const MCP_TIMEOUT_PROBE_MS = 660000;     // 제품 내부 최대 한도(600s) 위
+const MCP_TIMEOUT_LONG_MS = 300000;
+function _mcpTimeoutOverrideMs() {
+  const v = parseInt(process.env.LEERNESS_MCP_TIMEOUT_MS || '', 10);
+  return (Number.isFinite(v) && v >= 5000 && v <= 3600000) ? v : null;
+}
+// 1.36.125 (검수 P2 · 클래스 스윕): 1.36.124 는 `selftest` **한 이름만** 예산에서 구제했다 — 전형적인
+//   "가드는 자기가 밟은 경로만 지킨다". 60초를 넘길 수 있는 경로는 그것만이 아니고, 판별 기준도 이름이 아니라
+//   **그 명령이 스스로 거는 내부 타임아웃**이다. 예산이 내부 한도보다 짧으면 정상 동작을 잘라 놓고
+//   AI 에게 거짓 실패를 보고한다(1.36.124 와 같은 클래스). 그래서 술어를 흩뿌리지 않고 한 표로 모으고,
+//   각 항목이 반드시 넘어야 할 내부 한도(mustExceedMs)를 함께 적는다 — selftest 가 그 숫자를 **소스에서
+//   실제로 읽어** `budget > 내부한도` 를 단언하므로, 내부 한도를 올리고 표를 안 고치면 게이트가 깨진다.
+//   ⚠ 남는 한계(정직하게): referee verify 는 good/bad/check 세 번을 각각 내부 한도까지 쓸 수 있어
+//      최악(3×600초)은 어떤 예산으로도 못 덮는다 — 그 경우의 탈출구는 타임아웃 메시지가 안내하는
+//      `LEERNESS_MCP_TIMEOUT_MS` 다. 예산을 3배로 키우면 이번엔 서버가 30분간 얼어붙어 더 나쁘다.
+const MCP_LONG_PATHS = [
+  { id: 'selftest', budgetMs: MCP_TIMEOUT_LONG_MS, mustExceedMs: 116000,
+    why: '실측 116초(1.36.124) — 소스 리터럴이 아니라 측정값',
+    match: (a) => a[0] === 'selftest' },
+  // bugfix probe 가 도는 경로 — done 전이(task update --status done)와 TodoWrite 왕복(task sync).
+  { id: 'task-done-probe', budgetMs: MCP_TIMEOUT_PROBE_MS, mustExceedMs: 600000,
+    why: 'lib/bugfix.js 의 probe 실행 한도', src: { file: 'lib/bugfix.js', re: /shell: true, encoding: 'utf8', timeout: (\d+)/ },
+    match: (a) => a[0] === 'task' && (a[1] === 'sync'
+      || (a[1] === 'update' && a.includes('--status') && ['done', 'completed', 'verified'].includes(a[a.indexOf('--status') + 1]))) },
+  { id: 'verify-claim-run-tests', budgetMs: MCP_TIMEOUT_PROBE_MS, mustExceedMs: 300000,
+    why: '프로젝트 테스트 실행 한도(runCommandSafe kind:verify_claim_test)',
+    src: { file: 'bin/leerness.js', re: /timeout: (\d+) \* 60 \* 1000, kind: 'verify_claim_test'/, scale: 60000 },
+    match: (a) => a[0] === 'verify-claim' && a.includes('--run-tests') },
+  { id: 'referee-verify', budgetMs: MCP_TIMEOUT_PROBE_MS, mustExceedMs: 600000,
+    why: 'lib/referee.js calibrate 기본 한도(good/bad/check 각각)',
+    src: { file: 'lib/referee.js', re: /Number\(opts\.timeoutMs\) \|\| (\d+)/ },
+    match: (a) => a[0] === 'referee' && a[1] === 'verify' },
+  { id: 'api-skill-add', budgetMs: MCP_TIMEOUT_LONG_MS, mustExceedMs: 110000,
+    why: '본문 1 + same-domain 링크 최대 10 요청 × 요청당 10초',
+    match: (a) => a[0] === 'api-skill' && a[1] === 'add' },
+];
+function _mcpLongPathFor(cliArgs) {
+  const a = (cliArgs || []).map(String);
+  return MCP_LONG_PATHS.find(p => { try { return p.match(a) === true; } catch { return false; } }) || null;
+}
+function _mcpTimeoutFor(cliArgs) {
+  const ov = _mcpTimeoutOverrideMs();
+  if (ov != null) return ov;
+  const p = _mcpLongPathFor(cliArgs);
+  return p ? p.budgetMs : MCP_TIMEOUT_DEFAULT_MS;
+}
+// 타임아웃 사유 한 줄 — **실제로 적용된 예산**과 어긋나면 안 된다. 명시 override 가 걸린 호출에
+//   "이 호출은 긴 예산(300초)을 받습니다" 라고 말하면 5초에 잘린 사용자에게 거짓말을 하는 것이다.
+//   순수 함수로 두는 이유: 진짜 타임아웃을 기다리지 않고도 두 분기를 실행으로 단언할 수 있게(1.36.125).
+function _mcpTimeoutHint(cliArgs) {
+  if (_mcpTimeoutOverrideMs() != null) return '';        // 예산을 정한 것은 표가 아니라 사용자다
+  const p = _mcpLongPathFor(cliArgs);
+  return p ? `  · 이 호출은 긴 예산(${Math.round(p.budgetMs / 1000)}초)을 받습니다 — ${p.why}.\n` : '';
+}
 function mcpServeCmd(root) {
   root = absRoot(root || process.cwd());
   // 노출할 leerness 도구 목록
@@ -22032,42 +22364,8 @@ function mcpServeCmd(root) {
   function send(obj) {
     process.stdout.write(JSON.stringify(obj) + '\n');
   }
-  // 1.36.93 (헌트 #8): 래퍼 타임아웃(60s)이 bugfix probe 예산(600s)보다 짧아, 버그를 **진짜 고치고**
-  //   영수증까지 채운 사용자가 MCP 표면에서는 done 을 영영 기록하지 못했다. 게다가 stdout 이 비어 있어
-  //   응답이 `(no output)` 뿐 — 차단 사유도, 타임아웃이라는 사실도 전달되지 않았다(진단 단서 0).
-  //   ① 기본값을 probe 예산 위로 올리고 ② env 로 조절 가능하게 하며 ③ 타임아웃을 **사실대로** 보고한다.
-  //   (MCP 클라이언트 자체 타임아웃은 leerness 가 어쩌지 못한다 — 그래서 메시지에 CLI 대안을 함께 준다.)
-  //   codex 33차 #2: 한도를 **전역으로** 올리면 `spawnSync` 가 단일 스레드 서버를 그만큼 얼린다 —
-  //   무관한 도구가 멎어도 11분간 ping·취소 통지조차 못 읽는다. 그래서 긴 예산은 **probe 를 실행할 수 있는
-  //   호출에만** 준다(done 전이 · task sync). 나머지는 종전대로 60초.
-  const MCP_TIMEOUT_DEFAULT_MS = 60000;
-  const MCP_TIMEOUT_PROBE_MS = 660000;     // probe 예산(600s) 위 — 이 값이 적용되는 호출은 아래 _needsProbeBudget 뿐
-  const MCP_TIMEOUT_OVERRIDE_MS = (() => {
-    const v = parseInt(process.env.LEERNESS_MCP_TIMEOUT_MS || '', 10);
-    return (Number.isFinite(v) && v >= 5000 && v <= 3600000) ? v : null;
-  })();
-  // 1.36.124 (살아 있는 MCP 통신 실측): `leerness_selftest` 는 **항상** 60초 한도를 넘겨 타임아웃만 돌려줬다.
-  //   실측 116초(우리 repo·빈 임시 프로젝트 둘 다) — 즉 광고된 89개 도구 중 **설치 검증 도구가 MCP 로는 무용**이었다.
-  //   전역 한도를 올리지 않는 이유는 위와 같다(무관한 도구가 서버를 그만큼 얼린다). 그래서 이 명령에만 준다.
-  const MCP_TIMEOUT_LONG_MS = 300000;      // 실측 116초 대비 2.5배 여유
-  function _needsLongBudget(cliArgs) {
-    const a = (cliArgs || []).map(String);
-    return a[0] === 'selftest';
-  }
-  // bugfix probe 가 도는 경로만 긴 예산을 받는다 — done 전이(task update --status done)와 TodoWrite 왕복(task sync).
-  function _needsProbeBudget(cliArgs) {
-    const a = (cliArgs || []).map(String);
-    if (a[0] !== 'task') return false;
-    if (a[1] === 'sync') return true;
-    if (a[1] !== 'update') return false;
-    const i = a.indexOf('--status');
-    return i >= 0 && ['done', 'completed', 'verified'].includes(a[i + 1]);
-  }
-  function _mcpTimeoutFor(cliArgs) {
-    return MCP_TIMEOUT_OVERRIDE_MS != null ? MCP_TIMEOUT_OVERRIDE_MS
-      : (_needsProbeBudget(cliArgs) ? MCP_TIMEOUT_PROBE_MS
-        : (_needsLongBudget(cliArgs) ? MCP_TIMEOUT_LONG_MS : MCP_TIMEOUT_DEFAULT_MS));
-  }
+  // 예산 표(MCP_LONG_PATHS)와 _mcpTimeoutFor 는 모듈 스코프에 있다 — selftest 가 소스 grep 이 아니라
+  //   **실제 호출**로 `budget > 내부한도` 를 단언할 수 있게 하기 위함(1.36.125).
   const _shQuote = (s) => (/[\s"']/.test(String(s)) ? `"${String(s).replace(/"/g, '\\"')}"` : String(s));
   function callLeerness(cliArgs) {
     const budget = _mcpTimeoutFor(cliArgs);
@@ -22084,8 +22382,9 @@ function mcpServeCmd(root) {
       return {
         ok: false, exit: null, stdout: '',
         stderr: `⏱ ${Math.round(budget / 1000)}초 안에 끝나지 않아 중단했습니다: ${cmd}\n`
-          //   probe 설명은 probe 가 실제로 돌 수 있는 호출에만 — 무관한 도구에 엉뚱한 원인을 대지 않는다(#3).
-          + (_needsProbeBudget(cliArgs) ? `  · bugfix probe 가 등록된 task 를 done 으로 바꾸면 probe(최대 600초)가 실행됩니다 — 그만큼 시간이 필요합니다.\n` : '')
+          //   원인 설명은 그 호출에 실제로 해당하는 것만 — 무관한 도구에 엉뚱한 원인을 대지 않는다(#3).
+          //   1.36.125: 표의 `why` 를 그대로 쓴다(예산을 준 근거와 사용자에게 대는 이유가 갈라지지 않게).
+          + _mcpTimeoutHint(cliArgs)
           + `  · 한도 조절: LEERNESS_MCP_TIMEOUT_MS=<밀리초> (5000~3600000)\n`
           + `  · 또는 터미널에서 직접: ${cmd}`
           + (partial ? `\n  · 중단 전 출력:\n${partial.slice(0, 2000)}` : ''),

package/lib/audit.js

@@ -264,6 +264,39 @@ function audit(root, opts = {}, deps = {}) {
       });
     }
   } catch {}
+  // 1.36.126 (T-0107): 예전 버전의 `migrate-workspace-dir` 는 `.harness` 를 `.leerness` 로 **복사만** 하고
+  //   "마이그레이션 완료 → 다음 handoff부터 .leerness 우선 사용" 이라고 말했다. 실제로는 그 뒤 모든 쓰기가
+  //   `.harness` 로 가므로 `.leerness` 는 복사 시점에 얼어붙는다. 문제는 디스크 낭비가 아니라
+  //   같이 만들어진 `WHERE_TO_FIND.md` 가 **AI 를 그 낡은 상태로 안내**한다는 것이다 — 우리가 막으려는 실패 그 자체.
+  //   1.36.126 부터 그 명령은 거부하지만, **이미 당한 프로젝트**는 스스로 알 수 없다. 여기서 알린다.
+  //   ⚠ 지우지는 않는다 — 사용자 데이터를 대신 삭제하지 않는다는 원칙(편의 명령이 P1 5건을 냈던 전례).
+  try {
+    const staleMarker = path.join(root, '.leerness', 'MIGRATED_FROM_HARNESS');
+    const guide = path.join(root, '.leerness', 'WHERE_TO_FIND.md');
+    // 1.36.126 (검수 P2): 마커 하나만 믿으면 **마커가 지워진 사본**을 놓친다(수동 복구·복사 실패 등).
+    //   반대로 남의 도구가 만든 `.leerness` 를 "죽은 사본" 이라 부르면 오탐이 이 경고를 죽인다.
+    //   그래서 두 번째 신호는 **우리 생성물의 서명**으로 좁힌다 — 가이드 파일의 우리 헤더 문구.
+    //   (파일명만 보면 남의 것과 구별할 수 없다. 내용 서명이 있어야 우리 것이라고 말할 수 있다.)
+    let ourGuide = false;
+    try { ourGuide = exists(guide) && /by leerness \d+\.\d+\.\d+/.test(read(guide)); } catch {}
+    if (exists(staleMarker) || ourGuide) {
+      let ageDays = null;
+      try {
+        const mt = exists(staleMarker) ? fs.statSync(staleMarker).mtimeMs : fs.statSync(guide).mtimeMs;
+        const live = fs.statSync(path.join(root, '.harness', 'progress-tracker.md')).mtimeMs;
+        ageDays = Math.max(0, Math.round((live - mt) / 86400000));
+      } catch {}
+      warnings++;
+      warn(`.leerness/ 는 죽은 사본입니다 — 실제 저장소는 .harness 이고, 이 사본은 복사 시점에 멈춰 있습니다`);
+      log(`     근거: ${exists(staleMarker) ? '.leerness/MIGRATED_FROM_HARNESS 마커' : '.leerness/WHERE_TO_FIND.md 가 leerness 생성물'} + 이 빌드는 .leerness 를 읽지 않음 (leerness workspace-dir)`);
+      if (ageDays != null) log(`     낡음 정도: 실제 저장소가 사본보다 약 ${ageDays}일 앞서 있습니다`);
+      if (exists(guide)) log(`     ⚠ .leerness/WHERE_TO_FIND.md 를 AI 에게 주지 마세요 — 낡은 상태로 안내합니다`);
+      log(`     → 내용을 .harness 와 비교해 필요한 것이 없는지 확인한 뒤 직접 삭제하세요 (leerness 는 대신 지우지 않습니다)`);
+      _finding('stale_workspace_copy', 'warn', '.leerness is a frozen copy; the live store is .harness', {
+        markerPresent: exists(staleMarker), guidePresent: exists(guide), guideIsOurs: ourGuide, liveAheadDays: ageDays,
+      });
+    }
+  } catch {}
   const milestoneIds = Array.from(planText.matchAll(/^### (M-\d{4,})\./gm)).map(m => m[1]);
   const rows = readProgressRows(root);
   // 1.9.6 수정: 한 row에 여러 plan:M-XXXX 링크가 있어도 모두 인식 (matchAll로 전부 추출)

package/lib/pure-utils.js

@@ -1579,14 +1579,18 @@ function _renderWorkspaceReferenceGuide(dirName, version, generatedAt) {
   lines.push(`| API 제약 catalog | \`${dirName}/platform-constraints.json\` (1.9.208) |`);
   lines.push(`| 자동 wakeup 권장 간격 | \`${dirName}/wakeup-history.json\` (1.9.210) |`);
   lines.push('');
-  lines.push(`## 🔄 마이그레이션 안내`);
+  // 1.36.126 (T-0107, 검수 P1): 이 절은 AI 에게 **"마커가 있으면 `.leerness` 를 쓰라"** 고 지시하고 있었다.
+  //   메커니즘(해석기)은 고쳐 놓고 지시문을 남기면, 그 지시문이 같은 버그를 계속 재생산한다.
+  //   실측: `.leerness` 는 옛 migrate 가 만든 **얼어붙은 사본**이고 이후 모든 쓰기는 `.harness` 로 간다.
+  lines.push(`## 🔄 \`.leerness\` 디렉터리를 보셨다면`);
   lines.push('');
-  lines.push(`이 워크스페이스는 \`.harness\` → \`.leerness\` 로 마이그레이션되었을 수 있습니다.`);
-  lines.push(`- \`.leerness/MIGRATED_FROM_HARNESS\` 존재 → 마이그레이션 완료, \`.leerness\` 우선 사용`);
-  lines.push(`- \`.harness/MIGRATED_TO_LEERNESS.md\` 존재 → \`.leerness/\` 로 가야 함`);
-  lines.push(`- 양쪽 모두 없음 → 기본 \`.harness\` 사용 중`);
+  lines.push(`이 빌드가 읽고 쓰는 워크스페이스는 **\`${dirName}/\` 하나뿐**입니다.`);
+  lines.push(`- \`.leerness/\` 가 있어도 **읽지 마십시오** — 옛 \`migrate-workspace-dir\` 가 만든 사본이며 그 시점에 멈춰 있습니다.`);
+  lines.push(`- \`.leerness/MIGRATED_FROM_HARNESS\` 마커도 마찬가지입니다 — 이 빌드에서는 아무 효력이 없습니다.`);
+  lines.push(`- \`.harness/MIGRATED_TO_LEERNESS.md\` 안내문 역시 낡았습니다.`);
+  lines.push(`- \`migrate-workspace-dir\` 는 1.36.126 부터 사유를 설명하고 거부합니다 (T-0107).`);
   lines.push('');
-  lines.push(`AI 에이전트는 \`leerness handoff .\` 결과를 신뢰하십시오 — 자동으로 올바른 디렉토리를 사용합니다.`);
+  lines.push(`AI 에이전트는 \`leerness handoff .\` 결과를 신뢰하십시오 — 항상 살아 있는 워크스페이스를 씁니다.`);
   lines.push('');
   return lines.join('\n');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.124",
+  "version": "1.36.126",
   "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",

package/scripts/e2e.js

@@ -5147,34 +5147,83 @@ total++;
   let ok = false; const bad = [];
   const sb = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-mcp124-'));
   const ENVm = Object.assign({}, process.env, { TMPDIR: sb, TEMP: sb, TMP: sb, LEERNESS_OFFLINE: '1', LEERNESS_NO_PROMPT: '1' });
+  // 1.36.125 (검수 P3 + 실측): 이 블록은 **부모 환경을 상속하면 안 된다**. 사용자가 켜 둔 공개 설정 하나로
+  //   e2e 가 환경 의존적 거짓 실패를 낸다 — LEERNESS_MCP_TIMEOUT_MS 는 예산을, MCP_PROFILE 은 도구 수를,
+  //   WORKSPACE_DIR 은 상태 위치를, LANG 은 기대 문자열을 바꾼다(selftest 쪽 실측으로 확인된 같은 클래스).
+  for (const k of ['LEERNESS_MCP_TIMEOUT_MS', 'LEERNESS_MCP_PROFILE', 'LEERNESS_WORKSPACE_DIR', 'LEERNESS_LANG']) delete ENVm[k];
   try {
     const d = path.join(sb, 'p'); fs.mkdirSync(d, { recursive: true });
     fs.writeFileSync(path.join(d, 'package.json'), '{"name":"p","version":"0.1.0"}');
-    cp.spawnSync(process.execPath, [CLI, 'init', d, '--yes'], { cwd: d, encoding: 'utf8', timeout: 300000, env: ENVm });
+    // 셋업 실패를 통과로 세지 않는다(검수 P1) — init 이 죽으면 이후 단언은 무의미하다.
+    const rInit = cp.spawnSync(process.execPath, [CLI, 'init', d, '--yes'], { cwd: d, encoding: 'utf8', timeout: 300000, env: ENVm });
+    if (rInit.status !== 0) bad.push(`셋업init실패(exit=${rInit.status})`);
     const rpc = (id, method, params) => JSON.stringify({ jsonrpc: '2.0', id, method, ...(params ? { params } : {}) }) + '\n';
+    // 1.36.125: 같은 세션에서 **오류 규격**도 함께 받는다(추가 spawn 없이).
+    //   지난 라운드엔 도구 하나만 불러 봤다 — 한 곳에서 나온 결함(타임아웃·거짓 실패)이 클래스인지 보려면 폭이 필요하다.
+    // 규격(2024-11-05 lifecycle)상 initialize 성공 뒤 클라이언트는 `notifications/initialized` 를 보낸다 —
+    //   그걸 빼면 "실제 왕복" 이라면서 수명주기를 재현하지 않은 것이다(검수 P2). 알림은 id 가 없다.
+    const notify = (method) => JSON.stringify({ jsonrpc: '2.0', method }) + '\n';
     const input = rpc(1, 'initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'e2e', version: '0' } })
-      + rpc(2, 'tools/list') + rpc(3, 'tools/call', { name: 'leerness_selftest', arguments: { path: d } });
+      + notify('notifications/initialized')
+      + rpc(2, 'tools/list') + rpc(3, 'tools/call', { name: 'leerness_selftest', arguments: { path: d } })
+      + rpc(4, 'tools/call', { name: 'leerness_brainstorm', arguments: { path: d } })          // 필수 인자 누락 → -32602
+      + rpc(5, 'tools/call', { name: 'leerness_does_not_exist', arguments: {} })                // 미지 도구 → -32601
+      + rpc(6, 'unknown/method', {});                                                          // 미지 메서드 → -32601
     const r = cp.spawnSync(process.execPath, [CLI, 'mcp', 'serve', '--path', d],
       { cwd: d, input, encoding: 'utf8', timeout: 900000, env: ENVm, maxBuffer: 64 * 1024 * 1024 });
     const msgs = [];
     for (const line of String(r.stdout || '').split('\n')) { const s = line.trim(); if (s) { try { msgs.push(JSON.parse(s)); } catch { bad.push('비JSON줄'); } } }
     const by = (i) => msgs.find(m => m.id === i);
+    // 서버 자체의 종료 상태도 본다(검수 P1) — 응답만 보면 **비정상 종료·타임아웃**을 성공으로 센다.
+    if (r.error) bad.push(`서버오류(${r.error.code || r.error.message})`);
+    if (r.signal) bad.push(`서버시그널(${r.signal})`);
+    if (r.status !== 0) bad.push(`서버exit=${r.status}`);
     if (String(r.stderr || '').length !== 0) bad.push(`stderr(${String(r.stderr).length}B)`);
     const init = by(1); if (!init || init.error || !(init.result && init.result.serverInfo)) bad.push('initialize실패');
     const tools = by(2) && by(2).result && by(2).result.tools;
-    if (!Array.isArray(tools) || tools.length < 50) bad.push(`tools/list(${Array.isArray(tools) ? tools.length : 'none'})`);
+    // 1.36.125 (검수 P2): `>= 50` 은 도구가 39개 사라져도 통과한다. 등록부(lib/mcp-tools.js)와 **정확히** 대조한다 —
+    //   서버가 걸러 내거나 프로필이 새면 그 자리에서 어긋난다. 그리고 실제로 부를 도구가 목록에 있는지도 본다
+    //   (dispatch 는 되는데 discoverability 에서 사라지는 경우가 있다).
+    const REG = require(path.resolve(__dirname, '..', 'lib', 'mcp-tools.js'));
+    if (!Array.isArray(tools) || tools.length !== REG.length) bad.push(`tools/list(${Array.isArray(tools) ? tools.length : 'none'}≠등록부 ${REG.length})`);
     else {
       if (tools.some(t => !t.description || !String(t.description).trim())) bad.push('도구설명없음');
       if (tools.some(t => !t.inputSchema || typeof t.inputSchema !== 'object')) bad.push('도구스키마없음');
+      if (!tools.some(t => t.name === 'leerness_selftest')) bad.push('호출할도구가목록에없음');
+      // 1.36.125 (검수 P2): 길이 + "등록부 밖 없음" 만으로는 **중복이 누락을 상쇄**한다(A 를 두 번 내고 B 를 빼면 통과).
+      //   집합 동등으로 본다 — 이름 유일 + 등록부 전체 포함(양방향).
+      const regNames = new Set(REG.map(t => t.name));
+      const gotNames = tools.map(t => t.name);
+      const uniq = new Set(gotNames);
+      if (uniq.size !== gotNames.length) bad.push(`도구이름중복(${gotNames.length - uniq.size}건)`);
+      const extra = gotNames.filter(n => !regNames.has(n));
+      if (extra.length) bad.push(`목록에등록부밖도구(${extra.slice(0, 3).join(',')})`);
+      const missing = [...regNames].filter(n => !uniq.has(n));
+      if (missing.length) bad.push(`등록부인데목록에없음(${missing.slice(0, 3).join(',')})`);
     }
     const call = by(3);
     const txt = call && call.result && Array.isArray(call.result.content) ? String((call.result.content[0] || {}).text || '') : '';
     // ⚠ content 가 비어 있지 않다는 것만 보면 **타임아웃 문구도 성공**으로 센다(내 첫 프로브가 그랬다).
     if (!call || call.error) bad.push('tools/call오류');
+    else if (call.result && call.result.isError) bad.push('tools/call_isError');   // 도구 실패를 성공으로 세던 자리(검수 P1)
     else if (/안에 끝나지 않아 중단/.test(txt)) bad.push('tools/call타임아웃');
     else if (!/"total"\s*:\s*\d+|전체 \d+건 통과/.test(txt)) bad.push('tools/call결과아님');
     // MCP 경유 selftest 가 **실패를 보고하면** 그건 거짓 보고다(같은 프로젝트에서 CLI 는 통과한다)
-    else { const m = /"fail"\s*:\s*(\d+)/.exec(txt); if (m && Number(m[1]) > 0) bad.push(`MCP경유_selftest_거짓실패(fail=${m[1]})`); }
+    //   ⚠ `fail` 필드가 **없으면** 통과시키던 자리 — 계약상 반드시 있고 0 이어야 하며 pass===total 이어야 한다(검수 P1).
+    else {
+      const m = /"fail"\s*:\s*(\d+)/.exec(txt);
+      if (!m) bad.push('selftest_fail필드없음');
+      else if (Number(m[1]) > 0) bad.push(`MCP경유_selftest_거짓실패(fail=${m[1]})`);
+      const p = /"pass"\s*:\s*(\d+)/.exec(txt), t = /"total"\s*:\s*(\d+)/.exec(txt);
+      if (!p || !t || Number(p[1]) !== Number(t[1])) bad.push(`selftest_pass≠total(${p && p[1]}/${t && t[1]})`);
+    }
+    // 오류 규격 — 잘못된 호출을 **JSON-RPC 오류 코드**로 거절해야 한다(조용한 성공/크래시 금지).
+    for (const [id, code, label] of [[4, -32602, '필수인자누락'], [5, -32601, '미지도구'], [6, -32601, '미지메서드']]) {
+      const m = by(id);
+      if (!m) bad.push(`${label}:무응답`);
+      else if (!m.error) bad.push(`${label}:오류아님`);
+      else if (m.error.code !== code) bad.push(`${label}:코드=${m.error.code}(기대 ${code})`);
+    }
     ok = bad.length === 0;
   } catch (e) { bad.push('ERR:' + String(e && e.message).slice(0, 80)); }
   finally { try { fs.rmSync(sb, { recursive: true, force: true }); } catch {} }
@@ -5433,7 +5482,11 @@ total++;
     const pu = require(path.resolve(__dirname, '..', 'lib', 'pure-utils'));
     const g = pu._renderWorkspaceReferenceGuide('.harness', '1.2.3', '2026-01-01T00:00:00.000Z');
     ok = typeof g === 'string' && g.includes('.harness/progress-tracker.md') && g.includes('by leerness 1.2.3')
-      && g.includes('## 📁 디렉토리 구조 (핵심)') && g.includes('## 🧭 자주 묻는 위치') && g.includes('## 🔄 마이그레이션 안내') && g.includes('plan.md');
+      && g.includes('## 📁 디렉토리 구조 (핵심)') && g.includes('## 🧭 자주 묻는 위치') && g.includes('plan.md')
+      // 1.36.126 (T-0107): 여기도 제목 리터럴('## 🔄 마이그레이션 안내')을 붙잡고 있었다 — selftest 쪽만 고치고
+      //   이 **복제본**을 놓쳐 게이트가 깨졌다(같은 단언이 두 표면에 있으면 둘 다 고쳐야 한다).
+      //   제목이 아니라 계약을 건다: 가이드는 `.leerness` 를 다루되 그리로 **가라고 지시하지 않는다**.
+      && /\.leerness/.test(g) && !/우선 사용/.test(g) && !/로 가야 함/.test(g) && /읽지 마십시오/.test(g);
   } catch {}
   console.log(ok ? '✓ B(1.9.377) UR-0025: _renderWorkspaceReferenceGuide 모듈 분리 (빌더 동작 + 핵심 섹션)' : '✗ workspace guide 빌더 실패');
   if (!ok) failed++;
@@ -8310,16 +8363,21 @@ total++;
       //   codex 33차 #5: 메시지의 초 값이 **실제 적용된 한도**여야 한다 — 소스 리터럴만 보면
       //   `Math.min(MCP_TIMEOUT_MS, 60000)` 같은 변조가 그대로 통과한다. 5초 지정 → "5초" 로 찍혀야 한다.
       && /⏱ 5초 안에/.test(shortRes)
-      //   codex 33차 #3: probe 설명은 probe 가 돌 수 있는 호출에만 — selftest 에는 붙으면 안 된다
-      && !/bugfix probe 가 등록된 task/.test(shortRes);
-    //   codex 33차 #2: 긴 예산은 **done 전이/sync 에만** 준다 — 전역으로 올리면 단일 스레드 서버가 그만큼 얼어붙는다.
+      //   codex 33차 #3 → 1.36.125 개정: 사유 줄은 그 호출에만 붙는다. 예전 단언은 사라진 문구를 부정해
+      //   **공허참**이 돼 있었다(문구를 지워도 초록). 이제 "명시 override 가 걸리면 표의 사유를 말하지 않는다"
+      //   는 실제 계약을 건다 — 5초에 잘린 사용자에게 "긴 예산 300초" 라고 말하면 거짓말이기 때문.
+      && !/긴 예산\(/.test(shortRes);
+    //   codex 33차 #2: 긴 예산은 그 예산이 필요한 호출에만 — 전역으로 올리면 단일 스레드 서버가 그만큼 얼어붙는다.
     const srcTxt = fs.readFileSync(CLI, 'utf8');
     const probeBudget = (srcTxt.match(/MCP_TIMEOUT_PROBE_MS = (\d+)/) || [])[1];
     const defBudget = (srcTxt.match(/MCP_TIMEOUT_DEFAULT_MS = (\d+)/) || [])[1];
     T3 = !!probeBudget && Number(probeBudget) > 600000              // probe 예산 위
       && !!defBudget && Number(defBudget) <= 120000                 // 기본은 짧게(서버 정지 시간 제한)
       && /timeout: budget,/.test(srcTxt)                            // 배선: 계산된 예산이 실제로 쓰인다
-      && /_needsProbeBudget\(cliArgs\)/.test(srcTxt);
+      //   1.36.125: 이름 술어(_needsProbeBudget)는 표(MCP_LONG_PATHS)로 대체됐다 — 배선은 그 표를 쓰는지로 본다.
+      //   ⚠ 정확한 예산 계산 자체는 selftest 가 **실행으로** 단언한다(소스 문자열은 배선 유무만).
+      && /_mcpTimeoutHint\(cliArgs\)/.test(srcTxt)
+      && /const MCP_LONG_PATHS = \[/.test(srcTxt);
     ok = T1 && T2 && T3;
     if (!ok) console.log(`   [이월2 디버그] plan정규화=${T1}(done=${doneCount} vc=${vcTotal}) 타임아웃사유=${T2} 기본한도=${T3}(${srcTimeout})`);
   } catch (e) { console.log('   [이월2 디버그] 예외: ' + ((e && e.message) || e)); }
@@ -12303,6 +12361,223 @@ total++;
   if (!ok) failed++;
 }
 
+// 1.36.125 (검수 P2): `verify-claim --all --run-tests` 는 done 행마다 verifyClaimCmd 를 부르는데
+//   `--run-tests` 는 전역 플래그다 → 같은 테스트 스위트를 **주장 수만큼** 반복 실행했다(100주장 × 300초 = 8시간).
+//   메모화로 1회로 줄였다. 그런데 "안 돌렸다" 와 "한 번 돌리고 결과를 나눠 줬다" 는 겉보기가 같다 —
+//   그래서 **실패하는 스위트**를 판별 케이스로 쓴다: 전파되면 N개 주장 **전부** 실패하고, 끊기면 첫 주장만 실패한다.
+//   대조군(통과 스위트)도 함께 둔다 — 메모가 없는 실패를 지어내지 않는지.
+total++;
+{
+  let ok = false; const bad = []; const dbg = {};
+  const _dirs = [];
+  const N = 3;
+  const scenario = (label, testBody, expectFail) => {
+    const d = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-memo125-')); _dirs.push(d);
+    const env = Object.assign({}, process.env, { TMPDIR: d, TEMP: d, TMP: d, LEERNESS_OFFLINE: '1', LEERNESS_NO_PROMPT: '1' });
+    const counter = path.join(d, 'runs.txt');
+    fs.writeFileSync(path.join(d, 'package.json'), JSON.stringify({ name: 'memo', version: '0.1.0', scripts: { test: 'node t.js' } }));
+    fs.writeFileSync(path.join(d, 't.js'), `require('fs').appendFileSync(${JSON.stringify(counter)}, 'x\\n'); ${testBody}`);
+    const ri = cp.spawnSync(process.execPath, [CLI, 'init', d, '--yes'], { cwd: d, encoding: 'utf8', timeout: 300000, env });
+    if (ri.status !== 0) { bad.push(`${label}:init실패(${ri.status})`); return; }
+    for (let i = 0; i < N; i++) {
+      const ra = cp.spawnSync(process.execPath, [CLI, 'task', 'add', `주장${i}`, '--path', d, '--json'], { cwd: d, encoding: 'utf8', timeout: 300000, env });
+      let id = null; try { id = JSON.parse(ra.stdout || '{}').id; } catch {}
+      if (!id) { bad.push(`${label}:task add 실패`); return; }
+      const ru = cp.spawnSync(process.execPath, [CLI, 'task', 'update', id, '--status', 'done', '--evidence', 't.js 테스트 3건 통과', '--path', d],
+        { cwd: d, encoding: 'utf8', timeout: 600000, env });
+      if (ru.status !== 0) { bad.push(`${label}:task update 실패(${ru.status})`); return; }
+    }
+    // 셋업이 조용히 실패하면 아래 판정이 공허해진다 — done 행이 실제로 N개인지 먼저 확인한다.
+    const tracker = fs.readFileSync(path.join(d, '.harness', 'progress-tracker.md'), 'utf8');
+    const doneRows = tracker.split('\n').filter(l => /^\|\s*T-\d+/.test(l) && /\|\s*done\s*\|/.test(l)).length;
+    if (doneRows !== N) { bad.push(`${label}:셋업done행 ${doneRows}(기대 ${N})`); return; }
+    try { fs.unlinkSync(counter); } catch {}
+    const r = cp.spawnSync(process.execPath, [CLI, 'verify-claim', '--all', '--path', d, '--json', '--run-tests'],
+      { cwd: d, encoding: 'utf8', timeout: 900000, env, maxBuffer: 32 * 1024 * 1024 });
+    let runs = 0; try { runs = fs.readFileSync(counter, 'utf8').trim().split('\n').filter(Boolean).length; } catch {}
+    let j = null; try { j = JSON.parse(r.stdout); } catch {}
+    if (!j || !Array.isArray(j.results)) { bad.push(`${label}:JSON아님`); return; }
+    if (j.total !== N) bad.push(`${label}:total=${j.total}(기대 ${N})`);
+    if (runs !== 1) bad.push(`${label}:스위트실행 ${runs}회(기대 1)`);
+    const failedClaims = j.results.filter(x => x && x.ok === false).length;
+    if (expectFail && failedClaims !== N) bad.push(`${label}:실패전파 ${failedClaims}/${N}`);
+    if (!expectFail && failedClaims !== 0) bad.push(`${label}:거짓실패 ${failedClaims}건`);
+    dbg[label] = { runs, total: j.total, failedClaims };
+  };
+  try {
+    scenario('통과', "console.log('3 passed, 0 failed'); process.exit(0);", false);
+    scenario('실패', "console.log('1 passed, 2 failed'); process.exit(1);", true);
+    ok = bad.length === 0;
+  } catch (e) { dbg.err = String(e && e.message).slice(0, 200); }
+  finally { _dirs.forEach(x => { try { fs.rmSync(x, { recursive: true, force: true }); } catch {} }); }
+  console.log(ok ? `✓ U(1.36.125) verify-claim --all --run-tests: 스위트 1회만 실행(주장 수만큼 반복 금지) · 실패 결과가 ${N}개 주장 **전부**에 전파 · 통과 시 거짓 실패 0 ${JSON.stringify(dbg)}`
+    : '✗ 1.36.125 --all 테스트 메모화 실패 ' + JSON.stringify({ bad: bad.slice(0, 6), dbg }));
+  if (!ok) failed++;
+}
+
+// 1.36.126 (T-0107): `migrate-workspace-dir` 는 **배달할 수 없는 것을 배달했다고** 말하고 있었다.
+//   실측: 58파일을 복사하고 "✓ 마이그레이션 완료 → 다음 handoff부터 .leerness 우선 사용" 이라 찍은 뒤,
+//   바로 이어지는 `task add` 는 여전히 `.harness` 에 썼다(env 를 켜도 동일). 즉 `.leerness` 는 복사 시점에
+//   얼어붙은 사본이 되고, 같이 생성되는 WHERE_TO_FIND.md 가 **AI 를 그 낡은 상태로 안내**한다.
+//   배선 비용 실측: 경로 구성 252곳 + 안내 문자열 634곳 vs 해석기 소비처 9곳 → 이번 라운드에 배선 불가.
+//   그래서 ① 함정을 만들지 않고(fail-closed) ② 이미 당한 프로젝트를 알리고 ③ 평범한 프로젝트는 조용하다.
+total++;
+{
+  let ok = false; const bad = []; const dbg = {};
+  const sb = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-ws126-'));
+  const envW = Object.assign({}, process.env, { TMPDIR: sb, TEMP: sb, TMP: sb, LEERNESS_OFFLINE: '1', LEERNESS_NO_PROMPT: '1' });
+  for (const k of ['LEERNESS_WORKSPACE_DIR', 'LEERNESS_LANG', 'LEERNESS_MCP_PROFILE', 'LEERNESS_MCP_TIMEOUT_MS']) delete envW[k];
+  const mkP = (name) => {
+    const d = path.join(sb, name); fs.mkdirSync(d, { recursive: true });
+    fs.writeFileSync(path.join(d, 'package.json'), '{"name":"w","version":"0.1.0"}');
+    const r = cp.spawnSync(process.execPath, [CLI, 'init', d, '--yes'], { cwd: d, encoding: 'utf8', timeout: 600000, env: envW });
+    if (r.status !== 0) bad.push(`${name}:init실패(${r.status})`);
+    return d;
+  };
+  const RW = (d, args, extra) => cp.spawnSync(process.execPath, [CLI, ...args],
+    { cwd: d, encoding: 'utf8', timeout: 600000, env: Object.assign({}, envW, extra || {}), maxBuffer: 32 * 1024 * 1024 });
+  try {
+    // ① 함정을 만들지 않는다 — 복사 0 · 명시적 실패 · 사유와 실측 근거를 함께 말한다
+    const A = mkP('A');
+    const m = RW(A, ['migrate-workspace-dir', '--apply', '--path', A]);
+    if (fs.existsSync(path.join(A, '.leerness'))) bad.push('①.leerness가생성됨');
+    if (m.status === 0) bad.push('①조용한성공(exit 0)');
+    if (!/죽은 사본|옮길 수 없습니다/.test(m.stdout || '')) bad.push('①사유없음');
+    //   ⚠ 여기에 리터럴(252)을 박아 뒀더니 다음 편집에서 곧바로 틀렸다 — 사유의 숫자는 **실측과 같은지**로 본다.
+    //   실제 대조는 아래 ⑥(제품 보고 == e2e 실측). 여기서는 "숫자를 아예 안 대는" 경우만 잡는다.
+    if (!/\d{2,}곳이 '\.harness'/.test(m.stdout || '')) bad.push('①실측근거없음');
+    const mj = RW(A, ['migrate-workspace-dir', '--apply', '--path', A, '--json']);
+    let mjj = null; try { mjj = JSON.parse(mj.stdout); } catch { bad.push('①JSON아님'); }
+    if (mjj && mjj.blocked !== true) bad.push('①json:blocked아님');
+    if (mjj && mjj.blockedReason !== 'workspace-dir-alt-unsupported') bad.push(`①json:reason=${mjj && mjj.blockedReason}`);
+    if (mj.status === 0) bad.push('①json:exit 0');
+    if (mjj && Array.isArray(mjj.copiedFiles) && mjj.copiedFiles.length) bad.push('①json:복사보고');
+    dbg.A = { exit: m.status, created: fs.existsSync(path.join(A, '.leerness')) };
+
+    // ② 이미 당한 프로젝트 — 옛 버전이 남긴 상태를 재현(옛 바이너리가 없으므로 손으로 만든다)
+    const B = mkP('B');
+    fs.mkdirSync(path.join(B, '.leerness'), { recursive: true });
+    fs.copyFileSync(path.join(B, '.harness', 'progress-tracker.md'), path.join(B, '.leerness', 'progress-tracker.md'));
+    fs.writeFileSync(path.join(B, '.leerness', 'MIGRATED_FROM_HARNESS'), 'migrated');
+    fs.writeFileSync(path.join(B, '.leerness', 'WHERE_TO_FIND.md'), '# 어디서 찾나\n');
+    RW(B, ['task', 'add', '사본 이후 작업', '--path', B, '--json']);
+    const au = RW(B, ['audit', '--path', B, '--json']);
+    let aj = null; try { aj = JSON.parse(au.stdout); } catch { bad.push('②auditJSON아님'); }
+    const fnd = aj && Array.isArray(aj.findings) ? aj.findings.find(x => x.kind === 'stale_workspace_copy') : null;
+    if (!fnd) bad.push('②죽은사본_미탐지');
+    else if (fnd.guidePresent !== true) bad.push('②가이드파일_미보고');
+    const wdj = RW(B, ['workspace-dir', 'get', '--path', B, '--json']);
+    let wj = null; try { wj = JSON.parse(wdj.stdout); } catch { bad.push('②wdJSON아님'); }
+    if (wj && wj.current !== '.harness') bad.push(`②현재=${wj.current}`);
+    if (wj && wj.staleCopy !== true) bad.push('②staleCopy아님');
+    if (wj && wj.altSupported !== false) bad.push('②altSupported참');
+    if (!/죽은 사본/.test(RW(B, ['workspace-dir', 'get', '--path', B]).stdout || '')) bad.push('②사람용경고없음');
+    //   마커·env 가 있어도 **쓰기는 정상**이어야 한다(예전엔 _isInitialized 가 .leerness 를 봐서 "미초기화" 거부했다)
+    const w = RW(B, ['task', 'add', '마커 있어도 쓰기', '--path', B, '--json'], { LEERNESS_WORKSPACE_DIR: '.leerness' });
+    if (w.status !== 0) bad.push(`②마커상태쓰기실패(${w.status})`);
+    if (!fs.readFileSync(path.join(B, '.harness', 'progress-tracker.md'), 'utf8').includes('마커 있어도 쓰기')) bad.push('②쓰기가.harness에없음');
+    dbg.B = { finding: !!fnd, staleCopy: wj && wj.staleCopy, writeExit: w.status };
+
+    // ③ 대조군 — 평범한 프로젝트는 조용하다(오탐이 이 경고를 죽인다)
+    const C = mkP('C');
+    const au2 = RW(C, ['audit', '--path', C, '--json']);
+    let aj2 = null; try { aj2 = JSON.parse(au2.stdout); } catch { bad.push('③auditJSON아님'); }
+    const n2 = aj2 && Array.isArray(aj2.findings) ? aj2.findings.filter(x => x.kind === 'stale_workspace_copy').length : -1;
+    if (n2 !== 0) bad.push(`③대조군오탐 ${n2}건`);
+    const wd2 = RW(C, ['workspace-dir', 'get', '--path', C]).stdout || '';
+    if (/죽은 사본|적용되지 않습니다/.test(wd2)) bad.push('③대조군에경고문구');
+    dbg.C = { falsePositives: n2 };
+
+    // ③-c 마커가 지워진 사본도 잡는다(검수 P2) + **남의 `.leerness` 는 건드리지 않는다**(오탐이 경고를 죽인다)
+    {
+      const D = mkP('D');                                   // 마커 없음 · 우리 가이드 파일만 남음
+      fs.mkdirSync(path.join(D, '.leerness'), { recursive: true });
+      fs.writeFileSync(path.join(D, '.leerness', 'WHERE_TO_FIND.md'), 'Generated: 2026-01-01T00:00:00.000Z by leerness 1.36.100\n');
+      const ad = RW(D, ['audit', '--path', D, '--json']);
+      let adj = null; try { adj = JSON.parse(ad.stdout); } catch { bad.push('③c auditJSON아님'); }
+      const fd = adj && Array.isArray(adj.findings) ? adj.findings.find(x => x.kind === 'stale_workspace_copy') : null;
+      if (!fd) bad.push('③c마커없는사본_미탐지');
+      else if (fd.markerPresent !== false || fd.guideIsOurs !== true) bad.push(`③c근거오류(${fd.markerPresent}/${fd.guideIsOurs})`);
+
+      const E = mkP('E');                                   // 남의 도구가 만든 .leerness — 우리 서명 없음
+      fs.mkdirSync(path.join(E, '.leerness'), { recursive: true });
+      fs.writeFileSync(path.join(E, '.leerness', 'WHERE_TO_FIND.md'), '# someone else\n');
+      fs.writeFileSync(path.join(E, '.leerness', 'config.yml'), 'a: 1\n');
+      const ae = RW(E, ['audit', '--path', E, '--json']);
+      let aej = null; try { aej = JSON.parse(ae.stdout); } catch { bad.push('③c(대조)auditJSON아님'); }
+      const fe = aej && Array.isArray(aej.findings) ? aej.findings.filter(x => x.kind === 'stale_workspace_copy').length : -1;
+      if (fe !== 0) bad.push(`③c남의.leerness오탐 ${fe}건`);
+      dbg.D = { detected: !!fd, foreignFalsePositives: fe };
+    }
+
+    // ③-b 부모 자산 — 부모에 죽은 사본이 있어도 **살아 있는 저장소**의 자산을 물려받아야 한다.
+    //   (`_findParentWorkspace` 는 해석기를 안 쓰고 자체 로직으로 `.leerness` 를 우선하고 있었다 —
+    //    같은 클래스가 다른 자리에 남아 있던 경우. 자식이 낡은 design-system 을 물려받는다.)
+    {
+      const P = mkP('P');                                   // 부모
+      fs.writeFileSync(path.join(P, '.harness', 'design-system.md'), '# LIVE\n');
+      fs.mkdirSync(path.join(P, '.leerness'), { recursive: true });
+      fs.writeFileSync(path.join(P, '.leerness', 'MIGRATED_FROM_HARNESS'), 'x');
+      fs.writeFileSync(path.join(P, '.leerness', 'design-system.md'), '# STALE\n');
+      const kid = path.join(P, 'kid'); fs.mkdirSync(kid, { recursive: true });
+      fs.writeFileSync(path.join(kid, 'package.json'), '{"name":"kid","version":"0.1.0"}');
+      const pw = RW(kid, ['parent', 'detect', '--path', kid, '--json']);
+      let pj = null; try { pj = JSON.parse(pw.stdout); } catch { bad.push('③b parentJSON아님'); }
+      const par = pj && pj.parent;
+      if (!par) bad.push('③b부모미탐지(셋업실패면 아래 단언이 공허해진다)');
+      else {
+        if (par.workspaceDir !== '.harness') bad.push(`③b부모워크스페이스=${par.workspaceDir}`);
+        if (!String(par.workspaceAbs || '').endsWith('.harness')) bad.push('③b부모abs가.harness아님');
+        if (par.assets && par.assets.designSystem !== true) bad.push('③b살아있는자산미탐지(계측붕괴)');
+        // 판별: 실제로 읽히는 파일이 LIVE 인가(경로만 맞고 내용이 STALE 이면 의미 없다)
+        const body = fs.readFileSync(path.join(par.workspaceAbs, 'design-system.md'), 'utf8');
+        if (!/LIVE/.test(body)) bad.push('③b읽히는자산이 STALE');
+      }
+      dbg.P = { workspaceDir: par && par.workspaceDir, depth: par && par.depth };
+    }
+
+    // ④ 순서 강제 — 하드코딩이 남아 있는 한 "지원함" 이라 말할 수 없다.
+    //   (selftest 는 자기 소스를 못 읽는다 — 1.36.84 메타가드. 그래서 이 불변식은 여기서 건다.)
+    const binSrc = fs.readFileSync(CLI, 'utf8');
+    const libDir = path.resolve(path.dirname(CLI), '..', 'lib');   // CLI 에서 유도 — 실행 위치에 의존하지 않는다
+    let libSrc = '';
+    for (const f of fs.readdirSync(libDir)) if (f.endsWith('.js')) libSrc += '\n' + fs.readFileSync(path.join(libDir, f), 'utf8');
+    const hard = ((binSrc + libSrc).match(/path\.join\([^)]*'\.harness'/g) || []).length;
+    if (hard < 50) bad.push(`④하드코딩계측붕괴(${hard})`);            // 0건이면 측정이 깨진 것 — 공허통과 금지
+    const claims = /const WORKSPACE_DIR_ALT_SUPPORTED = (true|false);/.exec(binSrc);
+    if (!claims) bad.push('④지원상수없음');
+    else if (claims[1] === 'true' && hard > 0) bad.push(`④하드코딩 ${hard}곳인데 지원함이라 주장`);
+    // ⑤ 내부 시험 통로가 **제품 경로**로 새지 않는다.
+    //   (검수 P3) 정확 카운트는 안전한 리팩터만으로 깨진다 — 개수가 아니라 **어디에 있는가**로 본다:
+    //   selftest 케이스 영역(_selfTestCases) 밖에 이 옵션을 넘기는 곳이 있으면 제품 경로 누출이다.
+    const selfStart = binSrc.indexOf('function _selfTestCases(');
+    const selfEnd = selfStart < 0 ? -1 : binSrc.indexOf('\nfunction ', selfStart + 10);
+    if (selfStart < 0 || selfEnd < 0) bad.push('⑤selftest영역경계못찾음');
+    else {
+      const outside = binSrc.slice(0, selfStart) + binSrc.slice(selfEnd);
+      const inside = binSrc.slice(selfStart, selfEnd);
+      //   "언급" 이 아니라 **넘기는 것**만 센다 — 주석·선언(`opts.allowUnsupported !== true`)은 호출이 아니다.
+      const passes = (s) => (s.match(/allowUnsupported\s*:/g) || []).length;
+      const leaked = passes(outside);
+      if (leaked > 0) bad.push(`⑤시험통로가 제품 경로에 ${leaked}곳`);
+      if (passes(inside) < 1) bad.push('⑤시험통로를 아무도 안 태움(보호가 썩는다)');
+      dbg.seam = { leaked, insideUses: passes(inside) };
+    }
+    dbg.src = { hard, claims: claims && claims[1] };
+    // ⑥ 거부 사유의 숫자는 **실행 시 측정**이어야 한다(검수 P2: 손으로 적은 252가 곧 255로 낡았다).
+    //   제품이 보고한 수와 여기서 센 수가 같아야 한다 — 다르면 둘 중 하나가 거짓말이다.
+    if (mjj && mjj.measured) {
+      if (mjj.measured.hardcodedPathSites !== hard) bad.push(`⑥보고=${mjj.measured.hardcodedPathSites} vs 실측=${hard}`);
+      if (!(mjj.measured.resolverConsumers > 0)) bad.push('⑥해석기 소비처 0(계측붕괴)');
+    } else bad.push('⑥measured 없음');
+    ok = bad.length === 0;
+  } catch (e) { dbg.err = String(e && e.message).slice(0, 200); }
+  finally { try { fs.rmSync(sb, { recursive: true, force: true }); } catch {} }
+  console.log(ok ? `✓ V(1.36.126/T-0107) 워크스페이스 대체 디렉터리: migrate 가 죽은 사본을 만들지 않고 명시적으로 실패(사유+실측) · 이미 당한 프로젝트를 audit/workspace-dir 가 알림 · 마커·env 가 있어도 쓰기 정상(.harness) · 대조군 오탐 0 ${JSON.stringify(dbg)}`
+    : '✗ 1.36.126 워크스페이스 대체 디렉터리 실패 ' + JSON.stringify({ bad: bad.slice(0, 8), dbg }));
+  if (!ok) failed++;
+}
+
 console.log(`\nE2E result: ${total - failed}/${total} passed · ${((Date.now() - _e2eStart) / 1000).toFixed(0)}s`);
 if (failed > 0) process.exit(1);