leerness 1.36.125 → 1.36.127

package/README.md

@@ -122,7 +122,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.125 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.127 하네스를 사용합니다. 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.125는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
+Leerness v1.36.127는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -197,7 +197,7 @@ Leerness v1.36.125는 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.125 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.127 릴리스 태그 이력** (수백 라운드) · _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.125: 2026-08-16
+Last synced by Leerness v1.36.127: 2026-08-17
 <!-- 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.125';
+const VERSION = '1.36.127';
 
 // 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; } },
@@ -6692,6 +6693,101 @@ function _selfTestCases() {
       } 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.127 (T-0105/T-0106 도그푸딩): 고아 가드 탐지기가 **자기 저장소에서 눈이 멀어 있었다** —
+    //   CI 가 `bin/leerness.js` 를 실행하므로 그 파일이 러너로 잡히고, 그 안의 selftest 단언 문자열
+    //   (`'test:core'` 등)이 호출로 읽혀 진짜 고아 2건이 0건으로 보고됐다(실측).
+    //   ① 판정은 그대로 두고 **반사실**(자기 진입점 텍스트를 뺀 결과와의 차이)을 함께 보고한다.
+    //   ② 자기가 부르는 파일이 전부 다른 곳에서 이미 도는 **별칭**은 잠든 검사가 아니므로 면제한다.
+    //   순수 함수라 픽스처로 행위 검증한다(우리 저장소는 이제 배선을 끝내 이 경로를 안 밟는다 —
+    //   그래서 저장소에 의존하면 이 기능이 조용히 썩는다).
+    { name: '1.36.127 (T-0105): 고아 가드 — 자기 진입점 텍스트에 가려진 후보 보고 + 별칭 면제 + 진짜 고아/인라인 대조군', run: () => {
+      const pu = require('../lib/pure-utils');
+      const ci = { file: '.github/workflows/ci.yml', unconditional: true, viaScripts: [], text: 'run: npm test' };
+      const base = { readErrors: 0, skippedLarge: 0, workspaces: false };
+      // ① 반사실 — 자기 진입점이 잠든 가드 이름을 **문자열로만** 담고 있으면 그 사실을 말해야 한다
+      const masked = pu._detectOrphanGuards(Object.assign({}, base, {
+        packageScripts: { test: 'node scripts/a.js', 'test:dead': 'node scripts/dead.js' },
+        scriptFiles: ['scripts/a.js', 'scripts/dead.js'],
+        runners: [ci, { file: 'bin/prod.js', unconditional: true, viaScripts: [], ownEntry: true, text: 'const doc = "run test:dead (scripts/dead.js)";' }],
+      }));
+      if (masked.orphanScripts.length !== 0 || masked.orphanFiles.length !== 0) return false;   // 판정은 종전대로 조용
+      if (!masked.maskedByOwnEntry) return false;                                               // 그러나 가려진 사실은 말한다
+      if (!masked.maskedByOwnEntry.scripts.includes('test:dead')) return false;
+      if (!masked.maskedByOwnEntry.files.includes('scripts/dead.js')) return false;
+      // ② 대조군 — 자기 진입점이 없으면 반사실은 아예 없다(조용해야 할 때 조용한가)
+      const plain = pu._detectOrphanGuards(Object.assign({}, base, {
+        packageScripts: { test: 'node scripts/a.js', 'test:dead': 'node scripts/dead.js' },
+        scriptFiles: ['scripts/a.js', 'scripts/dead.js'], runners: [ci],
+      }));
+      if (plain.maskedByOwnEntry !== null) return false;
+      if (!plain.orphanScripts.includes('test:dead')) return false;      // 진짜 고아는 여전히 잡힌다
+      // ③ 별칭 면제 — 부르는 파일이 전부 이미 도는 스크립트는 잠든 검사가 아니다
+      const alias = pu._detectOrphanGuards(Object.assign({}, base, {
+        packageScripts: { test: 'node scripts/a.js && node scripts/b.js', 'test:alias': 'node scripts/a.js' },
+        scriptFiles: ['scripts/a.js', 'scripts/b.js'], runners: [ci],
+      }));
+      if (alias.orphanScripts.length !== 0) return false;
+      // ④ 면제가 너무 넓지 않은가 — 파일을 하나도 안 부르는 인라인 스크립트는 근거가 없으므로 면제 금지
+      const inline = pu._detectOrphanGuards(Object.assign({}, base, {
+        packageScripts: { test: 'node scripts/a.js', 'test:inline': 'node -e "process.exit(0)"' },
+        scriptFiles: ['scripts/a.js'], runners: [ci],
+      }));
+      if (!inline.orphanScripts.includes('test:inline')) return false;
+      // ⑤ (검수 P1, 실측 재현) 면제가 **다른 파일을 같은 파일로 착각**하면 안 된다 —
+      //    확장자 뒤 경계가 없으면 `check.tsx` 가 `check.ts` 로 잘려 죽은 가드가 별칭으로 사라졌다.
+      const extBoundary = pu._detectOrphanGuards(Object.assign({}, base, {
+        packageScripts: { test: 'tsx scripts/check.tsx', 'test:dead': 'tsx scripts/check.ts' },
+        scriptFiles: ['scripts/check.tsx', 'scripts/check.ts'], runners: [ci],
+      }));
+      if (!extBoundary.orphanScripts.includes('test:dead')) return false;
+      // ⑥ (검수 P1, 실측 재현) **주석 속 경로**는 실행 근거가 아니다 —
+      //    `# scripts/dead.js 는 나중에 정리` 한 줄로 그 가드가 목록에서 사라졌다.
+      const commented = pu._detectOrphanGuards(Object.assign({}, base, {
+        packageScripts: { test: 'node scripts/a.js', 'test:dead': 'node scripts/dead.js' },
+        scriptFiles: ['scripts/a.js', 'scripts/dead.js'],
+        runners: [{ file: '.github/workflows/ci.yml', unconditional: true, viaScripts: [], text: '# scripts/dead.js 는 나중에 정리\n      - run: npm test' }],
+      }));
+      return commented.orphanScripts.includes('test:dead');
+    } },
+    // 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;
@@ -9201,7 +9297,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)' },
@@ -9756,20 +9852,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));
@@ -9788,7 +9913,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')),
@@ -9821,6 +9951,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;
@@ -10638,6 +10786,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') {
@@ -10646,19 +10795,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;
   }
