leerness 1.36.118 → 1.36.120

package/README.md

@@ -122,7 +122,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.118 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.120 하네스를 사용합니다. 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.118는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
+Leerness v1.36.120는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -197,7 +197,7 @@ Leerness v1.36.118는 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.118 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.120 릴리스 태그 이력** (수백 라운드) · _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.118: 2026-08-14
+Last synced by Leerness v1.36.120: 2026-08-15
 <!-- 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.118';
+const VERSION = '1.36.120';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -4781,7 +4781,9 @@ function _selfTestCases() {
       const wired = src.includes("if (cmd === 'export' || cmd === 'prompt') {")
         && src.includes("arg('--target', null)")
         && src.includes("'agents-md': 'codex'")
-        && src.includes('return adapterCmd(arg(\'--path\', process.cwd()), _xTool);');
+        // 1.36.119: 별칭도 `adapter` 와 **같은 손상 가드**를 타야 한다 — 전엔 일반 error 로 떨어져
+        //   자동화가 '손상' 과 '그 밖의 실패' 를 구분할 수 없었다(검수 P2).
+        && src.includes('_guardStore(has(\'--json\'), () => adapterCmd(arg(\'--path\', process.cwd()), _xTool))');
       return wired;
     } },
     { name: '12th 외부평가 Sonnet P3 (UR-0143): plan drop 은 plan.md(D-)만 기록, progress-tracker T- 행 미생성 (1.9.449)', run: () => {
@@ -23913,23 +23915,30 @@ function adapterCmd(root, tool, opts = {}) {
     if (files[k] == null) continue;
     results.push(writeIfSafe(root, k, files[k], { mergeManaged: managedOverwrite.has(k), lang: lang === 'en' ? 'en' : 'ko' }));   // 1.36.60 (검수 2차 #2): 래퍼 언어 전달 (altTemplate 은 전환-감지 없는 이 경로에선 미적용 — High 회귀 방지)
   }
-  if (a.mcp) results.push(_mergeMcpJson(root));
+  // 1.36.119 (검수): 아래 안내 문구의 판정 대상을 **MCP 병합 결과로 한정**한다. 전에는 `results` 전체를 훑었고,
+  //   지금 맞는 이유는 `writeIfSafe` 가 'merged'/'preserved' 만 돌려주기 때문이다 — 그 이름이 바뀌면
+  //   지침 파일을 썼다는 이유로 "MCP 호출 가능" 이라고 말하게 된다(우연한 정합은 계약이 아니다).
+  const mcpResults = [];
+  if (a.mcp) { const _m = _mergeMcpJson(root); results.push(_m); mcpResults.push(_m); }
   // 1.36.116 (검수 P1-D): Cursor 의 프로젝트별 MCP 설정은 `.cursor/mcp.json` 이다. 루트 `.mcp.json` 만 만들어 놓고
   //   "Cursor 도 인식한다" 고 말하던 것은 거짓 안내였다 — 이 어댑터의 목적 자체가 그 도구를 배선하는 것이다.
   //   루트 파일도 그대로 둔다(다른 도구가 쓴다). 같은 병합기라 손상 파일은 여전히 보존/중단된다.
-  if (tool === 'cursor') { _assertStoreParsable(path.join(root, '.cursor', 'mcp.json'), '.cursor/mcp.json'); results.push(_mergeMcpJson(root, '.cursor/mcp.json')); }
+  if (tool === 'cursor') { _assertStoreParsable(path.join(root, '.cursor', 'mcp.json'), '.cursor/mcp.json'); const _m2 = _mergeMcpJson(root, '.cursor/mcp.json'); results.push(_m2); mcpResults.push(_m2); }
   if (json) { log(JSON.stringify({ adapter: tool, files: results }, null, 2)); return; }
   ok(`adapter ${tool} (${a.label}) 적용 — ${results.length}개 파일`);
   for (const r of results) log(`  ${r.action}: ${r.file}`);
   // 1.36.117 (검수 P1): 깨진 항목을 보존했을 때도 "직접 호출 가능" 이라고 말하고 있었다 — 그건 거짓 성공이다.
-  const _brk = results.filter(r => r.broken);
+  const _brk = mcpResults.filter(r => r.broken);
   if (_brk.length) _brk.forEach(r => warn(`${r.file} 의 leerness 항목에 command 가 없어 서버가 뜨지 않습니다 — 사용자 설정이라 보존했습니다`));
   // 1.36.118 (자체 헌트): **보존**했을 때도 "leerness MCP verb 를 직접 호출 가능" 이라고 말하고 있었다.
   //   보존한 항목이 leerness 를 띄우는지는 우리가 확인하지 않았다(사용자가 다른 서버를 적어 뒀을 수도 있다) —
   //   우리가 쓴 항목이 하나라도 있을 때만 그렇게 말한다. 그 밖에는 무엇을 보존했는지만 알린다.
-  const _wrote = results.filter(r => r.action === 'created' || r.action === 'updated');
-  const _kept = results.filter(r => r.preserved && !r.broken);
-  if (a.mcp && _wrote.length) log(`  ℹ MCP 등록 — 이 도구가 leerness MCP verb(state_show/start/record/verify/handoff)를 직접 호출 가능`);
+  const _wrote = mcpResults.filter(r => r.action === 'created' || r.action === 'updated');
+  const _kept = mcpResults.filter(r => r.preserved && !r.broken);
+  // 1.36.120 (검수·자체 재현): cursor 는 MCP 설정이 **둘**(루트 `.mcp.json` + `.cursor/mcp.json`)이다.
+  //   한쪽만 우리가 썼는데 "이 도구가 직접 호출 가능" 이라고 하면, 정작 그 도구가 읽는 파일은 남의 설정일 수 있다.
+  //   주장은 **파일 단위**로 한다 — 우리가 쓴 파일만 이름을 대고 말한다.
+  _wrote.forEach(r => log(`  ℹ ${r.file} 에 MCP 등록 — 이 파일을 읽는 도구는 leerness MCP verb(state_show/start/record/verify/handoff)를 직접 호출 가능`));
   _kept.forEach(r => log(`  ℹ ${r.file} 의 기존 leerness 항목을 그대로 두었습니다 — 그 항목이 leerness MCP 를 띄우는지는 확인하지 않았습니다`));
   // 보존은 안전하지만 **막다른 길이면 안 된다** — 우리 것이 망가졌을 때 되돌릴 방법을 알려 준다(자체 헌트).
   if (_kept.length || _brk.length) log(`     → 표준 설정으로 되돌리려면 그 파일의 "leerness" 항목을 지우고 이 명령을 다시 실행하세요`);
@@ -27022,7 +27031,9 @@ async function main() {
     const _ADAPTER_ALIAS = { 'agents-md': 'codex', 'agents': 'codex', 'agent': 'codex', 'agents.md': 'codex' };
     let _xTool = arg('--target', null) || (args[1] && !args[1].startsWith('-') ? args[1] : 'list');
     _xTool = _ADAPTER_ALIAS[String(_xTool).toLowerCase()] || _xTool;
-    return adapterCmd(arg('--path', process.cwd()), _xTool);
+    // 1.36.119 (검수 P2): 같은 공개 명령의 **별칭**인데 `adapter` 만 손상을 구조화해 내고 여기는 일반 error 였다 —
+    //   자동화가 '손상' 과 '그 밖의 실패' 를 구분할 수 없다. 같은 가드를 태운다.
+    return _guardStore(has('--json'), () => adapterCmd(arg('--path', process.cwd()), _xTool));
   }
   // 1.9.245: API skill cache — 공식 문서·관련링크 자동 정리 (사용자 명시 UR-0015)
   if (cmd === 'api-skill')                           return apiSkillCmd(arg('--path', process.cwd()), args[1] || 'help');

package/lib/audit.js

@@ -36,7 +36,10 @@ function _collectGuardInputs(root) {
   let ownEntries = new Set();
   let workspaces = false;
   try {
-    const pkg = JSON.parse(rd(path.join(root, 'package.json')) || '{}');
+    //   0바이트 `package.json` 은 유효 JSON 이 아닌데 `|| '{}'` 가 그것을 '스크립트 없음' 으로 삼켰다(검수 P2).
+    const _pkgRaw = rd(path.join(root, 'package.json'));
+    if (_pkgRaw != null && !String(_pkgRaw).trim()) throw new Error('empty package.json');
+    const pkg = JSON.parse(_pkgRaw || '{}');
     packageScripts = pkg.scripts || {};
     workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces.length > 0 : !!(pkg.workspaces && pkg.workspaces.packages);
     // 1.36.116 (실측): 패키지 **자신의 진입점**(bin/main)은 러너가 아니라 제품이다. leerness 에서 실제로 물렸다 —
@@ -87,15 +90,27 @@ function _collectGuardInputs(root) {
   //   가드를 배선하고 있으면 그걸 못 봐서 정상 가드가 고아로 뒤집힌다. CI 가 부르면 그건 러너가 맞다.
   //   ⚠ 단 **주석 줄에서 수집하면 안 된다**: `# debug: node bin/cli.js` 한 줄로 제품 진입점이 러너가 되고
   //   그 안의 문자열이 진짜 고아를 덮는다(검수 P2 — 자기참조가 주석 경로로 되살아난다).
-  const _noComment = (s) => String(s).split('\n').filter(l => !/^\s*(#|\/\/|--|;)/.test(l)).join('\n');
+  //   CMD 스텝의 `REM`·`::` 도 주석이다(검수 재현: `REM debug: node .\bin\phantom.js` 한 줄로 제품 진입점이 러너가 됐다).
+  //   ⚠ `--`·`;` 는 여기서 다루는 파일 종류(YAML·Makefile·셸·JS)에서 주석이 아니다 — 오히려 여러 줄 명령의
+  //   연속 인자(`--file=scripts/x.js`)를 지워 파일 참조를 잃는다. 주석 표기는 실제로 쓰이는 것만 둔다.
+  const _noComment = (s) => String(s).split('\n').filter(l => !/^\s*(#|\/\/|::|@?REM\s)/i.test(l)).join('\n');
+  //   설명 필드(`- name: archive index.js`)는 실행 증거가 아니다 — bare 진입점 매처에도 같은 규칙을 건다.
+  //   단 값이 **산문일 때만** 설명으로 본다(matrix 변수명이 `name` 일 수 있다 — 판정기와 같은 규칙).
+  const _noDescriptive = (s) => String(s).split('\n').filter(l => {
+    const m = /^\s*-?\s*(?:name|description|title|summary|comment|displayName|label)\s*:\s*(.*)$/i.exec(l);
+    if (!m) return true;
+    const v = String(m[1]).trim();
+    return !v || v.startsWith('[') || !/\s/.test(v);
+  }).join('\n');
   for (const r of runners.slice()) {
     const txt = _noComment(r.text);
     for (const m of txt.matchAll(_FILE_RE)) push(_norm(m[0]), null);
     // 디렉터리 접두가 없는 진입점(`"main": "index.js"`)은 위 정규식이 못 잡는다 — 선언된 bin/main 만 이름으로 확인한다.
+    const bareTxt = _noDescriptive(txt);
     for (const own of ownEntries) {
       if (/[/\\]/.test(own)) continue;
       const esc = own.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      if (new RegExp(`(^|[^\\w.\\-/\\\\])\\.?[/\\\\]?${esc}([^\\w.-]|$)`, 'm').test(txt)) push(own, null);
+      if (new RegExp(`(^|[^\\w.\\-/\\\\])\\.?[/\\\\]?${esc}([^\\w.-]|$)`, 'm').test(bareTxt)) push(own, null);
     }
   }
   for (const [name, body] of Object.entries(packageScripts)) for (const m of String(body || '').matchAll(_FILE_RE)) {
@@ -135,7 +150,13 @@ function audit(root, opts = {}, deps = {}) {
   const findings = [];
   const _finding = (kind, severity, message, details = {}) => findings.push({ kind, severity, message, ...details });
   const _origWrite = process.stdout.write.bind(process.stdout);
-  if (jsonMode) process.stdout.write = () => true;
+  // 1.36.120: `--json` 은 **stdout 만** 막고 있었다 — `warn()` 이 쓰는 stderr 로 사람용 문구가 그대로 샜다.
+  //   그 결과 JSON 계약 표면에 잡음이 남고, 그 잡음의 내용이 **프로젝트 상태에 따라** 달라져
+  //   게이트 판정이 저장소 상태에 종속됐다(같은 코드로 통과/실패가 갈렸다). json 모드에서는 양쪽을 다 막는다.
+  //   (findings 배열이 그 정보를 이미 싣고 있으므로 사람용 문구는 중복이다.)
+  const _origErrWrite = process.stderr.write.bind(process.stderr);
+  const _restoreStreams = () => { process.stdout.write = _origWrite; process.stderr.write = _origErrWrite; };
+  if (jsonMode) { process.stdout.write = () => true; process.stderr.write = () => true; }
   try {
   // 외부리뷰 CV-3/UR-0078: 미초기화/존재하지 않는 경로를 healthy 로 오판하던 것 수정 — 필수 마커 부재 시 failure 승격(verify 와 일관).
   if (!exists(root) || !exists(path.join(root, '.harness')) || !exists(path.join(root, 'AGENTS.md'))) {
@@ -144,7 +165,7 @@ function audit(root, opts = {}, deps = {}) {
     _finding('not_initialized', 'fail', 'uninitialized or missing path (.harness or AGENTS.md absent)', { root });
     // 1.27.1 (13번째 외부리뷰 #2): 미초기화 시 후속 체크(design/reuse 등)를 없는 하네스에 대해 보고하던 모순 출력 차단 — 요약/JSON 으로 직행 후 종료(exit code/JSON 페이로드는 종전과 동일).
     log(`Audit summary: warnings=${warnings} failures=${failures}`);
-    if (jsonMode) { process.stdout.write = _origWrite; process.stdout.write(JSON.stringify({ version: VERSION, root, warnings, failures, fixed, healthy: false, fixApplied: fix, strict: has('--strict'), strictThreshold: has('--strict') ? parseInt(arg('--threshold', '1'), 10) : null, summary: `warnings=${warnings} failures=${failures}`, findings }, null, 2) + '\n'); }
+    if (jsonMode) { _restoreStreams(); process.stdout.write(JSON.stringify({ version: VERSION, root, warnings, failures, fixed, healthy: false, fixApplied: fix, strict: has('--strict'), strictThreshold: has('--strict') ? parseInt(arg('--threshold', '1'), 10) : null, summary: `warnings=${warnings} failures=${failures}`, findings }, null, 2) + '\n'); }
     process.exitCode = 1;
     return;
   }
@@ -542,7 +563,7 @@ function audit(root, opts = {}, deps = {}) {
   log(`Audit summary: warnings=${warnings} failures=${failures}${fix ? ` fixed=${fixed}` : ''}${has('--strict') ? ` strict-threshold=${arg('--threshold', '1')}` : ''}`);
   } finally {
     // 1.9.102: stdout 복원
-    if (jsonMode) process.stdout.write = _origWrite;
+    if (jsonMode) _restoreStreams();
   }
   // 1.9.102: JSON 모드 — 구조화 출력
   if (jsonMode) {

package/lib/pure-utils.js

@@ -1209,16 +1209,22 @@ function _detectOrphanGuards(input) {
       //   줄 필터는 **코드 파일**에만 건다 — 거기서만 이름이 데이터로 등장한다(우리 e2e.js 가 그랬다).
       //   ⚠ CI 설정을 전문으로 보되 **설명용 필드는 뺀다**: `- name: TODO check:leaf 를 붙이자`,
       //   `env: { FOO: check:x }`, artifact 이름 같은 것이 그것만으로 '호출됨' 이 됐다(자체 헌트 + 검수 재현).
-      //   금지 목록은 유계가 아니므로(라벨 키는 얼마든지 새로 생긴다) **허용 목록**으로 뒤집는다:
-      //   `key: value` 꼴은 key 가 실행 키일 때만 보고, 키가 없는 줄(목록 항목·연속 줄)과
-      //   실행 토큰이 있는 줄은 그대로 본다. 진짜 배선이면 `run:` 줄이 반드시 있다.
-      const _KEY_RE = /^\s*-?\s*([A-Za-z_][\w.-]*)\s*:\s/;
-      const _RUN_KEYS = /^(?:run|cmd|command|commands|entrypoint|args|script|scripts|shell|uses|with)$/i;
-      const _INVOKE = /\b(?:npm|npx|yarn|pnpm|make|exec)\b/;
+      //   ⚠ 한때 **허용 목록**(실행 키만 본다)으로 뒤집었다가 되돌렸다. 그건 정상 배선을 버렸다(검수 재현):
+      //   `matrix: { target: [check:leaf] }` + `run: npm run ${{ matrix.target }}` 에서 `target` 은 실행 키가
+      //   아니므로 잘려 나가고, 실행 줄에는 이름이 없어 **정상 가드가 고아로 보고**된다. Azure 의 `customCommand:` 도 같다.
+      //   이 저장소의 편향은 명시적이다 — **오탐이 이 경고를 죽인다**. 그래서 방향은 과소 보고다:
+      //   사람이 읽는 설명 필드만 빼고 나머지는 그대로 본다.
+      //   그 대가(측정됨): `env: { TARGET: check:x }`·`key: check:x-hash` 처럼 **데이터 값**에 이름이 있으면
+      //   그것을 호출로 보고 진짜 고아를 가린다. 그건 미탐이라 감수한다.
+      //   ⚠ `name:` 을 **무조건** 설명으로 보면 matrix 변수명이 `name` 인 정상 배선이 잘려 나간다(검수 재현):
+      //   `matrix: { name: [check:leaf] }` + `run: npm run ${{ matrix.name }}`. 값이 **산문일 때만** 설명으로 본다 —
+      //   목록(`[...]`)이나 공백 없는 단일 토큰은 데이터일 수 있으므로 남긴다(편향은 과소 보고).
+      const _DESCRIPTIVE = /^\s*-?\s*(?:name|description|title|summary|comment|displayName|label)\s*:\s*(.*)$/i;
       const _configLineOk = (l) => {
-        const m = _KEY_RE.exec(l);
-        if (!m) return true;                    // 목록 항목(`- check:a`)·연속 줄
-        return _RUN_KEYS.test(m[1]) || _INVOKE.test(l);
+        const m = _DESCRIPTIVE.exec(l);
+        if (!m) return true;
+        const v = String(m[1]).trim();
+        return !v || v.startsWith('[') || !/\s/.test(v);
       };
       const _raw = _dropCommentLines(String(r.text || ''));
       const t = _isConfigRunner(r.file)
@@ -1244,8 +1250,13 @@ function _detectOrphanGuards(input) {
   //    1.36.116: 참조하는 쪽이 **도달 가능해야** 덮은 것으로 본다 — 아무도 안 부르는 스크립트가 파일을
   //    언급해 봐야 그 파일도 안 도는 건 마찬가지다(스크립트 쪽 #7 과 같은 결함이 파일 쪽에도 있었다).
   const liveScripts = Object.entries(scripts).filter(([n]) => isLive(n));
-  const allText = runners.filter(_liveRunner).map(r => String(r.text || '')).join('\n') + '\n'
-    + liveScripts.map(([, b]) => String(b || '')).join('\n');
+  //    ⚠ 매칭 전에 경로 구분자를 정규화한다. Windows CI 는 `node scripts\x\check.js` 로 적는데
+  //    후보 경로는 `/` 표기라 전체 경로가 안 맞고, basename 경계 판정은 앞의 `\` 때문에 걸러져
+  //    **실제로 실행되는 가드가 고아로 보고됐다**(자체 헌트 실측: POSIX 표기만 통과).
+  //    `scripts/./check.js` 같은 dot-segment 도 편다 — 전체 경로 비교가 정규화를 안 해서 실제 호출이
+  //    고아로 보고됐다(검수 재현). basename 경계는 앞의 `/` 를 거부하므로 폴백으로도 안 잡혔다.
+  const allText = (runners.filter(_liveRunner).map(r => String(r.text || '')).join('\n') + '\n'
+    + liveScripts.map(([, b]) => String(b || '')).join('\n')).replace(/\\/g, '/').split('/./').join('/');
   //    ⚠ basename 만으로 덮였다고 보면 **동명 파일이 서로를 살린다**(검수 P2): `a/check.js` 를 부르는 배선이
   //    `b/check.js` 까지 덮어 버린다. basename 은 그 이름이 유일할 때만 근거로 쓴다.
   const _baseCount = new Map();
@@ -1253,23 +1264,35 @@ function _detectOrphanGuards(input) {
   //    ⚠ 그런데 유일성만으로 끄면 **해석 가능한 상대 호출**까지 잃는다(검수 P2): `scripts/a/run.js` 안의
   //    `require('./check.js')` 는 `scripts/a/check.js` 를 가리키는데, 동명 파일이 있다는 이유로 그것까지 고아가 됐다.
   //    참조한 러너의 디렉터리를 기준으로 상대 경로를 **해석해서** 덮인 집합에 넣는다.
+  //    ⚠ 원문을 그대로 훑으면 **주석 속 참조**도 실행으로 계상되고(검수 재현: `// require("./a/check.js")`),
+  //    `..` 가 루트 밖으로 나가면 남은 조각이 엉뚱한 루트 내부 파일로 해석된다. 둘 다 막는다.
+  //    구분자는 `\` 도 받는다(`require(".\\a\\check.js")`).
   const _resolved = new Set();
   for (const r of runners.filter(_liveRunner)) {
-    const dir = String(r.file || '').replace(/\\/g, '/').split('/').slice(0, -1);
-    for (const m of String(r.text || '').matchAll(/(\.{1,2}(?:\/[\w.-]+)+\.(?:m?js|cjs|ts|sh))/g)) {
+    //    ⚠ 기준 디렉터리가 다르다: **CI 설정의 명령은 프로젝트 루트에서 실행**된다(`run: node ./scripts/x.js`).
+    //    설정 파일 위치(`.github/workflows`) 기준으로 풀면 `.github/workflows/scripts/x.js` 가 돼 실제 호출을 놓친다(검수 재현).
+    //    코드 파일 안의 `require('./x')` 는 그 파일 기준이 맞다.
+    const dir = _isConfigRunner(r.file) ? [] : String(r.file || '').replace(/\\/g, '/').split('/').slice(0, -1);
+    const body = _dropCommentLines(String(r.text || ''));
+    for (const m of body.matchAll(/(\.{1,2}(?:[/\\][\w.-]+)+\.(?:m?js|cjs|ts|sh))/g)) {
       const segs = dir.slice();
-      for (const s of m[1].split('/')) {
+      let escaped = false;
+      for (const s of m[1].replace(/\\/g, '/').split('/')) {
         if (s === '.' || s === '') continue;
-        if (s === '..') segs.pop(); else segs.push(s);
+        if (s === '..') { if (!segs.length) { escaped = true; break; } segs.pop(); } else segs.push(s);
       }
-      _resolved.add(segs.join('/'));
+      // `scripts/./check.js` 처럼 중간 dot-segment 가 남아 있으면 여기서 이미 걸러진다(위 루프가 `.` 를 건너뛴다).
+      if (!escaped) _resolved.add(segs.join('/'));
     }
   }
   const orphanFiles = unknownOrchestrator ? [] : scriptFiles.filter(f => {
     const full = String(f).replace(/\\/g, '/');
     if (allText.includes(full) || _resolved.has(full)) return false;
     const base = full.split('/').pop();
-    if (_baseCount.get(base) === 1 && allText.includes(base)) return false;
+    //    basename 폴백은 **경로의 일부**를 잡으면 안 된다: `../../outside/check.js` 가 우리 `scripts/check.js` 를
+    //    덮어 버렸다(자체 검증에서 실측). 앞에 경로 구분자가 없는 **단독 언급**일 때만 근거로 쓴다.
+    const _bnRe = new RegExp(`(^|[^\\w./\\\\-])${base.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^\\w.-]|$)`);
+    if (_baseCount.get(base) === 1 && _bnRe.test(allText)) return false;
     return true;
   });
 

package/package.json

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

@@ -5088,8 +5088,10 @@ total++;
     const j = JSON.parse(r.stdout);                       // 계약: stdout 전체가 단일 JSON 문서
     const payloadOk = j.ok === true && j.pass === j.total && j.fail === 0 && j.total > 0;
     const se = r.stderr || '';
-    // 알려진 유출원 3종: fail() 프로브의 '✗ ' · graph 사람용 3줄(파일경로/노드수/안내)
-    const noiseFree = !se.includes('✗ ') && !se.includes('leerness.html →') && !/nodes · /.test(se);
+    // 1.36.120: 잡음을 **열거**하는 대신 stderr 를 통째로 0 으로 고정한다. audit 이 `--json` 에서 stdout 만 막고
+    //   stderr 는 열어 둬서 사람용 경고가 샜고(309B), 그 문구가 **프로젝트 상태에 따라** 달라져
+    //   같은 코드로 게이트가 통과/실패로 갈렸다(실측). 열거는 유계가 아니다 — 원인 단계에서 막았으니 여기선 0을 요구한다.
+    const noiseFree = se.trim() === '';
     ok = pureStdout && payloadOk && noiseFree && r.status === 0;
   } catch {}
   console.log(ok ? '✓ B(1.36.88) selftest --json 계약: 리포 루트 cwd stdout 순수 JSON + stderr 잡음 0' : '✗ selftest --json 계약 실패 (stdout 오염 또는 stderr 잡음)');
@@ -11222,6 +11224,41 @@ total++;
       cp.spawnSync(process.execPath, [CLI, 'adapter', 'claude', '--path', dm2], { cwd: dm2, encoding: 'utf8', timeout: 300000, env: ENV });
       const afterLen = fs.readFileSync(path.join(dm2, 'CLAUDE.md'), 'utf8').length;
       if (afterLen > beforeLen * 1.5) bad.push(`adapter:등급무시(${beforeLen}→${afterLen})`);
+      // (검수 P3) manifest **형상** 5종을 고정한다 — `_assertStoreParsable` 은 문법만 보므로
+      //   `null`·`[]`·`false`·`0`·문자열이 통과한 뒤 조용히 standard 로 되돌아갔다.
+      for (const shape of ['null', '[]', 'false', '0', '"minimal"']) {
+        const dsh = mk(['--mode', 'minimal']);
+        const shLen = fs.readFileSync(path.join(dsh, 'CLAUDE.md'), 'utf8').length;
+        fs.writeFileSync(path.join(dsh, '.harness', 'manifest.json'), shape);
+        const rsh = cp.spawnSync(process.execPath, [CLI, 'adapter', 'claude', '--path', dsh], { cwd: dsh, encoding: 'utf8', timeout: 300000, env: ENV });
+        if (rsh.status === 0) bad.push(`manifest형상:${shape}에서_중단안함`);
+        if (fs.readFileSync(path.join(dsh, 'CLAUDE.md'), 'utf8').length !== shLen) bad.push(`manifest형상:${shape}에서_등급뒤집힘`);
+      }
+      // 판별력 — 정상 객체(구형: mode 없음)는 통과해야 한다(형상 검사가 과하면 기존 설치가 깨진다)
+      const dok = mk(['--mode', 'minimal']);
+      fs.writeFileSync(path.join(dok, '.harness', 'manifest.json'), JSON.stringify({ installedAt: '2026-01-01' }, null, 2));
+      if (cp.spawnSync(process.execPath, [CLI, 'adapter', 'claude', '--path', dok], { cwd: dok, encoding: 'utf8', timeout: 300000, env: ENV }).status !== 0) bad.push('manifest형상:정상객체를_거부');
+      // (검수 P2) `export`/`prompt` 는 같은 명령의 별칭이다 — 손상을 구조화해 내야 자동화가 구분한다
+      const dex = mk(['--mode', 'minimal']);
+      fs.writeFileSync(path.join(dex, '.harness', 'manifest.json'), 'false');
+      const rex = cp.spawnSync(process.execPath, [CLI, 'export', 'claude', '--path', dex, '--json'], { cwd: dex, encoding: 'utf8', timeout: 300000, env: ENV });
+      let jex = null; try { jex = JSON.parse(String(rex.stdout || '').trim()); } catch {}
+      if (!jex || jex.code !== 'store_corrupt' || rex.status === 0) bad.push(`export별칭:손상코드아님(${jex && jex.code}/${rex.status})`);
+      // (검수 P3) `prompt` 도 같은 별칭이다 — `export` 만 검사하면 `prompt` 를 가드 밖으로 빼는 변이가 산다.
+      const dpr = mk(['--mode', 'minimal']);
+      fs.writeFileSync(path.join(dpr, '.harness', 'manifest.json'), 'false');
+      const rpr = cp.spawnSync(process.execPath, [CLI, 'prompt', 'claude', '--path', dpr, '--json'], { cwd: dpr, encoding: 'utf8', timeout: 300000, env: ENV });
+      let jpr = null; try { jpr = JSON.parse(String(rpr.stdout || '').trim()); } catch {}
+      if (!jpr || jpr.code !== 'store_corrupt' || rpr.status === 0) bad.push(`prompt별칭:손상코드아님(${jpr && jpr.code}/${rpr.status})`);
+      // (검수 P3) MCP 안내가 **MCP 결과에만** 결부되는지 — 지침 파일이 새로 생기는 경로에서 검사해야
+      //   `results` 로 되돌리는 변이가 죽는다(기존 픽스처는 모두 init 이 끝난 뒤라 우연히 같았다).
+      const dmr = path.join(sb, 'mcponly'); fs.mkdirSync(dmr, { recursive: true });
+      fs.writeFileSync(path.join(dmr, 'package.json'), '{"name":"m","version":"0.1.0"}');
+      fs.writeFileSync(path.join(dmr, '.mcp.json'), JSON.stringify({ mcpServers: { leerness: { command: 'node', args: ['./mine.js'] } } }, null, 2));
+      const rmr = cp.spawnSync(process.execPath, [CLI, 'adapter', 'claude', '--path', dmr], { cwd: dmr, encoding: 'utf8', timeout: 300000, env: ENV });
+      const omr = String(rmr.stdout || '') + String(rmr.stderr || '');
+      if (/MCP 등록 —/.test(omr)) bad.push('MCP안내가_지침파일생성으로_발화');
+      if (!/확인하지 않았습니다/.test(omr)) bad.push('MCP보존_중립문구없음');
       // 판별력 — standard 프로젝트에서는 adapter 가 여전히 standard 를 유지해야 한다(등급 반영이 전부를 줄이면 안 된다)
       const ds2 = mk();
       const sBefore = fs.readFileSync(path.join(ds2, 'CLAUDE.md'), 'utf8').length;
@@ -11312,6 +11349,19 @@ total++;
       cp.spawnSync(process.execPath, [CLI, 'adapter', 'cursor', '--path', dc3], { cwd: dc3, encoding: 'utf8', timeout: 300000, env: ENV });
       let jc3 = null; try { jc3 = JSON.parse(fs.readFileSync(path.join(dc3, '.cursor', 'mcp.json'), 'utf8')); } catch {}
       if (!jc3 || jc3.mcpServers.leerness.command !== 'node' || !jc3.mcpServers.other) bad.push('cursor:사용자설정미보존');
+      // (검수·자체 재현) cursor 는 MCP 설정이 **둘**이다. 한쪽만 우리가 썼는데 "이 도구가 직접 호출 가능" 이라고 하면
+      //   정작 그 도구가 읽는 파일은 남의 설정일 수 있다 — 주장은 우리가 쓴 **파일 이름과 함께** 해야 한다.
+      const dc4 = mk();
+      fs.rmSync(path.join(dc4, '.mcp.json'), { force: true });
+      fs.mkdirSync(path.join(dc4, '.cursor'), { recursive: true });
+      fs.writeFileSync(path.join(dc4, '.cursor', 'mcp.json'), JSON.stringify({ mcpServers: { leerness: { command: 'node', args: ['./mine.js'] } } }, null, 2));
+      const rc4 = cp.spawnSync(process.execPath, [CLI, 'adapter', 'cursor', '--path', dc4], { cwd: dc4, encoding: 'utf8', timeout: 300000, env: ENV });
+      const oc4 = String(rc4.stdout || '') + String(rc4.stderr || '');
+      if (!/\.mcp\.json 에 MCP 등록/.test(oc4)) bad.push('cursor:쓴파일_범위표기없음');
+      if (/\.cursor[\\/]mcp\.json 에 MCP 등록/.test(oc4)) bad.push('cursor:보존파일까지_호출가능주장');
+      if (!/확인하지 않았습니다/.test(oc4)) bad.push('cursor:보존_중립문구없음');
+      let jc4 = null; try { jc4 = JSON.parse(fs.readFileSync(path.join(dc4, '.cursor', 'mcp.json'), 'utf8')); } catch {}
+      if (!jc4 || jc4.mcpServers.leerness.command !== 'node') bad.push('cursor:보존실패');
     }
     // ⑦ (검수 P1) `_ours` 경계 — 우리가 만든 **정확한 형태**만 갱신하고, 모르는 키가 하나라도 붙으면 보존한다.
     //    그리고 명시적으로 적힌 falsy 값을 '없음' 으로 오인해 덮어쓰면 안 된다.
@@ -11556,6 +11606,8 @@ total++;
           if (f.severity !== 'warn') bad.push(`권고아님(${f.severity})`);            // 차단으로 승격되면 안 된다
           if (!(f.orphanScripts || []).includes('test:orphan-guard')) bad.push('audit_대상누락');
           if (!f.reason) bad.push('audit_근거없음');
+          // (검수 P3) 범위 메타데이터는 고아가 **있을 때도** 실려야 한다 — 0건 분기에만 넣으면 계약이 갈린다.
+          if (!('monorepoOutOfScope' in f) || !('deferred' in f)) bad.push('audit_범위메타누락');
         }
       }
       // 대조군 — 고아가 없으면 이 발견이 나오면 안 된다(오탐 0)
@@ -11765,6 +11817,112 @@ total++;
         const cr = ci.runners.find(r => /tools[\\/]ci\.js$/.test(r.file)) || {};
         if (!cr.unconditional) bad.push('CI직접호출_출처_유실');
         if (PU._detectOrphanGuards(ci).orphanScripts.length) bad.push('CI직접호출인데_고아로_오탐');
+        // (검수 P2) CMD 스텝의 `REM` 주석에서 제품 진입점을 러너로 승격시키면 자기참조가 되살아난다
+        const d6c = path.join(sb4, 'rem');
+        fs.mkdirSync(path.join(d6c, 'bin'), { recursive: true });
+        fs.mkdirSync(path.join(d6c, '.github', 'workflows'), { recursive: true });
+        fs.writeFileSync(path.join(d6c, 'package.json'), JSON.stringify({ name: 'r', version: '0.1.0', bin: { r: 'bin/phantom.js' },
+          scripts: { test: 'node t.js', 'check:leaf': 'node l.js' } }));
+        fs.writeFileSync(path.join(d6c, '.github', 'workflows', 'ci.yml'),
+          'jobs:\n  a:\n    steps:\n      - shell: cmd\n        run: |\n          REM debug only: node .\\bin\\phantom.js\n          echo harmless\n      - run: npm test\n');
+        fs.writeFileSync(path.join(d6c, 'bin', 'phantom.js'), 'const x = "npm run check:leaf";\n');
+        const remInp = AUD._collectGuardInputs(d6c);
+        if (remInp.runners.some(r => /phantom\.js$/.test(r.file))) bad.push('CMD주석에서_진입점_수집');
+        if (!PU._detectOrphanGuards(remInp).orphanScripts.includes('check:leaf')) bad.push('CMD주석이_고아를_덮음');
+        // (검수 P3) `REM` 만 검사하면 `::`·`@REM` 변이가 산다 — 주석 표기별로 잰다.
+        for (const [tag, mark] of [['::', '::'], ['@REM', '@REM']]) {
+          fs.writeFileSync(path.join(d6c, '.github', 'workflows', 'ci.yml'),
+            `jobs:\n  a:\n    steps:\n      - shell: cmd\n        run: |\n          ${mark} debug: node .\\bin\\phantom.js\n          echo harmless\n      - run: npm test\n`);
+          const ri = AUD._collectGuardInputs(d6c);
+          if (ri.runners.some(r => /phantom\.js$/.test(r.file))) bad.push(`CMD주석(${tag})에서_진입점_수집`);
+        }
+        // (검수 P3) bare 진입점(`main: index.js`)의 설명 필터 — 픽스처가 없어 되돌리는 변이가 살았다.
+        const dbe = path.join(sb4, 'bare');
+        fs.mkdirSync(path.join(dbe, '.github', 'workflows'), { recursive: true });
+        fs.writeFileSync(path.join(dbe, 'package.json'), JSON.stringify({ name: 'b', version: '0.1.0', main: 'index.js',
+          scripts: { test: 'node t.js', 'check:leaf': 'node l.js' } }));
+        fs.writeFileSync(path.join(dbe, '.github', 'workflows', 'ci.yml'), 'jobs:\n  a:\n    steps:\n      - name: archive index.js\n        run: npm test\n');
+        fs.writeFileSync(path.join(dbe, 'index.js'), 'sh("npm run check:leaf")\n');
+        const beInp = AUD._collectGuardInputs(dbe);
+        if (beInp.runners.some(r => /index\.js$/.test(r.file))) bad.push('설명필드가_bare진입점을_승격');
+        if (!PU._detectOrphanGuards(beInp).orphanScripts.includes('check:leaf')) bad.push('설명필드_승격이_고아를_덮음');
+        // 판별력 — 실제 실행이면 수집돼야 한다
+        fs.writeFileSync(path.join(dbe, '.github', 'workflows', 'ci.yml'), 'jobs:\n  a:\n    steps:\n      - run: node index.js --guard\n');
+        const beInp2 = AUD._collectGuardInputs(dbe);
+        if (!beInp2.runners.some(r => /index\.js$/.test(r.file))) bad.push('실제실행인데_bare진입점_미수집');
+        // (검수 P3) 0바이트 package.json 을 **실제로 수집**해서 계상되는지 — 지금까지는 readErrors 를 주입만 했다.
+        const dz = path.join(sb4, 'zero'); fs.mkdirSync(dz, { recursive: true });
+        fs.writeFileSync(path.join(dz, 'package.json'), '');
+        const zInp = AUD._collectGuardInputs(dz);
+        if (!zInp.readErrors) bad.push('0바이트_package.json_미계상');
+        if (!/수집 불완전/.test(PU._detectOrphanGuards(zInp).reason || '')) bad.push('0바이트_근거미표기');
+        // (검수 P2) 상대 경로 해석: 주석 속 참조는 무시, 루트 밖은 내부 파일로 오인 금지, 역슬래시도 해석
+        const rel1 = PU._detectOrphanGuards({
+          packageScripts: { test: 'node scripts/run-a.js && node scripts/run-b.js' },
+          runners: [{ file: '.github/workflows/ci.yml', text: 'run: npm test', viaScript: null, viaScripts: [], unconditional: true },
+            { file: 'scripts/run-a.js', text: '// require("./a/check.js")\n', viaScript: 'test', viaScripts: ['test'] },
+            { file: 'scripts/run-b.js', text: 'require("./b/check.js");\n', viaScript: 'test', viaScripts: ['test'] }],
+          scriptFiles: ['scripts/a/check.js', 'scripts/b/check.js'],
+        });
+        if (!rel1.orphanFiles.includes('scripts/a/check.js')) bad.push('주석속_상대참조를_실행으로');
+        if (rel1.orphanFiles.includes('scripts/b/check.js')) bad.push('실제_상대참조를_고아로');
+        const rel2 = PU._detectOrphanGuards({
+          packageScripts: { test: 'node scripts/run.js' },
+          runners: [{ file: '.github/workflows/ci.yml', text: 'run: npm test', viaScript: null, viaScripts: [], unconditional: true },
+            { file: 'scripts/run.js', text: 'require("../../outside/check.js");\n', viaScript: 'test', viaScripts: ['test'] }],
+          scriptFiles: ['scripts/check.js'],
+        });
+        if (!rel2.orphanFiles.includes('scripts/check.js')) bad.push('루트밖_참조가_내부파일을_덮음');
+        // ⚠ 루트 이탈(`../../../…`) 가드는 **여기서 관측할 수 없다** — 측정해 보고 단언을 뺐다:
+        //   `allText` 의 전체 경로 비교가 부분 문자열이라, 이탈 경로도 우리 후보를 접미로 포함하면 어차피 덮인다.
+        //   경계 판정을 전체 경로에까지 걸면 흔한 `./scripts/x.js` 표기가 깨지므로 그렇게 하지 않는다.
+        //   가드 자체는 남긴다(해석 결과가 접미가 아닌 경우를 위한 방어) — 다만 공허한 단언을 두지는 않는다.
+        const relIn = PU._detectOrphanGuards({
+          packageScripts: { test: 'node scripts/a/run.js' },
+          runners: [{ file: '.github/workflows/ci.yml', text: 'run: npm test', viaScript: null, viaScripts: [], unconditional: true },
+            { file: 'scripts/a/run.js', text: 'require("../../scripts/./check.js");\n', viaScript: 'test', viaScripts: ['test'] }],
+          scriptFiles: ['scripts/check.js'],
+        });
+        if (relIn.orphanFiles.length) bad.push(`루트내_dot세그먼트_경로_오탐(${relIn.orphanFiles.join(',')})`);
+        // (검수 P3) 역슬래시 상대경로 — 픽스처가 없어 `[/\\]` 를 `/` 로 줄이는 변이가 살았다.
+        const relBs = PU._detectOrphanGuards({
+          packageScripts: { test: 'node scripts/a/run.js' },
+          runners: [{ file: '.github/workflows/ci.yml', text: 'run: npm test', viaScript: null, viaScripts: [], unconditional: true },
+            { file: 'scripts/a/run.js', text: 'require(".\\check.js");\n', viaScript: 'test', viaScripts: ['test'] }],
+          scriptFiles: ['scripts/a/check.js', 'scripts/b/check.js'],
+        });
+        if (relBs.orphanFiles.includes('scripts/a/check.js')) bad.push('역슬래시_상대경로_미해석');
+        // (검수) CI 설정의 명령은 **프로젝트 루트**에서 돈다 — 설정 파일 위치 기준으로 풀면 실제 호출을 놓친다.
+        const relRoot = PU._detectOrphanGuards({
+          packageScripts: { test: 'node t.js' },
+          runners: [{ file: '.github/workflows/ci.yml', viaScript: null, viaScripts: [], unconditional: true,
+            text: 'jobs:\n  a:\n    steps:\n      - run: node ./scripts/deep/check.js\n      - run: npm test\n' }],
+          scriptFiles: ['scripts/deep/check.js'],
+        });
+        if (relRoot.orphanFiles.length) bad.push(`CI상대경로_루트기준아님(${relRoot.orphanFiles.join(',')})`);
+        // dot-segment 가 낀 전체 경로도 정규화돼야 한다
+        const relDot = PU._detectOrphanGuards({
+          packageScripts: { test: 'node run.sh' },
+          runners: [{ file: '.github/workflows/ci.yml', text: 'run: npm test', viaScript: null, viaScripts: [], unconditional: true },
+            { file: 'run.sh', text: 'node scripts/./check.js\n', viaScript: 'test', viaScripts: ['test'] }],
+          scriptFiles: ['scripts/check.js'],
+        });
+        if (relDot.orphanFiles.length) bad.push(`dot세그먼트_경로_오탐(${relDot.orphanFiles.join(',')})`);
+        // (자체 헌트) Windows CI 는 `node scripts\x\check.js` 로 적는다. 후보 경로는 `/` 표기라
+        //   전체 경로가 안 맞고 basename 경계 판정도 앞의 `\` 때문에 걸러져 **정상 배선이 고아로 보고**됐다.
+        for (const [label, ref] of [['posix', 'scripts/x/check.js'], ['win', 'scripts\\x\\check.js'], ['win-dot', '.\\scripts\\x\\check.js']]) {
+          const rw = PU._detectOrphanGuards({ packageScripts: { test: 'node t.js' },
+            runners: [{ file: '.github/workflows/ci.yml', viaScript: null, viaScripts: [], unconditional: true,
+              text: `jobs:\n  a:\n    steps:\n      - run: node ${ref}\n      - run: npm test\n` }],
+            scriptFiles: ['scripts/x/check.js'] });
+          if (rw.orphanFiles.includes('scripts/x/check.js')) bad.push(`경로표기_오탐:${label}`);
+        }
+        // 판별력 — 루트의 동명 파일을 부르는 것은 하위 디렉터리 후보를 덮지 않는다(경계 판정의 목적)
+        const rw2 = PU._detectOrphanGuards({ packageScripts: { test: 'node t.js' },
+          runners: [{ file: '.github/workflows/ci.yml', viaScript: null, viaScripts: [], unconditional: true,
+            text: 'jobs:\n  a:\n    steps:\n      - run: node .\\check.js\n      - run: npm test\n' }],
+          scriptFiles: ['scripts/x/check.js', 'scripts/y/check.js'] });
+        if (rw2.orphanFiles.length !== 2) bad.push(`경로경계_과다커버(${rw2.orphanFiles.join(',')})`);
       } finally { try { fs.rmSync(sb4, { recursive: true, force: true }); } catch {} }
     }
     // ⑰ (검수 P2) 와일드카드가 있다고 실행은 아니다 — `echo "test:*"` 는 아무것도 안 돌린다.
@@ -11838,6 +11996,13 @@ total++;
       ['산문만', 'jobs:\n  a:\n    steps:\n      - name: TODO check:leaf 붙이기\n        run: echo skip\n', true],
       ['name 뒤 실제 run', 'jobs:\n  a:\n    steps:\n      - name: Run check:leaf\n        run: npm run check:leaf\n', false],
       ['matrix', 'jobs:\n  a:\n    strategy:\n      matrix:\n        script: [check:leaf]\n    steps:\n      - run: npm run ${{ matrix.script }}\n', false],
+      // ⚠ 한때 **허용 목록**(실행 키만 본다)으로 뒤집었다가 되돌렸다 — 아래 두 케이스가 그때 고아로 뒤집혔다(오탐).
+      //   이 저장소의 편향은 "오탐이 경고를 죽인다" 이므로 방향은 과소 보고다. 이 두 줄이 그 결정을 고정한다.
+      ['matrix 변수명(실행키 아님)', 'jobs:\n  a:\n    strategy:\n      matrix:\n        target: [check:leaf]\n    steps:\n      - run: npm run ${{ matrix.target }}\n', false],
+      ['Azure customCommand', 'steps:\n- task: Npm@1\n  inputs:\n    command: custom\n    customCommand: run check:leaf\n', false],
+      // (검수) `name:` 을 **무조건** 설명으로 보면 matrix 변수명이 `name` 인 정상 배선이 잘린다.
+      //   값이 산문일 때만 설명이다 — 목록·단일 토큰은 데이터일 수 있으므로 남긴다.
+      ['matrix 변수명이 name', 'jobs:\n  a:\n    strategy:\n      matrix:\n        name: [check:leaf]\n    steps:\n      - run: npm run ${{ matrix.name }}\n', false],
     ]) {
       const rr = PU._detectOrphanGuards({ packageScripts: { test: 'node t.js', 'check:leaf': 'node l.js' },
         runners: [{ file: '.github/workflows/ci.yml', text, viaScript: null, viaScripts: [] }], scriptFiles: [] });