@@ -10801,7 +10968,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('⚠ 이미 존재') : '(생성)'}`);

package/lib/audit.js

@@ -7,7 +7,7 @@ const path = require('path');
 const { log, ok, warn, fail, failJson, today, now, absRoot, exists, read, readBuf, mkdirp, writeUtf8, append, rel } = require('./io');
 const { SECRET_PATTERNS } = require('./catalogs');
 const { findCorruptedStateJson } = require('./state-integrity');  // 1.36.1 (클린룸 리뷰 FN): 상태 JSON 무결성
-const { _briefUnfilled, _planGoalUnfilled, _detectOrphanGuards } = require('./pure-utils');  // 1.36.19: 전략 앵커 · 1.36.116: 고아 가드
+const { _briefUnfilled, _planGoalUnfilled, _detectOrphanGuards, _normPath } = require('./pure-utils');  // 1.36.19: 전략 앵커 · 1.36.116: 고아 가드 · 1.36.127: 경로 접기 규칙 공유
 const fs = require('fs');
 
 // 1.36.116 — "존재하지만 아무도 실행하지 않는 가드" 를 audit 이 본다.
@@ -49,7 +49,11 @@ function _collectGuardInputs(root) {
     if (typeof pkg.bin === 'string') ent.push(pkg.bin);
     else if (pkg.bin && typeof pkg.bin === 'object') ent.push(...Object.values(pkg.bin));
     if (typeof pkg.main === 'string') ent.push(pkg.main);
-    ownEntries = new Set(ent.filter(x => typeof x === 'string').map(x => x.replace(/^\.\//, '').replace(/\\/g, '/')));
+    //   1.36.127 (검수 P1): 선행 `./` 와 백슬래시만 걷어내면 **중간 dot-segment** 가 남는다 —
+    //   CI 가 `node ./bin/./p.js` 로 적으면 수집 파일명은 `bin/./p.js`, own entry 는 `bin/p.js` 라
+    //   정확 일치 비교가 어긋나 `ownEntry:false` 가 되고, 이 릴리스가 없애려는 **조용한 0건이 그대로 재발**한다.
+    //   양쪽을 같은 규칙(_normEntry)으로 접어서 비교한다.
+    ownEntries = new Set(ent.filter(x => typeof x === 'string').map(x => _normPath(x).replace(/^\.\//, '')));
   } catch { readErrors++; }   // package.json 이 깨져 있으면 '스크립트 0개' 가 아니라 **못 읽었다** 고 말해야 한다(검수 P2)
   // `viaScript` = 이 파일을 러너로 담게 만든 npm 스크립트 이름(CI 설정 파일이면 null).
   //   1.36.116 (검수 P2): 아무도 안 부르는 wrapper 가 참조하는 파일도 러너로 담기고, 그 텍스트에 잎 가드 이름이
@@ -70,7 +74,11 @@ function _collectGuardInputs(root) {
       return;
     }
     const t = rd(path.join(root, file));
-    if (t != null) runners.push({ file, text: t, viaScript: viaScript || null, viaScripts: viaScript ? [viaScript] : [], unconditional: !viaScript });
+    //   1.36.127 (T-0105/T-0106 실측): CI 가 패키지 **자신의 진입점**을 실행하면(우리 저장소가 그렇다) 그 파일이
+    //   러너로 들어오고, 그 안의 **문자열 리터럴**(우리 selftest 가 단언하는 `'test:core'` 등)이 배선으로 읽힌다.
+    //   그래서 leerness 자신의 진짜 고아 2건(`test:core`·`test:smoke`)이 0건으로 보고됐다 — 도구가 자기 저장소에서
+    //   자기 기능에 눈이 먼 상태. 판정은 그대로 두되(오탐 편향 유지), **무엇이 가려졌는지 셀 수 있게** 표시만 남긴다.
+    if (t != null) runners.push({ file, text: t, viaScript: viaScript || null, viaScripts: viaScript ? [viaScript] : [], unconditional: !viaScript, ownEntry: ownEntries.has(file) });
   };
   try { for (const f of fs.readdirSync(path.join(root, '.github', 'workflows'))) if (/\.ya?ml$/.test(f)) push(`.github/workflows/${f}`); } catch {}
   // 1.36.116 (검수 #5): 정확히 `Makefile` 과 훅 2개만 읽었다 — `GNUmakefile`·소문자 `makefile`·`commit-msg` 를
@@ -86,7 +94,7 @@ function _collectGuardInputs(root) {
   //   ⚠ **중간 디렉터리**를 허용해야 한다: `scripts/a/run.js` 처럼 한 단계 더 들어간 러너가 아예 수집되지 않아
   //   그 러너가 배선한 것이 전부 거짓 고아가 됐다(실측: `scripts/run.js` 는 잡히고 `scripts/a/run.js` 는 안 잡힘).
   const _FILE_RE = /[\w./\\-]*(?:scripts|tools|ci|bin|tasks)[/\\](?:[\w.-]+[/\\])*[\w.-]+\.(?:m?js|cjs|ts|sh)/g;
-  const _norm = (x) => String(x).replace(/\\/g, '/').replace(/^\.\//, '');
+  const _norm = (x) => _normPath(x).replace(/^\.\//, '');   // 1.36.127 (검수 P1): 중간 dot-segment 까지 같은 규칙으로 접는다
   // CI 설정 파일이 부르는 것은 출처 null(무조건 유효한 러너), npm 스크립트가 부르는 것은 그 스크립트가 출처다.
   //   ⚠ 자기 진입점 제외는 **CI 설정이 직접 부르는 경우까지** 막으면 안 된다(검수 P2) — 그 파일이 실제로
   //   가드를 배선하고 있으면 그걸 못 봐서 정상 가드가 고아로 뒤집힌다. CI 가 부르면 그건 러너가 맞다.
@@ -263,6 +271,58 @@ function audit(root, opts = {}, deps = {}) {
         guardCount: g.guardCount, reason: g.reason,
       });
     }
+    // 1.36.127 (T-0105/T-0106 실측): CI 가 패키지 **자신의 진입점**을 실행하는 저장소에서는, 그 파일 안의
+    //   문자열 리터럴이 배선으로 읽혀 진짜 고아가 0건으로 보고된다. leerness 자신이 그 상태였다 —
+    //   `test:core`·`test:smoke` 2건이 우리 selftest 단언 문자열에 가려져 있었다(도구가 자기 저장소에 눈이 멂).
+    //   판정은 바꾸지 않는다(오탐 편향 유지 — 오탐이 이 경고를 죽인다). 대신 **가려진 후보를 이름으로** 말한다.
+    //   고아가 0건이든 아니든 별도로 낸다 — 조용한 0건을 없애는 것이 목적이다.
+    if (g && g.maskedByOwnEntry) {
+      const mk = g.maskedByOwnEntry;
+      const parts = [];
+      if ((mk.scripts || []).length) parts.push(`npm ${mk.scripts.join(', ')}`);
+      if ((mk.files || []).length) parts.push(`파일 ${mk.files.join(', ')}`);
+      warnings++;
+      warn(`가드 배선 판정이 이 패키지 자신의 진입점 텍스트에 가려질 수 있습니다 — 확인 필요: ${parts.join(' · ')}`);
+      log(`     이유: CI 가 이 패키지의 bin/main 을 실행하므로 러너로 잡히는데, 그 안의 **문자열**(문서·템플릿·테스트 단언)에`);
+      log(`           스크립트 이름이 있으면 호출로 읽힙니다. 위 항목은 그 텍스트를 빼면 '아무도 안 부름' 으로 나옵니다.`);
+      log(`     → 실제로 부르는 곳이 있으면 무시하세요. 없으면 CI 에 배선하거나 삭제하세요.`);
+      _finding('orphan_guard_masked_by_own_entry', 'warn', 'own bin/main text may mask orphan guards', {
+        maskedScripts: mk.scripts || [], maskedFiles: mk.files || [], guardCount: g.guardCount,
+      });
+    }
+  } 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);

package/lib/pure-utils.js

@@ -1061,9 +1061,16 @@ const _ENUMS_SCRIPTS_RE = /\b(?:Object\.(?:keys|entries)\s*\(\s*[\w.?\s]*\bscrip
 //   1.36.116 (검수 #6): `/^test:/.test(name)` 형태를 못 뽑아 접두가 0개가 되고, 그러면 "전부 덮는다" 로 처리돼
 //   같은 파일의 `check:dead` 까지 실행된 것으로 계상됐다(미탐). 정규식 리터럴 + `.test(` 형태를 추가한다.
 const _ENUM_PREFIX_RE = /startsWith\s*\(\s*["'`]([\w:.-]+)["'`]\s*\)|\.match\s*\(\s*\/\^([\w:.-]+)|\/\^([\w:.-]+)[^/\n]*\/[a-z]*\s*\.test\s*\(/g;
-function _detectOrphanGuards(input) {
+// 1.36.127 (T-0105/T-0106 실측): `opts.ignoreOwnEntryText` — 패키지 **자신의 진입점**의 텍스트를 배선 근거에서만
+//   뺀다(러너 자격·도달성 루트로는 그대로 남긴다). 판정을 바꾸려는 것이 아니라 **무엇이 가려졌는지 재기 위한
+//   반사실**이다. 우리 저장소에서 실측: 기본 0건 → 진입점 텍스트 제외 시 `test:core`·`test:smoke` 2건.
+//   왜 이 방식인가: "문자열인가 호출인가" 를 가리려면 파서가 필요하고, 이 저장소는 0-deps 로 손수 만든
+//   마스커에 이미 한 번 빠졌다(검수 7회 → 되돌림). 그래서 **판정 로직은 손대지 않고** 차이만 보고한다.
+function _detectOrphanGuards(input, opts) {
+  const _ignoreOwnEntryText = !!(opts && opts.ignoreOwnEntryText);
   const scripts = (input && input.packageScripts) || {};      // { name: body }
-  const runners = (input && input.runners) || [];             // [{ file, text }] — CI 워크플로 등
+  const runners = ((input && input.runners) || [])            // [{ file, text }] — CI 워크플로 등
+    .map(r => (_ignoreOwnEntryText && r && r.ownEntry) ? Object.assign({}, r, { text: '' }) : r);
   const scriptFiles = (input && input.scriptFiles) || [];     // ['scripts/check-x.js', ...]
   // ⚠ 관례상 **진입점**인 이름은 대상이 아니다 — `npm test` 는 사람도 CI 도 직접 부르는 표준 동사다.
   //   신규 프로젝트(스크립트 `test` 하나, CI 없음)에서 그걸 "아무도 안 부른다" 고 하면 그건 잡음이고,
@@ -1262,7 +1269,28 @@ function _detectOrphanGuards(input) {
   //   CI 설정 쪽도 **주석은 빼고** 본다 — "# turbo 로 옮길지 검토중" 한 줄로 경고 전체가 꺼지면 안 된다(검수 P2).
   const unknownOrchestrator = Object.entries(scripts).some(([n, b]) => isLive(n) && _ORCH_RE.test(String(b || '')))
     || runners.some(r => _isConfigRunner(r.file) && _ORCH_RE.test(_dropCommentLines(String(r.text || ''))));
-  const orphanScripts = unknownOrchestrator ? [] : guardNames.filter(n => !isLive(n));
+  // 1.36.127 (T-0105 도그푸딩): 잡으려는 것은 **잠든 검사**이지 단축키가 아니다. `test:core` 처럼
+  //   자기가 부르는 파일이 **전부 다른 곳에서 이미 도는** 스크립트는, 아무도 그 이름을 부르지 않아도
+  //   검사가 잠들지 않는다 — 사람용 별칭일 뿐이다. 그런 것을 "아무도 실행하지 않는 검사" 라 부르면
+  //   오탐이고, 오탐이 이 경고를 죽인다. 파일을 하나도 안 부르는 스크립트(인라인 `node -e` 등)는
+  //   판단 근거가 없으므로 **면제하지 않는다**(빈 집합 공허참 차단).
+  //   ⚠ 알려진 한계(false-PASS 편향대로 유지): 같은 파일을 **다른 플래그**로 부르는 경우
+  //     (`x.js` vs `x.js --strict`)는 별칭으로 보고 면제한다 — 플래그 차이까지 보려면 명령 파싱이 필요하다.
+  //   ⚠ (검수 P1, 실측 재현) 확장자 뒤 **경계**가 없으면 `scripts/check.tsx` 가 `scripts/check.ts` 로 잘려
+  //     서로 다른 두 파일이 같은 것으로 보이고, 죽은 스크립트가 별칭으로 면제된다. 경계를 요구한다.
+  const _filesOf = (body) => [...String(body || '').matchAll(/(?:\.{0,2}[/\\])?[\w.-]+[/\\][\w./\\-]*\.(?:m?js|cjs|mts|cts|tsx?|sh)(?![\w])/g)]
+    .map(m => _normPath(m[0]).replace(/^\.\//, ''));
+  const _reachedElsewhere = (name) => {
+    const mine = _filesOf(scripts[name]);
+    if (!mine.length) return false;                        // 파일 없는 스크립트는 근거가 없다 — 면제 안 함
+    const others = Object.entries(scripts).filter(([n]) => n !== name && isLive(n)).map(([, b]) => _filesOf(b)).flat();
+    //   ⚠ (검수 P1, 실측 재현) 러너 텍스트를 원문 그대로 보면 **주석 속 경로**가 면제 근거가 된다
+    //     (`# scripts/dead.js 는 나중에 정리` 한 줄로 그 가드가 사라졌다). 주석은 빼고 본다 —
+    //     같은 함정을 파일 판정 쪽에서 이미 한 번 고쳤는데(검수 재현) 이 신규 경로에 그대로 되살아났다.
+    const runnerText = _normPath(_dropCommentLines(runners.filter(_liveRunner).map(r => String(r.text || '')).join('\n')));
+    return mine.every(f => others.includes(f) || runnerText.includes(f));
+  };
+  const orphanScripts = unknownOrchestrator ? [] : guardNames.filter(n => !isLive(n) && !_reachedElsewhere(n));
   void mentions;
 
   // ③ scripts/ 아래 파일 가드 — 어디에서도 참조되지 않는 것
@@ -1332,6 +1360,18 @@ function _detectOrphanGuards(input) {
     ? ` ⚠ 수집 불완전(읽기실패 ${Number(input.readErrors) || 0} · 대용량 제외 ${Number(input.skippedLarge) || 0}) — 이 목록은 과다보고일 수 있다`
     : '')
     + (monorepoOutOfScope ? ` ⚠ workspaces 저장소 — 루트 package.json 만 봤다(하위 패키지는 범위 밖)` : '');
+  // 1.36.127: 반사실 — 자기 진입점의 **텍스트만** 배선 근거에서 빼면 무엇이 더 보이는가.
+  //   판정(orphanScripts/orphanFiles)은 그대로 두고 차이만 싣는다. 재귀는 한 단계로 막는다.
+  //   이 값이 비어 있지 않다는 것은 "0건이라는 결과를 그대로 믿지 말라" 는 뜻이다 — 조용한 0건을 없앤다.
+  let maskedByOwnEntry = null;
+  if (!_ignoreOwnEntryText && runners.some(r => r && r.ownEntry && String(r.text || ''))) {
+    try {
+      const cf = _detectOrphanGuards(input, { ignoreOwnEntryText: true });
+      const sMore = (cf.orphanScripts || []).filter(x => !orphanScripts.includes(x));
+      const fMore = (cf.orphanFiles || []).filter(x => !orphanFiles.includes(x));
+      if (sMore.length || fMore.length) maskedByOwnEntry = { scripts: sMore, files: fMore };
+    } catch { /* 반사실을 못 재면 그냥 안 싣는다 — 본 판정에 영향 없음 */ }
+  }
   return {
     guardCount: guardNames.length,
     dynamicRunners,
@@ -1340,6 +1380,7 @@ function _detectOrphanGuards(input) {
     orphanFiles,
     scanIncomplete,
     monorepoOutOfScope,
+    maskedByOwnEntry,
     deferred: unknownOrchestrator,
     // 판정 근거를 함께 돌려준다 — 숫자만 보고 못 믿는 일이 없도록(사용자가 근거 없이 목록을 받으면 그냥 끈다)
     reason: (unknownOrchestrator
@@ -1579,14 +1620,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');
 }
@@ -1809,6 +1854,9 @@ function _replaceMdSection(content, heading, newBodyLines, opts = {}) {
 }
 
 module.exports = { _decisionBlocksWithOffset, _blocksWithOffset, _lineOfOffset,
+  // 1.36.127 (검수 P1): 경로 접기 규칙은 **한 곳**이어야 한다 — 수집기가 따로 구현했다가 중간 dot-segment 에서
+  //   갈라져 `ownEntry` 판정이 어긋났다(같은 파일을 다른 이름으로 봄).
+  _normPath,
   _parseImplExports, _briefUnfilled, _planGoalUnfilled, _mdSectionBody, _draftAnchors, _replaceMdSection,
   _matchTool, _parsePackageJsonDeps, _parseRequirementsTxt, _buildGlossary, _renderGlossaryMd, GLOSSARY_START, GLOSSARY_END,
   _isSecretKey, redactSecrets, hasCredentialMarker, compareVer, parseHarnessVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.125",
+  "version": "1.36.127",
   "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,7 +48,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node ./scripts/lint.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e.js",
+    "test": "node ./scripts/lint.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/e2e.js",
     "test:core": "node ./scripts/lint.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js",
     "test:fast": "node ./scripts/lint.js && node ./bin/leerness.js selftest && node ./scripts/smoke.js",
     "test:smoke": "node ./scripts/smoke.js",

package/scripts/e2e.js

@@ -4649,7 +4649,7 @@ total++;
     // 1.36.85: selftest 가 소스문자열 검사 → **행위 검사**로 바뀌며 4초대 → 약 13초가 됐다(CLI spawn 비용).
     //   30s 는 4초 시절 기준이라 전체 e2e 부하에서 타임아웃으로 터졌다(격리 재현 3/3 통과 = 검사 자체는 정상).
     //   여유를 넉넉히 준다 — 이 블록이 재는 것은 "비초기화 dir 에서도 통과하는가"이지 속도가 아니다.
-    const sr = cp.spawnSync(process.execPath, [CLI, 'selftest'], { cwd: ni, encoding: 'utf8', timeout: 180000 });
+    const sr = cp.spawnSync(process.execPath, [CLI, 'selftest'], { cwd: ni, encoding: 'utf8', timeout: 300000 });
     const sout = (sr.stdout || '') + (sr.stderr || '');
     const selftestOk = sr.status === 0 && /전체 \d+건 통과/.test(sout) && !/설치 손상/.test(sout);
     const dr = cp.spawnSync(process.execPath, [CLI, 'doctor'], { cwd: ni, encoding: 'utf8', timeout: 300000 });   // 1.36.87: doctor 는 selftest 를 내장한다 · 1.36.105: 실측 97~101s(게시본 포함) 라 120s 는 여유 1.2배였다 → 300s
@@ -5065,7 +5065,7 @@ total++;
   let ok = false;
   try {
     // 1.36.85: 행위검사 전환으로 selftest 약 13s — 4초 시절 기준 30s 는 전체 부하에서 터진다.
-    const r = cp.spawnSync(process.execPath, [CLI, 'selftest', '--json'], { encoding: 'utf8', timeout: 180000 });
+    const r = cp.spawnSync(process.execPath, [CLI, 'selftest', '--json'], { encoding: 'utf8', timeout: 300000 });
     const j = JSON.parse(r.stdout);
     ok = j.ok === true && j.pass === j.total && j.fail === 0 && j.total >= 112 && r.status === 0;
   } catch {}
@@ -5083,7 +5083,7 @@ total++;
   let ok = false;
   try {
     const repoRoot = path.resolve(__dirname, '..');
-    const r = cp.spawnSync(process.execPath, [CLI, 'selftest', '--json'], { cwd: repoRoot, encoding: 'utf8', timeout: 180000, maxBuffer: 64 * 1024 * 1024 });
+    const r = cp.spawnSync(process.execPath, [CLI, 'selftest', '--json'], { cwd: repoRoot, encoding: 'utf8', timeout: 300000, maxBuffer: 64 * 1024 * 1024 });
     const pureStdout = typeof r.stdout === 'string' && r.stdout.trimStart().startsWith('{');
     const j = JSON.parse(r.stdout);                       // 계약: stdout 전체가 단일 JSON 문서
     const payloadOk = j.ok === true && j.pass === j.total && j.fail === 0 && j.total > 0;
@@ -5482,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++;
@@ -7160,8 +7164,12 @@ total++;
     // ⑦ (1.28.2 Phase 10c) doctor: en 영어(한글 0) + ko 기본 한글 보존
     // 1.36.87: doctor 는 내부에서 selftest 를 돌린다 — 실측 19~24s 인데 제한이 20s 라 여유가 없었다(1.36.86 에서도 0.9s).
     //   제한을 올린 대신 종료코드도 함께 단언한다 — 타임아웃(status=null)이 출력 매칭만으로 통과하면 안 된다(codex 26차 #11).
-    const docEnR = cp.spawnSync(process.execPath, [CLI, 'doctor', '--language', 'en'], { encoding: 'utf8', timeout: 120000, cwd: d });
-    const docKoR = cp.spawnSync(process.execPath, [CLI, 'doctor'], { encoding: 'utf8', timeout: 120000, cwd: d });
+    // 1.36.127 (실측): 1.36.105 가 형제 블록의 doctor 제한을 120s→300s 로 올리며 "여유가 1.2배뿐이라
+    //   전체 부하에서 반복해 터진다" 고 적었는데, **이 클론은 120s 로 남아 있었다**(같은 수정의 누락분).
+    //   이번 게이트에서 실제로 여기서만 터졌고, 격리 실측은 `doctor --language en` **120s**(= 제한과 동일, 여유 1.0배).
+    //   측정 대상은 속도가 아니라 언어 렌더이므로 넉넉히 준다.
+    const docEnR = cp.spawnSync(process.execPath, [CLI, 'doctor', '--language', 'en'], { encoding: 'utf8', timeout: 300000, cwd: d });
+    const docKoR = cp.spawnSync(process.execPath, [CLI, 'doctor'], { encoding: 'utf8', timeout: 300000, cwd: d });
     const docEn = out(docEnR), docKo = out(docKoR);
     const doctorOk = docEnR.status === 0 && docKoR.status === 0
       && /install\/environment diagnosis/.test(docEn) && !H.test(docEn) && /설치\/환경 진단/.test(docKo);
@@ -12311,14 +12319,29 @@ total++;
       //   *다른 프로젝트용* CI 를 생성하는 코드라 `npm run test:smoke` 같은 문자열을 담고 있고,
       //   CI 가 그 파일을 직접 실행하므로 러너로 수집된다(정상 프로젝트에선 그게 맞는 판단이다).
       //   그래서 기준값은 **우리 CLI 소스를 뺀 입력**으로 잰다 — 탐지기가 망가지면 여기서 잡힌다.
-      //   ⚠ `test:core`·`test:smoke` 는 실제로 어떤 러너도 부르지 않는다(ci.yml 은 `test:fast` 만 돌린다).
-      //   나중에 CI 에 배선하면 이 단언을 **의도적으로** 갱신하라.
+      //   ⚠ (1.36.127) 위 주석은 "`test:core`·`test:smoke` 를 아무도 안 부른다 — 배선하면 **의도적으로**
+      //   이 단언을 갱신하라" 고 적어 두었다. 이번 라운드에 실제로 배선했다(`e2e-core.js` → npm test + CI),
+      //   그리고 `test:smoke` 는 그 파일이 `test:fast` 로 이미 도는 **별칭**이라 면제 대상이 됐다.
+      //   그래서 기대값을 0건으로 바꾼다 — 다만 **0건을 그냥 단언하면 탐지기가 죽어도 통과한다**.
+      //   실제 수집 입력에 **가짜 잠든 가드를 심어** 잡히는지 함께 본다(계측이 살아 있다는 증거).
       const selfNoBin = Object.assign({}, selfInp, { runners: selfInp.runners.filter(r => !/bin[\\/]leerness\.js$/.test(r.file)) });
       const selfBase = PU._detectOrphanGuards(selfNoBin);
-      for (const expect of ['test:smoke', 'test:core']) {
-        if (!selfBase.orphanScripts.includes(expect)) bad.push(`자기기준:${expect}가고아목록에없음(${selfBase.orphanScripts.join(',') || '없음'})`);
-      }
+      if (selfBase.orphanScripts.length) bad.push(`자기기준:이제0이어야(${selfBase.orphanScripts.join(',')})`);
       if (selfBase.orphanScripts.includes('test:fast')) bad.push('자기기준:CI가도는test:fast를오탐');
+      {
+        //   ⚠ 자기참조 7회차: 심을 이름을 **소스에 적으면** 이 파일(scripts/e2e.js)이 러너로 수집되면서
+        //   그 이름이 '덮인 것'이 돼 계측이 조용히 죽는다(실측으로 재현했다). 리터럴 쪼개기는 다음 사람이
+        //   이름을 적는 순간 또 뚫린다 — 그래서 이름 자체를 **실행 시 생성**한다(소스에 존재할 수 없음).
+        const uniq = `check-${process.pid.toString(36)}${(selfNoBin.scriptFiles || []).length.toString(36)}.js`;
+        const uniqPath = `scripts/${uniq}`;
+        const planted = Object.assign({}, selfNoBin, {
+          packageScripts: Object.assign({}, selfNoBin.packageScripts, { 'test:planted': `node ${uniqPath}` }),
+          scriptFiles: (selfNoBin.scriptFiles || []).concat(uniqPath),
+        });
+        const pr = PU._detectOrphanGuards(planted);
+        if (!pr.orphanScripts.includes('test:planted')) bad.push('자기기준:심은잠든가드를못잡음(탐지기죽음)');
+        if (!pr.orphanFiles.includes(uniqPath)) bad.push(`자기기준:심은파일을못잡음(${uniqPath})`);
+      }
       // 그리고 **불변식**으로 고정한다: 이 테스트 파일 자체가 판정을 바꾸면 안 된다.
       //   리터럴 쪼개기로 막으면 다음에 누가 이름을 적는 순간 또 뚫린다 — 값이 아니라 성질을 단언한다.
       const selfNoE2e = PU._detectOrphanGuards(Object.assign({}, selfNoBin,
@@ -12411,6 +12434,280 @@ total++;
   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++;
+}
+
+// 1.36.127 (T-0105/T-0106 도그푸딩): 고아 가드 탐지기가 **자기 저장소에서 눈이 멀어 있었다**.
+//   CI 가 `bin/leerness.js` 를 실행하므로 그 파일이 러너로 잡히고, 그 안의 selftest 단언 문자열
+//   (`'test:core'`·`e2e-core.js`)이 호출로 읽혀 leerness 자신의 진짜 고아가 0건으로 보고됐다.
+//   ① audit 이 그 가림을 **사용자에게 말하는가** ② 대조군은 조용한가 ③ 그리고 우리 자신이 실제로 배선했는가.
+total++;
+{
+  let ok = false; const bad = []; const dbg = {};
+  const sb = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-mask127-'));
+  const envM = 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 envM[k];
+  try {
+    // ① 피해자 픽스처 — 자기 진입점이 잠든 가드 이름을 **문자열로만** 담는다
+    const d = path.join(sb, 'p'); fs.mkdirSync(path.join(d, 'scripts'), { recursive: true });
+    fs.mkdirSync(path.join(d, '.github', 'workflows'), { recursive: true });
+    fs.writeFileSync(path.join(d, 'package.json'), JSON.stringify({
+      name: 'p', version: '0.1.0', bin: { p: 'bin/p.js' },
+      scripts: { test: 'node scripts/check-a.js', 'test:dead': 'node scripts/check-dead.js' },
+    }, null, 2));
+    fs.mkdirSync(path.join(d, 'bin'), { recursive: true });
+    //   호출이 아니라 **문서 문자열** — 사람 눈에는 명백히 호출이 아니지만 탐지기는 구분하지 못한다(0-deps 파서 없음).
+    fs.writeFileSync(path.join(d, 'bin', 'p.js'), 'const help = "run test:dead (scripts/check-dead.js) manually";\nconsole.log(help);\n');
+    fs.writeFileSync(path.join(d, 'scripts', 'check-a.js'), 'process.exit(0);\n');
+    fs.writeFileSync(path.join(d, 'scripts', 'check-dead.js'), 'process.exit(0);\n');
+    fs.writeFileSync(path.join(d, '.github', 'workflows', 'ci.yml'), 'jobs:\n  t:\n    steps:\n      - run: npm test\n      - run: node ./bin/p.js\n');
+    const ri = cp.spawnSync(process.execPath, [CLI, 'init', d, '--yes'], { cwd: d, encoding: 'utf8', timeout: 600000, env: envM });
+    if (ri.status !== 0) bad.push(`①init실패(${ri.status})`);
+    const au = cp.spawnSync(process.execPath, [CLI, 'audit', '--path', d, '--json'], { cwd: d, encoding: 'utf8', timeout: 600000, env: envM, maxBuffer: 32 * 1024 * 1024 });
+    let aj = null; try { aj = JSON.parse(au.stdout); } catch { bad.push('①auditJSON아님'); }
+    const fs2 = aj && Array.isArray(aj.findings) ? aj.findings : [];
+    const mask = fs2.find(x => x.kind === 'orphan_guard_masked_by_own_entry');
+    if (!mask) bad.push('①가림_미보고');
+    else {
+      if (!(mask.maskedScripts || []).includes('test:dead')) bad.push(`①가림목록=${JSON.stringify(mask.maskedScripts)}`);
+      if (!(mask.maskedFiles || []).includes('scripts/check-dead.js')) bad.push(`①가림파일=${JSON.stringify(mask.maskedFiles)}`);
+    }
+    //   판정 자체는 종전대로 조용해야 한다(오탐 편향 유지 — 가림 보고는 **추가**이지 판정 변경이 아니다)
+    if (fs2.some(x => x.kind === 'orphan_guard')) bad.push('①판정이바뀜(오탐편향깨짐)');
+    if (!/자신의 진입점 텍스트에 가려질 수 있습니다/.test(
+      cp.spawnSync(process.execPath, [CLI, 'audit', '--path', d], { cwd: d, encoding: 'utf8', timeout: 600000, env: envM }).stdout || '')) bad.push('①사람용문구없음');
+    dbg.masked = mask ? { s: mask.maskedScripts, f: mask.maskedFiles } : null;
+
+    // ② 대조군 — 진입점이 그 이름을 담지 않으면 가림 보고는 없고, 진짜 고아가 그대로 잡힌다
+    const d2 = path.join(sb, 'q'); fs.mkdirSync(path.join(d2, 'scripts'), { recursive: true });
+    fs.mkdirSync(path.join(d2, '.github', 'workflows'), { recursive: true });
+    fs.mkdirSync(path.join(d2, 'bin'), { recursive: true });
+    fs.writeFileSync(path.join(d2, 'package.json'), JSON.stringify({
+      name: 'q', version: '0.1.0', bin: { q: 'bin/q.js' },
+      scripts: { test: 'node scripts/check-a.js', 'test:dead': 'node scripts/check-dead.js' },
+    }, null, 2));
+    fs.writeFileSync(path.join(d2, 'bin', 'q.js'), 'console.log("nothing to see");\n');
+    fs.writeFileSync(path.join(d2, 'scripts', 'check-a.js'), 'process.exit(0);\n');
+    fs.writeFileSync(path.join(d2, 'scripts', 'check-dead.js'), 'process.exit(0);\n');
+    fs.writeFileSync(path.join(d2, '.github', 'workflows', 'ci.yml'), 'jobs:\n  t:\n    steps:\n      - run: npm test\n      - run: node ./bin/q.js\n');
+    cp.spawnSync(process.execPath, [CLI, 'init', d2, '--yes'], { cwd: d2, encoding: 'utf8', timeout: 600000, env: envM });
+    let aj2 = null;
+    try { aj2 = JSON.parse(cp.spawnSync(process.execPath, [CLI, 'audit', '--path', d2, '--json'], { cwd: d2, encoding: 'utf8', timeout: 600000, env: envM, maxBuffer: 32 * 1024 * 1024 }).stdout); } catch { bad.push('②auditJSON아님'); }
+    const f2 = aj2 && Array.isArray(aj2.findings) ? aj2.findings : [];
+    if (f2.some(x => x.kind === 'orphan_guard_masked_by_own_entry')) bad.push('②대조군에가림보고');
+    const og = f2.find(x => x.kind === 'orphan_guard');
+    if (!og) bad.push('②진짜고아_미탐지(계측붕괴)');
+    else if (!(og.orphanScripts || []).includes('test:dead')) bad.push(`②고아목록=${JSON.stringify(og.orphanScripts)}`);
+    dbg.control = { masked: f2.some(x => x.kind === 'orphan_guard_masked_by_own_entry'), orphan: !!og };
+
+    // ②-b (검수 P1) 경로 표기가 조금만 달라도 가림 경고가 통째로 빠지면 안 된다 —
+    //   CI 가 `node ./bin/./p.js` 로 적으면 수집 파일명은 `bin/./p.js`, 선언은 `bin/p.js` 라
+    //   정확 일치 비교가 어긋나 `ownEntry:false` 가 되고 **조용한 0건이 그대로 재발**했다(실측 재현).
+    {
+      const d3 = path.join(sb, 'r'); fs.mkdirSync(path.join(d3, 'scripts'), { recursive: true });
+      fs.mkdirSync(path.join(d3, '.github', 'workflows'), { recursive: true });
+      fs.mkdirSync(path.join(d3, 'bin'), { recursive: true });
+      fs.writeFileSync(path.join(d3, 'package.json'), JSON.stringify({
+        name: 'r', version: '0.1.0', bin: 'bin/r.js',
+        scripts: { test: 'node scripts/check-a.js', 'test:dead': 'node scripts/check-dead.js' },
+      }, null, 2));
+      fs.writeFileSync(path.join(d3, 'bin', 'r.js'), 'const help = "run test:dead (scripts/check-dead.js) manually";\n');
+      fs.writeFileSync(path.join(d3, 'scripts', 'check-a.js'), 'process.exit(0);\n');
+      fs.writeFileSync(path.join(d3, 'scripts', 'check-dead.js'), 'process.exit(0);\n');
+      //   ⚠ 중간 dot-segment — 이 표기 하나가 예전엔 경고를 통째로 없앴다
+      fs.writeFileSync(path.join(d3, '.github', 'workflows', 'ci.yml'), 'jobs:\n  t:\n    steps:\n      - run: npm test\n      - run: node ./bin/./r.js\n');
+      cp.spawnSync(process.execPath, [CLI, 'init', d3, '--yes'], { cwd: d3, encoding: 'utf8', timeout: 600000, env: envM });
+      let aj3 = null;
+      try { aj3 = JSON.parse(cp.spawnSync(process.execPath, [CLI, 'audit', '--path', d3, '--json'], { cwd: d3, encoding: 'utf8', timeout: 600000, env: envM, maxBuffer: 32 * 1024 * 1024 }).stdout); } catch { bad.push('②b auditJSON아님'); }
+      const f3 = aj3 && Array.isArray(aj3.findings) ? aj3.findings : [];
+      const m3 = f3.find(x => x.kind === 'orphan_guard_masked_by_own_entry');
+      if (!m3) bad.push('②b dot-segment 표기에서 가림보고 사라짐');
+      else if (!(m3.maskedScripts || []).includes('test:dead')) bad.push(`②b가림목록=${JSON.stringify(m3.maskedScripts)}`);
+      dbg.dotSeg = { masked: !!m3 };
+    }
+
+    // ③ 우리 자신 — 도구가 알려준 것을 실제로 고쳤는가(66초짜리 42블록이 안 돌고 있었다)
+    //   (검수 P2) 단순 부분문자열이면 `echo scripts/e2e-core.js` 로도 통과한다 — **실행 형태**를 요구한다:
+    //   npm test 본문에서 `node …e2e-core.js` 가 명령 경계(시작 또는 `&&`)에 있어야 하고,
+    //   CI 는 `run:` 줄의 **명령 첫 토큰**이 node 여야 한다. 완전한 실행 의미 검증은 아니지만 echo 위조는 막는다.
+    const ownPkg = JSON.parse(fs.readFileSync(path.resolve(path.dirname(CLI), '..', 'package.json'), 'utf8'));
+    const testBody = String(ownPkg.scripts && ownPkg.scripts.test || '');
+    const inNpmTest = /(^|&&)\s*node\s+\.?\/?scripts\/e2e-core\.js(\s|$|&)/.test(testBody);
+    if (!inNpmTest) bad.push(`③e2e-core가 npm test 에 실행형태로 미배선(${testBody.slice(0, 80)})`);
+    const ciText = fs.readFileSync(path.resolve(path.dirname(CLI), '..', '.github', 'workflows', 'ci.yml'), 'utf8');
+    const inCi = ciText.split('\n').some(l => /^\s*(-\s*)?run:\s*node\s+\.?\/?scripts\/e2e-core\.js\s*$/.test(l));
+    if (!inCi) bad.push('③e2e-core가 CI 에 실행형태로 미배선');
+    //   위조 대조군 — 같은 단언이 `echo …` 를 **거부하는지** 함께 확인한다(단언이 살아 있다는 증거).
+    if (/(^|&&)\s*node\s+\.?\/?scripts\/e2e-core\.js(\s|$|&)/.test('echo scripts/e2e-core.js')) bad.push('③단언이 echo 위조를 통과시킴');
+    dbg.self = { inNpmTest, inCi };
+    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 ? `✓ W(1.36.127/T-0105) 고아 가드 가림: 자기 진입점 문자열이 판정을 가리면 **후보를 이름으로** 보고(판정은 불변) · 대조군은 조용하고 진짜 고아는 그대로 · 우리 자신도 e2e-core 배선 완료 ${JSON.stringify(dbg)}`
+    : '✗ 1.36.127 고아 가드 가림 보고 실패 ' + 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);