leerness 1.36.170 → 1.36.171

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.36.171 — 2026-08-27
+
+- MCP handoff/session-close가 호출별 sessionKey로 presence를 등록·종료하고, Windows 환경변수 casing·일회성 marker·legacy case variant·손상 closedAt를 안전하게 처리하도록 개선했습니다. 전용 MCP presence 회귀 22/22와 전체 E2E 467/467를 추가·통과했습니다.
+
 ## 1.36.170 — 2026-08-27
 
 - next-action의 정규화 계약을 모든 읽기 표면으로 확장했습니다. release-time auto-resume plan 생성과 외부 에이전트용 `context`가 legacy `--filter`, 자동 완료 명령, 시간 기반 중복, 존재하지 않는 stress 실행을 다시 노출하지 않습니다.

package/README.md

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

package/bin/leerness.js

@@ -48,13 +48,33 @@ const {
   migrateLegacyWorkspace,
 } = require('../lib/workspace-dir');
 
-const VERSION = '1.36.170';
+const VERSION = '1.36.171';
+
+// MCP lifecycle 주소 표식은 현재 CLI 호출 한 번에만 유효하다. CLI bootstrap에서 즉시 env에서
+// 떼어 두어 `--no-record`/hook처럼 presence 기록 함수에 도달하지 않는 경로도 후속 child에 유출하지 않는다.
+let _directMcpPresenceMarkerPending = false;
+function _deleteEnvKeyCaseInsensitive(env, canonical) {
+  const folded = String(canonical).toLowerCase();
+  for (const key of Object.keys(env || {})) {
+    if (key.toLowerCase() === folded) delete env[key];
+  }
+}
+function _captureDirectMcpPresenceMarker() {
+  const markerKey = process.platform === 'win32'
+    ? Object.keys(process.env).find(key => key.toLowerCase() === 'leerness_mcp_address_explicit')
+    : (Object.prototype.hasOwnProperty.call(process.env, 'LEERNESS_MCP_ADDRESS_EXPLICIT')
+      ? 'LEERNESS_MCP_ADDRESS_EXPLICIT' : null);
+  if (markerKey && process.env[markerKey] === '1') _directMcpPresenceMarkerPending = true;
+  // 인식 여부와 무관하게 모든 casing을 떼어 자식 프로세스에 일회성 marker가 새지 않게 한다.
+  _deleteEnvKeyCaseInsensitive(process.env, 'LEERNESS_MCP_ADDRESS_EXPLICIT');
+}
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
 //   해결: 부작용을 _cliBootstrap() 으로 묶고 파일 끝 require.main 가드에서만 호출. import/단위테스트는 부작용 0.
 // 1.9.249 (UR-0018): 터미널 출력 한국어 깨짐 사전 방지 (stdout UTF-8 + Windows 비-65001 시 chcp 65001 자동, opt-out LEERNESS_NO_AUTOCHCP=1).
 function _ensureStdoutEncoding() {
+  _captureDirectMcpPresenceMarker();
   try {
     if (process.stdout && process.stdout.setEncoding) process.stdout.setEncoding('utf8');
     if (process.stderr && process.stderr.setEncoding) process.stderr.setEncoding('utf8');
@@ -7491,15 +7511,22 @@ function _selfTestCases() {
       if (SP.suppressionReason(Object.assign({}, base, { LEERNESS_NO_SESSION_PRESENCE: '1' }), true) !== 'opt-out') return false;
       if (SP.suppressionReason(base, false) !== 'not-a-leerness-project') return false;
       if (SP.suppressionReason({}, true) !== 'not-identifiable') return false;
-      // ⑤ 프루닝 — 입력은 {name, record}, 반환은 **파일명**. 상한을 넘기면 자르되 자기 것은 안 자르고,
-      //    적으면 아무것도 안 자른다(상한만 재면 "전부 삭제"가 통과한다).
+      const addressedMcp = Object.assign({}, base, { LEERNESS_INTERNAL: '1', LEERNESS_SESSION_ID: 'mcpdirect01', LEERNESS_MCP_ADDRESS_EXPLICIT: '1' });
+      if (SP.suppressionReason(addressedMcp, true) !== null) return false;
+      if (SP.suppressionReason(Object.assign({}, addressedMcp, { LEERNESS_HOOK: '1' }), true) !== 'hook') return false;
+      if (SP.suppressionReason(Object.assign({}, addressedMcp, { CI: '1' }), true) !== 'ci') return false;
+      // ⑤ 프루닝 — 입력은 {name, record}, 반환은 **파일명**. 열린 동료 레코드는 상한을 넘어도
+      //    절대 자르지 않고, 닫힌 tombstone에만 상한/TTL을 적용한다.
       const mkE = (i, extra) => ({ name: `key${String(i).padStart(5, '0')}.json`,
         record: Object.assign({ sessionKey: `key${String(i).padStart(5, '0')}`, openedAt: new Date(1700000000000 + i * 1000).toISOString(), closedAt: null }, extra || {}) });
       const many = Array.from({ length: 30 }, (_, i) => mkE(i));
       const pruned = SP.selectPrunable(many, { selfKey: 'key00000', nowMs: Date.now() });
-      if (pruned.includes('key00000.json')) return false;                    // 자기 것은 안 자른다
-      if ((30 - pruned.length) > SP.SESSIONS_KEEP + 1) return false;         // 상한이 실제로 걸린다
-      if (!pruned.length) return false;                                      // 계측 생존
+      if (pruned.length !== 0) return false;                                 // 열린 peer 30건 모두 보존
+      const manyClosed = many.map((e, i) => mkE(i, { closedAt: new Date(Date.now() - i * 1000).toISOString() }));
+      const prunedClosed = SP.selectPrunable(manyClosed, { selfKey: 'key00000', nowMs: Date.now() });
+      if (prunedClosed.includes('key00000.json')) return false;              // 자기 것은 안 자른다
+      if ((30 - prunedClosed.length) > SP.SESSIONS_KEEP + 1) return false;   // 닫힌 레코드 상한은 실제로 걸린다
+      if (!prunedClosed.length) return false;
       const few = Array.from({ length: 5 }, (_, i) => mkE(i));
       if (SP.selectPrunable(few, { selfKey: 'key00000', nowMs: Date.now() }).length !== 0) return false;
       //    close 기록이 TTL 을 넘긴 것은 자르고, 갓 닫힌 것은 안 자른다
@@ -7507,6 +7534,20 @@ function _selfTestCases() {
       if (SP.selectPrunable(closedOld, { selfKey: 'other123', nowMs: Date.now() }).length !== 1) return false;
       const closedNew = [mkE(1, { closedAt: new Date(Date.now() - 60000).toISOString() })];
       if (SP.selectPrunable(closedNew, { selfKey: 'other123', nowMs: Date.now() }).length !== 0) return false;
+      //    canonical toISOString이 아닌 close 값은 종료 증거가 아니다. Date.parse가 관대하게 받는
+      //    숫자/불가능한 달력 날짜도 20개 상한이나 payload mismatch 정리로 지우지 않고,
+      //    같은 host의 다른 세션 기록으로 계속 센다.
+      const malformedValues = ['not-a-date', '0', '1', '2024-02-30T00:00:00.000Z', '2024-02-30T00:00:00Z'];
+      const malformed = Array.from({ length: 21 }, (_, i) => mkE(i, { closedAt: malformedValues[i % malformedValues.length] }));
+      malformed.push({ name: 'wrongpeer.json', record: { sessionKey: 'otherpeer', hostId: 'hostAAA', closedAt: 'not-a-date' } });
+      if (SP.selectPrunable(malformed, { selfKey: 'me000000', nowMs: Date.now() }).length !== 0) return false;
+      if (malformed.some(e => SP.hasConfirmedClose(e.record))) return false;
+      if (SP.confirmedCloseMs({ closedAt: new Date(1700000000000).toISOString() }) !== 1700000000000) return false;
+      const caseConflict = SP.caseVariantConflict([
+        Object.assign({}, { name: 'CasePeer01.json', record: { sessionKey: 'CasePeer01', closedAt: null } }),
+        Object.assign({}, { name: 'casepeer01.json', record: { sessionKey: 'casepeer01', closedAt: 'not-a-date' } }),
+      ]);
+      if (!caseConflict || caseConflict.count !== 2 || caseConflict.reason !== 'ambiguous-open-case-variants') return false;
       //    (검수 P2, 실측 재현) **파일명과 키가 어긋난 레코드**가 남을 지우면 안 된다 — 자기 파일만 정리된다
       const victim = { name: 'victimxx.json', record: { sessionKey: 'victimxx', openedAt: new Date().toISOString(), lastHandoffAt: new Date().toISOString(), closedAt: null } };
       const forged = { name: 'fakefake.json', record: { sessionKey: 'victimxx', openedAt: new Date(1700000000000).toISOString(), closedAt: new Date(1700000000000).toISOString() } };
@@ -7526,6 +7567,8 @@ function _selfTestCases() {
         { sessionKey: 'otherkk3', hostId: 'hostBBB', closedAt: null },
       ];
       if (SP.countOtherSessions(recs, 'selfkey1', H) !== 1) return false;
+      if (SP.countOtherSessions([{ sessionKey: 'otherkk1', hostId: H, closedAt: 'not-a-date' }], 'selfkey1', H) !== 1) return false;
+      if (SP.countOtherSessions([{ sessionKey: 'SelfKey1', hostId: H, closedAt: null }], 'selfkey1', H) !== 0) return false;
       if (SP.countOtherSessions([recs[0]], 'selfkey1', H) !== 0) return false;              // 자기만 → 0(침묵)
       if (SP.countOtherSessions([recs[3]], 'selfkey1', H) !== 0) return false;              // 다른 머신뿐 → 0(침묵)
       //    (검수 P2) hostId 를 모르면 '다른 머신' 이라고 단정하지 않는다 — 3상태
@@ -13206,24 +13249,62 @@ function _sessionHostId(root) {
     return require('crypto').createHash('sha256').update(salt + '|' + String(os.hostname())).digest('hex').slice(0, 12);
   } catch { return null; }
 }
+function _sessionRecordActivityMs(record) {
+  const r = record || {};
+  return Math.max(Date.parse(r.lastHandoffAt || '') || 0, Date.parse(r.closedAt || '') || 0,
+    Date.parse(r.openedAt || '') || 0);
+}
+// 1.36.171 (외부 Codex P2): 1.36.132 이전 POSIX 저장소에는 CaseKey.json/`CaseKey`와
+// casekey.json/`casekey`가 동시에 남을 수 있다. 읽기 명령은 파일을 바꾸지 않되, 같은 case-fold 주소를
+// 하나의 논리 레코드로 접어 자기 자신을 '다른 세션'으로 세지 않는다.
+function _collapseSessionEntries(rawEntries) {
+  const SP = require('../lib/session-presence');
+  const passthrough = [];
+  const grouped = new Map();
+  for (const entry of (rawEntries || [])) {
+    const fileKey = String(entry && entry.name || '').replace(/\.json$/, '');
+    const recordKey = entry && entry.record && entry.record.sessionKey;
+    if (!SP.isValidKey(recordKey) || fileKey.toLowerCase() !== String(recordKey).toLowerCase()) {
+      passthrough.push(entry); continue;
+    }
+    const folded = String(recordKey).toLowerCase();
+    const normalizedRecord = Object.assign({}, entry.record, { sessionKey: folded });
+    // 저장된 표식은 현재 물리 파일 집합으로 다시 계산한다. variant가 사라졌는데 경고만 남는 stale 상태를 막는다.
+    delete normalizedRecord.caseVariantConflict;
+    const candidate = { name: `${folded}.json`, record: normalizedRecord };
+    const prev = grouped.get(folded);
+    if (!prev) { grouped.set(folded, { logical: candidate, sourceName: entry.name, sources: [entry] }); continue; }
+    prev.sources.push(entry);
+    const pa = _sessionRecordActivityMs(prev.logical.record), ca = _sessionRecordActivityMs(candidate.record);
+    const candidateWins = ca > pa
+      || (ca === pa && !SP.hasConfirmedClose(candidate.record) && SP.hasConfirmedClose(prev.logical.record))
+      || (ca === pa && SP.hasConfirmedClose(candidate.record) === SP.hasConfirmedClose(prev.logical.record) && entry.name === `${folded}.json`);
+    if (candidateWins) { prev.logical = candidate; prev.sourceName = entry.name; }
+  }
+  return passthrough.concat([...grouped.values()].map((group) => {
+    const conflict = SP.caseVariantConflict(group.sources);
+    if (conflict) group.logical.record.caseVariantConflict = conflict;
+    return group.logical;
+  }));
+}
 //   ⚠ (검수 P1) 예전엔 읽기 실패를 빈 배열로 삼켰다 — 그러면 "기록이 없다" 와 "확인할 수 없다" 가
 //     같은 출력이 된다(조용한 0). 못 읽은 사실을 **함께 돌려준다**.
 function _readSessionEntries(root) {
   const dir = _sessionStoreDir(root);
-  const entries = [];
+  const rawEntries = [];
   let names = [];
   let unreadable = 0, storeError = null;
   try { names = fs.readdirSync(dir); }
   catch (e) {
-    if (e && e.code === 'ENOENT') return { entries, unreadable: 0, storeError: null };   // 아직 아무도 안 썼다 = 진짜 0
-    return { entries, unreadable: 0, storeError: String((e && e.code) || 'EREAD') };
+    if (e && e.code === 'ENOENT') return { entries: [], rawEntries: [], unreadable: 0, storeError: null };   // 아직 아무도 안 썼다 = 진짜 0
+    return { entries: [], rawEntries: [], unreadable: 0, storeError: String((e && e.code) || 'EREAD') };
   }
   for (const n of names) {
     if (!SESSION_FILE_RE.test(n)) continue;               // 염 파일·tmp·lock 잔재는 목록에서 제외
-    try { const j = JSON.parse(read(path.join(dir, n))); if (j && j.sessionKey) entries.push({ name: n, record: j }); else unreadable++; }
+    try { const j = JSON.parse(read(path.join(dir, n))); if (j && j.sessionKey) rawEntries.push({ name: n, record: j }); else unreadable++; }
     catch { unreadable++; }                               // 손상은 '없음' 이 아니라 '못 읽음' 이다
   }
-  return { entries, unreadable, storeError };
+  return { entries: _collapseSessionEntries(rawEntries), rawEntries, unreadable, storeError };
 }
 function _readSessionRecords(root) { return _readSessionEntries(root).entries.map(e => e.record); }
 //   phase: 'open' (handoff) | 'close' (session close)
@@ -13232,21 +13313,30 @@ function _sessionPresenceRecord(root, phase) {
   const SP = require('../lib/session-presence');
   try {
     root = absRoot(root);
+    // CLI bootstrap에서 떼어 둔 MCP direct-lifecycle marker는 이 기록 시도 한 번에만 복원한다.
+    // require 기반 호출도 안전하도록 여기서 한 번 더 capture한다.
+    _captureDirectMcpPresenceMarker();
+    const presenceEnv = SP.normalizePresenceEnv(process.env);
+    if (_directMcpPresenceMarkerPending) {
+      presenceEnv.LEERNESS_MCP_ADDRESS_EXPLICIT = '1';
+      _directMcpPresenceMarkerPending = false;
+    }
     const hasHarness = exists(path.join(root, '.leerness'));
-    const reason = SP.suppressionReason(process.env, hasHarness);
+    const reason = SP.suppressionReason(presenceEnv, hasHarness);
     if (reason) return { written: false, reason };
-    const key = SP.deriveSessionKey(process.env);
+    const key = SP.deriveSessionKey(presenceEnv);
     if (!SP.isValidKey(key)) return { written: false, reason: 'not-identifiable' };
     const dir = _sessionStoreDir(root);
     mkdirp(dir);
     const fp = path.join(dir, `${key}.json`);
     //   경로 가둠 — 키 정규식이 이미 막지만, 실제 해석 결과가 스토어 밖이면 쓰지 않는다(이중 방어).
     if (path.dirname(path.resolve(fp)) !== path.resolve(dir)) return { written: false, reason: 'path-escape' };
-    const det = SP.detectOutermostAgent(process.env);
+    const det = SP.detectOutermostAgent(presenceEnv);
     const nowIso = new Date().toISOString();
     let res = { written: false, reason: 'lock' };
     _withLock(fp, () => {
       let prev = null;
+      const legacyVariants = [];
       if (exists(fp)) {
         try { prev = JSON.parse(read(fp)); } catch {
           //   손상 레코드는 **지우고 새로 쓴다**. `writeUtf8` 의 손상 구조 경로는 stderr 경고를 내는데,
@@ -13255,12 +13345,45 @@ function _sessionPresenceRecord(root, phase) {
           try { fs.unlinkSync(fp); } catch { /* 지우지 못해도 아래 쓰기가 덮는다 */ }
         }
       }
+      const canonicalPrev = prev;
+      // OS 이름으로 case sensitivity를 추측하지 않는다. 디렉터리의 exact canonical entry가 없는데
+      // canonical path가 이미 resolve되면 같은 물리 파일을 가리키는 case-insensitive 저장소다.
+      // 반대로 exact entry가 있거나 canonical path가 resolve되지 않으면 variant는 별도 파일이다.
+      try {
+        const storedNames = fs.readdirSync(dir);
+        const canonicalName = `${key}.json`;
+        const distinctCaseEntries = storedNames.includes(canonicalName) || !exists(fp);
+        if (distinctCaseEntries) {
+          for (const name of storedNames) {
+            if (!SESSION_FILE_RE.test(name) || name === `${key}.json`
+              || name.replace(/\.json$/, '').toLowerCase() !== key) continue;
+            const variantPath = path.join(dir, name);
+            try {
+              const rawText = read(variantPath);
+              const record = JSON.parse(rawText);
+              if (!record || !record.sessionKey || String(record.sessionKey).toLowerCase() !== key) continue;
+              legacyVariants.push({ name, path: variantPath, rawText, record });
+            } catch { /* 손상 variant는 읽기 표면에서 unreadable로 남기며 여기서 지우지 않는다 */ }
+          }
+        }
+      } catch { /* 저장소 열거 실패는 본 canonical 기록을 막지 않는다 */ }
+      const caseConflict = SP.caseVariantConflict([
+        ...(canonicalPrev ? [{ name: `${key}.json`, record: canonicalPrev }] : []),
+        ...legacyVariants,
+      ]);
+      // 열린 variant가 둘 이상이면 서로 다른 구버전 세션이었을 수 있다. 어느 하나도 병합 근거로
+      // 사용하지 않고 물리 파일도 보존한다. 충돌이 없을 때만 최신 legacy 상태를 이월한다.
+      if (!caseConflict) {
+        for (const variant of legacyVariants) {
+          if (!prev || _sessionRecordActivityMs(variant.record) > _sessionRecordActivityMs(prev)) prev = variant.record;
+        }
+      }
       const _prevAgent = prev && prev.outermostAgent;
       //   1.36.132 (검수 P2): 라벨 순서를 안 맞추면 `A<->B` 와 `B<->A` 가 번갈아 기록되며 **매 handoff 마다** 새 경고가 났다.
       //   같은 두 에이전트는 같은 표식이어야 한다 — 정렬해서 순서를 없앤다.
       const _sharedAgents = (_prevAgent && _prevAgent !== 'unknown' && det.agent !== 'unknown' && _prevAgent !== det.agent)
         ? [_prevAgent, det.agent].sort().join('<->') : ((prev && prev.sharedKeyAgents) || null);
-      if (_sharedAgents && !(prev && prev.sharedKeyAgents === _sharedAgents) && process.env.LEERNESS_NO_LOCK_WARN !== '1') {
+      if (_sharedAgents && !(prev && prev.sharedKeyAgents === _sharedAgents) && presenceEnv.LEERNESS_NO_LOCK_WARN !== '1') {
         try { process.stderr.write(`⚠ 세션 주소 공유 감지: ${key} 를 서로 다른 에이전트(${_sharedAgents})가 쓰고 있습니다 — 두 세션이 한 기록으로 합쳐져 서로를 못 봅니다. 세션마다 다른 LEERNESS_SESSION_ID 를 쓰세요.\n`); } catch {}
       }
       const _handoffHistory = Array.isArray(prev && prev.handoffHistory) ? prev.handoffHistory.slice(-10) : [];
@@ -13268,7 +13391,7 @@ function _sessionPresenceRecord(root, phase) {
       const rec = {
         schemaVersion: 1,
         sessionKey: key,
-        keySource: SP.keySource(process.env),   // 1.36.132: 3종(LEERNESS_SESSION_ID 우선) — 손으로 적은 삼항은 새 출처를 놓친다
+        keySource: SP.keySource(presenceEnv),   // 1.36.132: 3종(LEERNESS_SESSION_ID 우선) — 손으로 적은 삼항은 새 출처를 놓친다
         outermostAgent: det.agent,
         agentEvidence: det.evidence,                 // 결론이 아니라 원증거 키 이름 — 규칙이 틀려도 원자료가 남는다
         hostId: _sessionHostId(root),
@@ -13285,6 +13408,7 @@ function _sessionPresenceRecord(root, phase) {
         //   라벨이 마지막 기록자로 덮임). 라벨이 **둘 다 unknown 이 아니면서** 바뀌었다면 그건 공유의 증거다.
         //   unknown 을 제외하는 이유: 셸마다 env 가시성이 달라 라벨이 흔들릴 때 오탐이 난다(실측).
         sharedKeyAgents: _sharedAgents,
+        caseVariantConflict: caseConflict,
       };
       // 1.36.133 (정찰 실측): `rec` 는 닫힌 리터럴이라 **우리가 모르는 키는 다음 handoff 에서 사라졌다** —
       //   주입한 `scope`/`futureField` 가 handoff 한 번에 소멸, exit 0, **stderr 0바이트**. 버전 혼재가 이 기계에 실재한다
@@ -13315,6 +13439,17 @@ function _sessionPresenceRecord(root, phase) {
       if (_carried.length) rec.carriedUnknownKeys = _carried;
       if (_dropped.length) rec.droppedUnknownKeys = _dropped.slice(0, 10);
       writeUtf8(fp, JSON.stringify(rec, null, 2) + '\n');
+      for (const variant of legacyVariants) {
+        if (caseConflict && !SP.hasConfirmedClose(variant.record)) continue; // 모호한 열린 세션은 절대 자동 삭제하지 않는다
+        try {
+          _withLock(variant.path, () => {
+            let current = null;
+            try { current = read(variant.path); } catch { return; }
+            if (current !== variant.rawText) return;           // 구버전 writer가 갱신함 — 다음 회차로 미룬다
+            try { fs.unlinkSync(variant.path); } catch { /* canonical은 이미 안전하게 기록됨 */ }
+          }, { maxWaitMs: 250 });
+        } catch { /* 잠금을 못 얻으면 variant를 보존한다 */ }
+      }
       res = { written: true, reason: null };
     });
     //   프루닝은 락 밖(자기 파일 락과 무관한 남의 파일 삭제) — 상한이 없으면 무한히 자란다.
@@ -13322,7 +13457,8 @@ function _sessionPresenceRecord(root, phase) {
       //   ⚠ (검수 P2) 프루너가 **삭제 대상의 락을 안 잡아서** 남이 방금 갱신한 레코드를 지울 수 있었다.
       //     파일별 락을 잡고, 락 안에서 **다시 읽어** 여전히 삭제 대상인지 확인한 뒤에만 지운다.
       const snap = _readSessionEntries(root);
-      const doomed = SP.selectPrunable(snap.entries, { selfKey: key, nowMs: Date.now() });
+      const physical = snap.rawEntries || snap.entries;
+      const doomed = SP.selectPrunable(physical, { selfKey: key, nowMs: Date.now() });
       for (const name of doomed) {
         if (!SESSION_FILE_RE.test(name)) continue;
         const victim = path.join(dir, name);
@@ -13333,7 +13469,7 @@ function _sessionPresenceRecord(root, phase) {
           let cur = null;
           try { cur = JSON.parse(read(victim)); } catch { cur = null; }
           const still = SP.selectPrunable([{ name, record: cur }].concat(
-            snap.entries.filter(e => e.name !== name)), { selfKey: key, nowMs: Date.now() });
+            physical.filter(e => e.name !== name)), { selfKey: key, nowMs: Date.now() });
           if (!still.includes(name)) return;                              // 조건이 사라졌다 → 보존
           try { fs.unlinkSync(victim); } catch { /* 남아도 다음에 다시 시도 */ }
         });
@@ -13374,9 +13510,11 @@ function _sessionSignal(root, opts = {}) {
   let mine = null;
   try { mine = selfKey ? (snap.entries.find(e => e.record && e.record.sessionKey === selfKey) || null) : null; } catch {}
   const sharedKeyAgents = (mine && mine.record && mine.record.sharedKeyAgents) || null;
+  const caseVariantConflict = (mine && mine.record && mine.record.caseVariantConflict) || null;
   return {
     others,                                                   // 다른 세션 **기록** 수(활성 여부는 판정하지 않는다)
     sharedKeyAgents,
+    caseVariantConflict,
     //   1.36.132 (검수 P1): 명시 주소가 형식에 안 맞으면 종전엔 조용히 다음 출처로 넘어갔다(오타를 안 알림).
     invalidExplicitKey: SP.invalidExplicitKey(process.env),
     //   1.36.132 (검수 P1): 저장소를 못 읽은 것을 `others:0` 으로 축약하지 않는다 — 이 저장소의 규율이다.
@@ -13390,7 +13528,7 @@ function _sessionSignal(root, opts = {}) {
     //   1.36.133: **서브에이전트가 빠져 있었다.** 이 프로젝트의 session-workflow 는 파일 경로를 나눠 주는
     //   병렬 sub-agent 를 의무화하는데, 그들은 `child-agent` 로 억제돼 레지스트리에 아예 안 나타난다 —
     //   즉 겹침이 가장 잘 나는 주체가 구조적으로 안 보인다. 못 보는 것을 안 적으면 "0건" 이 거짓말이 된다.
-    blindSpots: ['handoff 를 부르지 않는 세션', 'MCP 전용 클라이언트(LEERNESS_INTERNAL)',
+    blindSpots: ['handoff 를 부르지 않는 세션', 'sessionKey 없이 lifecycle handoff/close 를 호출하는 MCP 클라이언트',
       '병렬 sub-agent (CLAUDE_CODE_CHILD_SESSION — 억제되어 등록되지 않음)',
       '주소가 없는 에이전트(cursor/vscode/grok 등 · codex 는 CODEX_THREAD_ID 가 없는 실행에서만, TUI 미검증)',
       '다른 머신', '구버전 설치본'],
@@ -13406,6 +13544,7 @@ function _sessionSignalFlags(ss) {
     out.push(`🙈 나는 안 보임(${ss.selfSuppressedReason})`);
   }
   if (ss.sharedKeyAgents) out.push(`⚠ 주소 공유(${ss.sharedKeyAgents})`);
+  if (ss.caseVariantConflict) out.push(`⚠ 대소문자 세션 충돌(${ss.caseVariantConflict.count || '?'})`);
   if (ss.storeError) out.push(`⚠ 세션저장소 읽기실패(${ss.storeError})`);
   if (ss.invalidExplicitKey) out.push(`⚠ LEERNESS_SESSION_ID 형식 오류("${ss.invalidExplicitKey}") — 무시됨`);
   return out;
@@ -13480,14 +13619,15 @@ function sessionsCmd(root) {
     outermostAgent: r.outermostAgent || 'unknown',
     //   ⚠ (검수 P2) `hostId` 가 없으면 '다른 머신' 이 아니라 **모르는 것**이다 — 3상태로 답한다.
     hostRelation: SP.hostRelation(r.hostId, selfHost),
-    closeRecorded: !!r.closedAt,
+    closeRecorded: SP.hasConfirmedClose(r),
     lastHandoffAt: r.lastHandoffAt || null,
     handoffCount: Number(r.handoffCount || 0) || 0,
     leernessVersion: r.leernessVersion || null,
+    caseVariantConflict: r.caseVariantConflict || null,
   }));
   const blindSpots = [
     t('leerness handoff 를 돌리지 않은 에이전트 세션', 'agent sessions that never ran `leerness handoff`'),
-    t('MCP 도구만 쓰는 클라이언트', 'clients that only use MCP tools'),
+    t('sessionKey 없이 lifecycle handoff/close를 호출하는 MCP 클라이언트', 'MCP clients calling lifecycle handoff/close without a sessionKey'),
     t(`${VERSION} 이전 버전으로 시작된 세션`, `sessions started on a version older than ${VERSION}`),
     //   1.36.132: 종전엔 '세션키가 없는 에이전트(codex/cursor 등)' 이라고 적었는데 codex 는 이제 주소가 있다.
     //   자기 도구의 능력을 과소·과대 주장하지 않는다 — 실측 범위를 그대로 적는다(codex exec 경로에서 확인).
@@ -13546,7 +13686,10 @@ function sessionsCmd(root) {
         : (r.hostRelation === 'different'
           ? t('다른 머신 — 확인 불가', 'another machine — unverifiable')
           : t('머신 판별 불가 — 확인 불가', 'machine unknown — unverifiable'));
-      log(`  ${who}  ${String(r.sessionKey).slice(0, 8)}…  ${String(r.outermostAgent).padEnd(13)} ${when}`);
+      const collision = r.caseVariantConflict
+        ? t(` · ⚠ 대소문자 충돌 ${r.caseVariantConflict.count || '?'}건`, ` · ⚠ ${r.caseVariantConflict.count || '?'} case variants conflict`)
+        : '';
+      log(`  ${who}  ${String(r.sessionKey).slice(0, 8)}…  ${String(r.outermostAgent).padEnd(13)} ${when}${collision}`);
     }
   }
   log('');
@@ -16245,6 +16388,8 @@ function memorySearch(root, query) {
 
 function handoff(root) {
   root = absRoot(root);
+  // hook/--no-record 경로도 marker를 child env로 넘기지 않도록 기록 gate보다 먼저 소비한다.
+  _captureDirectMcpPresenceMarker();
   const _versionSkew = _handoffVersionSkew(root);
   // 1.9.199: handoff 진입 시 1) 이전 timestamp 보존 → 2) 현재 timestamp 기록
   //   detector 가 prior gap 을 정확히 측정 (overwrite 전 값 필요). 함수 최상단에 선언.
@@ -21268,6 +21413,7 @@ const _sessionClose = require('../lib/session-close');
 // 1.9.425 (UR-0025/UR-0125 큰 핸들러 모듈화 10번째): sessionClose → lib/session-close.js (DI 위임)
 function sessionClose(root, opts = {}) { // 1.36.132 (검수): handoff 는 --no-record/LEERNESS_HOOK 게이트 뒤에서 기록하는데 여기는 **게이트 없이** 기록했다
   //   (실측: handoff --no-record → 0건, session close --no-record → 1건). 같은 스토어의 같은 계약은 같은 문장으로.
+  _captureDirectMcpPresenceMarker(); // hook/--no-record여도 nested skill/drift child에는 일회성 MCP marker를 물려주지 않는다
   if (!has('--no-record') && process.env.LEERNESS_HOOK !== '1') { try { _sessionPresenceRecord(root, 'close'); } catch {} }     // 1.36.129 (P-0016 P1): close 는 '기록됨' 일 뿐 '프로세스가 죽었다' 가 아니다
   return _sessionClose.sessionClose(root, opts, { VERSION, STATUSES, MARK, has, arg, uiLang: _uiLang(root), harnessPath: __filename, readProgressRows, evidencePath, handoffPath, currentStatePath, taskLogPath, verifyRules, _autoRoadmap, _readUsageStats, readSessionCounter, writeSessionCounter, _retroAggregate, _retroOneLine, retroCmd, _loadDecisions, readRules, planPath, _loadLessons, _readFeatureGraph, _auditUserRequests, _detectDeliveredRequests, _computeRoundHistory, _computeMilestones, _computeRecentChanges, _collectPyFiles, _analyzePyFile, _collectRuntimeEnv, _scanShellScriptsEncoding, _listAPISkills, _matchAPISkills, _loadShellFailures, _shellEnvDrift, _runPreWakeAudit, _saveAndAppendPreWakeReport, _runIdempotencyAudit, _detectAbnormalShutdown, _updateUserRequest, _detectOptimism, _scanCodeForPatterns, _collectSecretFindings, _withLock }); }  // 1.17.6 (UR-0049): 마감 정합 — done 낙관 재확인 + 시크릿 재확인 · 1.36.108: 락 주입(T-0097)
 
@@ -25661,10 +25807,20 @@ function mcpServeCmd(root) {
   //   자식 프로세스로 돌리므로 **env 로 주소를 넘길 수 있다** — 호출마다 다른 주소를 준다.
   function callLeerness(cliArgs, extraEnv) {
     const budget = _mcpTimeoutFor(cliArgs);
+    const childEnv = { ...process.env, LEERNESS_INTERNAL: '1', LEERNESS_NO_BANNER: '1', LEERNESS_NO_STALE_CHECK: '1', LEERNESS_NO_DRIFT_CHECK: '1', LEERNESS_NO_PROMPT: '1', LEERNESS_NO_WORKFLOW_GUIDE: '1' };
+    // MCP 서버 프로세스가 바깥 호출의 일회성 presence marker를 물려받았더라도 다음 호출로
+    // 재사용하지 않는다. 검증된 direct lifecycle 호출만 아래 extraEnv에서 다시 부여한다.
+    _deleteEnvKeyCaseInsensitive(childEnv, 'LEERNESS_MCP_ADDRESS_EXPLICIT');
+    // Windows child_process는 env 이름을 대소문자 비구분으로 하나만 전달한다. 호출별 주소를
+    // 덮을 때 상속된 다른 casing이 남아 있으면 어느 값이 선택될지 정렬 순서에 의존한다.
+    if (extraEnv && Object.prototype.hasOwnProperty.call(extraEnv, 'LEERNESS_SESSION_ID')) {
+      _deleteEnvKeyCaseInsensitive(childEnv, 'LEERNESS_SESSION_ID');
+    }
+    Object.assign(childEnv, extraEnv || {});
     const r = cp.spawnSync(process.execPath, [__filename, ...cliArgs], {
       encoding: 'utf8',
       timeout: budget,
-      env: { ...process.env, LEERNESS_INTERNAL: '1', LEERNESS_NO_BANNER: '1', LEERNESS_NO_STALE_CHECK: '1', LEERNESS_NO_DRIFT_CHECK: '1', LEERNESS_NO_PROMPT: '1', LEERNESS_NO_WORKFLOW_GUIDE: '1', ...(extraEnv || {}) }
+      env: childEnv
     });
     const cmd = `leerness ${cliArgs.map(_shQuote).join(' ')}`;
     const partial = ((r.stdout || '') + (r.stderr || '')).trim();
@@ -25720,14 +25876,14 @@ function mcpServeCmd(root) {
         return send({ jsonrpc: '2.0', id, error: { code: -32602, message: 'Invalid params: arguments must be an object' } });
       }
       const args = _rawArgs || {};
+      const _toolDef = TOOLS.find(t => t.name === name) || null;
       // 1.36.58 (F-09): core 프로필에서는 노출 집합 = 호출 가능 집합 (광고 안 한 도구 호출은 unknown 과 동일 처리)
-      if (_profile === 'core' && !TOOLS.some(t => t.name === name)) {
+      if (_profile === 'core' && !_toolDef) {
         return send({ jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown tool: ${name} (core profile — full: leerness mcp serve --profile full)` } });
       }
       // 1.36.39 (#3): 도구 inputSchema 기반 타입 검증 — {"title":{...}} 같은 비문자열이 "[object Object]" 로 영속되던 것 차단.
       {
-        const _td = TOOLS.find(t => t.name === name);
-        const _props = _td && _td.inputSchema && _td.inputSchema.properties || null;
+        const _props = _toolDef && _toolDef.inputSchema && _toolDef.inputSchema.properties || null;
         if (_props) {
           for (const [k, spec] of Object.entries(_props)) {
             const v = args[k];
@@ -25736,11 +25892,28 @@ function mcpServeCmd(root) {
             if (spec.type === 'number' && typeof v !== 'number') return send({ jsonrpc: '2.0', id, error: { code: -32602, message: `Invalid params: '${k}' must be a number` } });
             if (spec.type === 'boolean' && typeof v !== 'boolean') return send({ jsonrpc: '2.0', id, error: { code: -32602, message: `Invalid params: '${k}' must be a boolean` } });
           }
-          for (const rk of (_td.inputSchema.required || [])) {
+          for (const rk of (_toolDef.inputSchema.required || [])) {
             if (args[rk] === undefined || args[rk] === null) return send({ jsonrpc: '2.0', id, error: { code: -32602, message: `Invalid params: missing required '${rk}'` } });
           }
         }
       }
+      // 1.36.171 (외부 Codex P1/P2): sessionKey는 광고한 도구에서만 받으며, 명시된 값은
+      // MCP 경계에서 완전히 검증한다. 잘못된 값을 CLI가 무시해 서버의 CODEX_THREAD_ID나 전역
+      // currentRunId로 떨어뜨리면 서로 다른 에이전트의 증거가 다시 섞인다.
+      let _sk = null;
+      const _hasSessionKey = Object.prototype.hasOwnProperty.call(args, 'sessionKey');
+      if (_hasSessionKey && _toolDef) {
+        const _props = _toolDef.inputSchema && _toolDef.inputSchema.properties || {};
+        if (!Object.prototype.hasOwnProperty.call(_props, 'sessionKey')) {
+          return send({ jsonrpc: '2.0', id, error: { code: -32602, message: `Invalid params: '${name}' does not accept 'sessionKey'` } });
+        }
+        const _candidate = typeof args.sessionKey === 'string' ? args.sessionKey : '';
+        const _SPmcp = require('../lib/session-presence');
+        if (!_SPmcp.isValidKey(_candidate)) {
+          return send({ jsonrpc: '2.0', id, error: { code: -32602, message: "Invalid params: 'sessionKey' must be 8-64 letters, numbers, '_' or '-' and not a reserved key" } });
+        }
+        _sk = _candidate.toLowerCase();
+      }
       // 1.12.2 (14th 버그헌트, UR-0181): MCP 서버는 generic 설계 — cwd 에서 실행 후 각 호출의 path 로 대상 프로젝트 지정(의도된 기능, e2e 가 검증). 즉 path-타게팅 자체는 취약점 아님(신뢰된 로컬 MCP). policy 도 대상-프로젝트별로 path 에서 로드(올바름).
       //   진짜 버그는 unknown tool 도 _bumpMcpUsage 가 임의 경로에 무조건 쓰던 것 → 사용 통계를 unknown-tool 검증 "후"로 이동. (프로젝트-scoped 가둠은 opt-in 플래그로 별도 검토 — UR backlog)
       //   1.36.146 (재검수 P1, 재현): 빈 `path` 가 falsy 라 **서버 root** 로 떨어져
@@ -25761,15 +25934,19 @@ function mcpServeCmd(root) {
         //   cliArgs(실제 실행 명령) 로 required tier 판정 → enforce ON 이고 초과 시 JSON-RPC error 반환(실행 안 함).
         try {
           // 1.9.301 (UR-0041): 도구 선언 requiredTier(메타데이터) + cliArgs regex 중 더 엄격한 tier 로 판정 (under-classify 갭 차단).
-          const _toolDef = TOOLS.find(t => t.name === name);
           const pol = _policyEnforce(targetPath, cliArgs.join(' '), _toolDef && _toolDef.requiredTier);
           if (!pol.allowed) {
             return send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `정책 차단(policy): ${pol.reason}` }], isError: true } });
           }
         } catch {}
-        //   세션 주소를 그대로 전달한다(문자열일 때만). 형식이 안 맞으면 CLI 가 무시하고 그 사실을 말한다.
-        const _sk = (args && typeof args.sessionKey === 'string' && args.sessionKey.trim()) ? args.sessionKey.trim() : null;
-        const r = callLeerness(cliArgs, _sk ? { LEERNESS_SESSION_ID: _sk } : null);
+        // T-0110: lifecycle MCP 호출은 명시 sessionKey가 있어도 callLeerness의
+        // LEERNESS_INTERNAL=1 때문에 presence에서 억제됐다. 이 marker는 서버가 호출별 주소를
+        // 실제로 받은 **직접 handoff/close**에만 붙인다. state/agent-mode/일반 내부 스폰은
+        // presence 억제 예외가 아니며, sessionKey 자체는 상태 귀속용 env로만 전달한다.
+        const _lifecycle = name === 'leerness_handoff' || name === 'leerness_session_close';
+        const _mcpEnv = _sk ? { LEERNESS_SESSION_ID: _sk } : null;
+        if (_mcpEnv && _lifecycle) _mcpEnv.LEERNESS_MCP_ADDRESS_EXPLICIT = '1';
+        const r = callLeerness(cliArgs, _mcpEnv);
         // 1.9.61: cursor 기반 페이지네이션 — 긴 출력은 cursor offset로 다음 청크
         const fullText = r.stdout || r.stderr || '(no output)';
         // 1.12.4 (15th 버그헌트 P2, UR-0016): _chunkSize 를 양의 정수로 클램프 — 음수/소수면 slice 빈 출력 + nextCursor 음수 → 무한 빈-루프(데이터 손실)였음.

package/lib/mcp-tools.js

@@ -4,7 +4,7 @@
 'use strict';
 
 module.exports = [
-  { name: 'leerness_handoff', requiredTier: 'safe-write', description: '워크스페이스 컨텍스트(plan/progress/decisions) 적재', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } },
+  { name: 'leerness_handoff', requiredTier: 'safe-write', description: '워크스페이스 컨텍스트(plan/progress/decisions) 적재. sessionKey를 주면 해당 MCP 세션의 presence도 등록한다.', inputSchema: { type: 'object', properties: { sessionKey: { type: 'string', description: '이 MCP 세션의 고유 주소(8~64자 영문/숫자/_/-). 동시 에이전트가 서로를 보려면 세션마다 다른 값을 사용한다.' }, path: { type: 'string' } } } },
   { name: 'leerness_drift_check', requiredTier: 'read-only', description: '1.9.136 — AI 에이전트 leerness 미사용 drift 자동 감지 JSON ({ root, score, level, signals[], healthy }). 5+ 신호 + 4단계 레벨 (🟢 healthy / 🟡 warning / 🟠 caution / 🔴 critical). 보안 신호 통합 (1.9.78)', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } },
   { name: 'leerness_audit', requiredTier: 'safe-write', description: '1.9.102 — 워크스페이스 일관성 감사 JSON (warnings/failures/fixed/healthy + findings[]. kind 11종: design_dup/design_system_default/reuse_map_empty/milestone_unlinked/handoff_not_generated/current_state_stale/readme_version_mismatch/npm_cve/gitignore_missing_secrets/env_keys_missing/strict_promoted)', inputSchema: { type: 'object', properties: { path: { type: 'string' }, fix: { type: 'boolean' }, strict: { type: 'boolean' } } } },
   { name: 'leerness_verify_claim', requiredTier: 'read-only', description: 'AI 거짓 완료 자동 검증 (evidence 파일 + 실 테스트 실행). 1.9.309(UR-0048): done/완료 주장은 evidence(수정파일+테스트) 기본 강제 — 증거 없는 done 은 FAIL(exit 1). lenient=true 로 완화, runTests/strictClaims 추가 가능. 응답 verdict.evidenceComplete 포함.', inputSchema: { type: 'object', properties: { taskId: { type: 'string' }, path: { type: 'string' }, runTests: { type: 'boolean' }, strictClaims: { type: 'boolean' }, lenient: { type: 'boolean' }, refereeId: { type: 'string' } }, required: ['taskId'] } },
@@ -14,7 +14,7 @@ module.exports = [
   { name: 'leerness_reuse_map', requiredTier: 'read-only', description: '워크스페이스 중복 함수/capability 자동 감지 (--all-apps + fuzzy 매칭)', inputSchema: { type: 'object', properties: { path: { type: 'string' }, allApps: { type: 'boolean' }, strictElements: { type: 'boolean' } } } },
   { name: 'leerness_whats_new', requiredTier: 'read-only', description: 'CHANGELOG 차분 자동 추출 (from → to 사이 신규 명령/플래그/파일). 1.36.69: 기본 최신 30개 버전만 반환(응답 폭주 방지) — 응답의 totalVersions/shown/truncated 로 절단 여부 확인, 더 필요하면 limit(개수) 또는 all=true(전체, 대용량 주의) 지정.', inputSchema: { type: 'object', properties: { from: { type: 'string' }, to: { type: 'string' }, limit: { type: 'number' }, all: { type: 'boolean' } } } },
   { name: 'leerness_usage_stats', requiredTier: 'read-only', description: 'leerness 명령별 누적 호출 통계 + drift 통계', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } },
-  { name: 'leerness_session_close', requiredTier: 'safe-write', description: '1.9.103 — 세션 마감 JSON (handoff/current-state/task-log 갱신 + taskCounts + rules + skillCandidates + drift + topCommands + mcpStats). 외부 AI가 마감 통계 자동 회수', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } },
+  { name: 'leerness_session_close', requiredTier: 'safe-write', description: '1.9.103 — 세션 마감 JSON (handoff/current-state/task-log 갱신 + taskCounts + rules + skillCandidates + drift + topCommands + mcpStats). sessionKey를 주면 그 MCP presence만 닫는다.', inputSchema: { type: 'object', properties: { sessionKey: { type: 'string', description: '마감할 MCP 세션의 고유 주소(8~64자 영문/숫자/_/-).' }, path: { type: 'string' } } } },
   { name: 'leerness_skill_suggest', requiredTier: 'read-only', description: '1.9.53 — 사용 패턴 자동 분석 → 새 skill 후보 제안 (Hermes-style 자동 학습)', inputSchema: { type: 'object', properties: { path: { type: 'string' }, min: { type: 'number' }, days: { type: 'number' } } } },
   { name: 'leerness_lessons', requiredTier: 'read-only', description: '1.9.7/54 — 과거 결정·실수 자동 회수 (--auto: 현재 task 키워드 자동 추출)', inputSchema: { type: 'object', properties: { path: { type: 'string' }, query: { type: 'string' }, auto: { type: 'boolean' }, limit: { type: 'number' } } } },
   { name: 'leerness_task_export', requiredTier: 'project-write', description: '1.9.60/66 — leerness task → Claude Code TodoWrite 호환 JSON (외부 AI 양방향 sync)', inputSchema: { type: 'object', properties: { path: { type: 'string' }, to: { type: 'string' } } } },

package/lib/session-presence.js

@@ -12,10 +12,11 @@
 //
 //   이 모듈은 순수 함수만 담는다(스폰·IO 없음) — 가드가 자기 소스를 읽지 않고 행위로 검증할 수 있게.
 
-const SESSIONS_KEEP = 20;                              // 임의의 수 — 아래 주석 참조
+const SESSIONS_KEEP = 20;                              // 보존할 최근 closed tombstone 수 — 아래 주석 참조
 const SESSIONS_CLOSED_TTL_MS = 7 * 24 * 3600 * 1000;   // 임의의 수 — 아래 주석 참조
-//   ⚠ 두 값은 **임의**다. 측정으로 유도한 것은 "상한이 있어야 한다" 는 사실뿐이고, 그 근거는 실측이다 —
-//     이 저장소의 `.leerness/runs/` 는 프루닝이 없어 909개 파일까지 자랐다. 값 자체는 근거가 없으므로 그렇게 적는다.
+//   ⚠ 두 값은 **임의**다. 측정으로 유도한 것은 closed tombstone에 상한이 있어야 한다는 사실뿐이고,
+//     그 근거는 실측이다 — `.leerness/runs/` 는 프루닝이 없어 909개 파일까지 자랐다. 열린 peer 기록은
+//     충돌 회피의 유일한 흔적일 수 있어 이 상한으로 삭제하지 않는다. 값 자체는 근거가 없으므로 그렇게 적는다.
 
 const KEY_RE = /^[A-Za-z0-9_-]{8,64}$/;
 const FILE_RE = /^[A-Za-z0-9_-]{8,64}\.json$/;
@@ -25,11 +26,65 @@ const RESERVED_KEYS = new Set(['unaddressed']);
 // 자체 점검이 쓰는 격리 marker는 실제 세션 주소가 될 수 없어야 한다. 그렇지 않으면 enforce install이
 // 같은 주소의 실제 handoff를 저장/복원 사이에 되돌려 버릴 수 있다.
 const RESERVED_PREFIXES = ['leerness-internal-'];
+// Windows의 process.env는 키 대소문자를 구분하지 않지만, `{ ...process.env }`로 복사한
+// 평범한 객체는 구분한다. presence 판정 직전에 아래 키만 OS 의미에 맞춰 canonical casing으로
+// 올린다. POSIX에서는 원래의 case-sensitive 계약을 유지하고, 순수 회귀 테스트는 옵션으로
+// Windows 의미를 강제할 수 있다.
+const PRESENCE_ENV_KEYS = [
+  'LEERNESS_SESSION_ID', 'CLAUDE_CODE_HOST_SESSION_ID', 'CLAUDE_CODE_SESSION_ID', 'CODEX_THREAD_ID',
+  'CLAUDE_CODE_CHILD_SESSION', 'LEERNESS_MCP_ADDRESS_EXPLICIT', 'LEERNESS_INTERNAL', 'LEERNESS_HOOK',
+  'LEERNESS_NO_SESSION_PRESENCE', 'CI', 'GITHUB_ACTIONS', 'CLAUDECODE', 'CURSOR_AGENT',
+  'CODEX_MANAGED_BY_NPM', 'CODEX_MANAGED_BY_PNPM', 'CODEX_MANAGED_BY_BUN',
+  'CODEX_INTERNAL_ORIGINATOR_OVERRIDE',
+];
+function normalizePresenceEnv(env, options) {
+  const source = env || {};
+  const out = { ...source };
+  const caseInsensitive = options && Object.prototype.hasOwnProperty.call(options, 'caseInsensitive')
+    ? options.caseInsensitive === true
+    : process.platform === 'win32';
+  if (!caseInsensitive) return out;
+  const keys = Object.keys(source);
+  for (const canonical of PRESENCE_ENV_KEYS) {
+    const variants = keys.filter(key => key.toLowerCase() === canonical.toLowerCase());
+    if (!variants.length) continue;
+    const selected = Object.prototype.hasOwnProperty.call(source, canonical) ? canonical : variants[0];
+    for (const key of variants) delete out[key];
+    out[canonical] = source[selected];
+  }
+  return out;
+}
 function isValidKey(s) {
   if (typeof s !== 'string' || !KEY_RE.test(s)) return false;
   const folded = s.toLowerCase();
   return !RESERVED_KEYS.has(folded) && !RESERVED_PREFIXES.some(prefix => folded.startsWith(prefix));
 }
+// `closedAt` 은 truthy 여부나 Date.parse()의 관대한 정규화가 아니라, 이 제품이 실제로 쓰는
+// `Date#toISOString()` 형식과 달력 값이 정확히 일치해야 종료 증거다. 예를 들어 Date.parse는
+// `0`과 `2024-02-30T00:00:00.000Z`도 시각으로 받아들이므로 그것만 믿으면 손상 레코드를 지운다.
+// 손상/미래 스키마 값은 "열림"으로 단정하지도 않지만, 적어도 삭제 가능한 tombstone으로 취급하지 않는다.
+const CANONICAL_ISO_UTC_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+function confirmedCloseMs(record) {
+  const value = record && record.closedAt;
+  if (typeof value !== 'string' || !CANONICAL_ISO_UTC_RE.test(value)) return null;
+  const ms = Date.parse(value);
+  if (!Number.isFinite(ms)) return null;
+  try { return new Date(ms).toISOString() === value ? ms : null; } catch { return null; }
+}
+function hasConfirmedClose(record) { return confirmedCloseMs(record) !== null; }
+
+// 구버전의 case-sensitive 저장소에서는 대소문자만 다른 주소가 서로 다른 열린 세션이었을 수 있다.
+// 둘 이상이면 어느 하나를 canonical 주소로 합칠 근거가 없으므로 보존하고, 읽기/쓰기 표면에 충돌을 표시한다.
+function caseVariantConflict(entries) {
+  const open = (entries || []).filter(e => e && e.record && !hasConfirmedClose(e.record));
+  if (open.length < 2) return null;
+  const variants = open.map(e => String(e.name || '')).filter(name => FILE_RE.test(name)).slice(0, 10);
+  return {
+    reason: 'ambiguous-open-case-variants',
+    count: open.length,
+    variants,
+  };
+}
 // env 값의 참/거짓 — CI 계열은 `"false"`/`"0"` 을 **명시적으로** 넘기는 환경이 흔하다.
 function isTruthyEnv(v) {
   const t = String(v == null ? '' : v).trim().toLowerCase();
@@ -59,7 +114,7 @@ const FORBIDDEN_SIGNALS = ['CODEX_COMPANION_SESSION_ID', 'CODEX_COMPANION_TRANSC
 //   물려받으므로(실측) 부모 세션으로 접히는 지금 동작을 유지한다. 독립 실행 codex 만 자기 주소를 얻는다.
 const KEY_SOURCES = ['LEERNESS_SESSION_ID', 'CLAUDE_CODE_HOST_SESSION_ID', 'CLAUDE_CODE_SESSION_ID', 'CODEX_THREAD_ID'];
 function keySource(env) {
-  const e = env || {};
+  const e = normalizePresenceEnv(env);
   // 1.36.148 (재검수 P1, 재현): child 억제가 **명시 주소보다 앞**에 있어,
   //   MCP 서버가 `CLAUDE_CODE_CHILD_SESSION=1` 을 상속하면 호출별 `sessionKey` 가 통째로 버려졌다
   //   — 1.36.145 에서 넣은 주소 전달이 조용히 무력화되고 전역 슬롯 오귀속이 돌아온다.
@@ -75,13 +130,14 @@ function keySource(env) {
 //   `CaseKey01ABCD` 와 `casekey01abcd` 가 **다른 주소인 척하다가 같은 파일 하나로 조용히 병합**됐다(실측 2→1).
 //   주소를 소문자로 접어 **하나의 규칙**으로 만든다: 같은 글자면 같은 주소다(그리고 파일명과 항상 일치한다).
 function deriveSessionKey(env) {
-  const src = keySource(env);
-  return src ? String((env || {})[src]).toLowerCase() : null;
+  const e = normalizePresenceEnv(env);
+  const src = keySource(e);
+  return src ? String(e[src]).toLowerCase() : null;
 }
 // 1.36.132 (검수 P1): 사용자가 **명시한** 주소가 형식에 안 맞으면 조용히 다음 출처로 넘어갔다 —
 //   오타를 알리지 않고 설정을 뒤집는 것이다. 무엇이 왜 무시됐는지 말할 수 있게 사유를 돌려준다.
 function invalidExplicitKey(env) {
-  const v = (env || {}).LEERNESS_SESSION_ID;
+  const v = normalizePresenceEnv(env).LEERNESS_SESSION_ID;
   if (v === undefined || v === null || v === '') return null;
   return isValidKey(v) ? null : String(v).slice(0, 40);
 }
@@ -90,7 +146,7 @@ function invalidExplicitKey(env) {
 //   보고했다 — codex 가 부모 env 를 통째로 물려주고, 그 codex 자신이 Claude 세션에서 시작됐기 때문이다.
 //   env 가 가리키는 것은 **체인의 최외곽**이다. 이름을 그렇게 붙이면 그 라벨은 참이 된다.
 function detectOutermostAgent(env) {
-  const e = env || {};
+  const e = normalizePresenceEnv(env);
   if (e.CLAUDECODE === '1') return { agent: 'claude-code', evidence: ['CLAUDECODE'] };
   if (!e.CLAUDECODE) {
     for (const k of ['CODEX_MANAGED_BY_NPM', 'CODEX_MANAGED_BY_PNPM', 'CODEX_MANAGED_BY_BUN']) {
@@ -109,13 +165,19 @@ function detectOutermostAgent(env) {
 
 // 억제 판정은 **한 곳**에서 한다. 호출부마다 조건을 복붙하면 새 호출부가 빠진다(1.36.108 이 고친 형태).
 function suppressionReason(env, hasHarness) {
-  const e = env || {};
-  if (e.LEERNESS_INTERNAL === '1') return 'internal';        // leerness 가 자기를 스폰하는 20여 지점
+  const e = normalizePresenceEnv(env);
+  // T-0110: MCP 서버도 자식 CLI를 `LEERNESS_INTERNAL=1` 로 실행한다. 그 값만 보면 호출자가
+  // 명시한 sessionKey까지 일반 내부 호출로 오인해 lifecycle handoff/close가 영원히 등록되지 않는다.
+  // 서버가 **호출별 유효 주소를 검증해 붙인 marker**만 예외로 삼는다. 단순히 부모 env에서 물려받은
+  // LEERNESS_SESSION_ID나 일반 내부 스폰은 이 marker가 없으므로 종전처럼 억제된다.
+  const addressedMcp = e.LEERNESS_MCP_ADDRESS_EXPLICIT === '1' && isValidKey(e.LEERNESS_SESSION_ID);
+  if (e.LEERNESS_INTERNAL === '1' && !addressedMcp) return 'internal';
   if (e.LEERNESS_HOOK === '1') return 'hook';
   // child는 부모의 LEERNESS_SESSION_ID도 그대로 상속할 수 있다. env 값만 보고 호출자가 새 주소를
   // 지정했다고 단정하면 자식 활동이 부모 presence에 합쳐진다. 상태 MCP의 호출별 sessionKey는
-  // deriveSessionKey 경로에서 별도로 귀속되므로, presence 자체는 child를 계속 억제한다.
-  if (e.CLAUDE_CODE_CHILD_SESSION === '1') return 'child-agent';
+  // deriveSessionKey 경로에서 별도로 귀속된다. presence 예외는 MCP 서버가 호출별 주소를 검증한
+  // lifecycle handoff/close에만 marker로 열고, 그 외 child는 계속 억제한다.
+  if (e.CLAUDE_CODE_CHILD_SESSION === '1' && !addressedMcp) return 'child-agent';
   //   ⚠ (검수 P2, 실측 재현) `e.CI` 만 보면 `CI="false"`·`CI="0"` 도 억제했다 —
   //     명시적으로 '아니다' 라고 말한 정상 로컬 환경이 조용히 등록되지 않는다. **참인 값만** 본다.
   if (isTruthyEnv(e.CI) || isTruthyEnv(e.GITHUB_ACTIONS)) return 'ci';
@@ -137,34 +199,44 @@ function selectPrunable(records, opts) {
   const selfKey = o.selfKey || null;
   const list = (records || []).filter(e => e && typeof e.name === 'string' && FILE_RE.test(e.name));
   const keyOf = (e) => String(e.name).replace(/\.json$/, '');
-  const trusted = list.filter(e => e.record && e.record.sessionKey === keyOf(e));
+  const foldedKeyOf = (e) => keyOf(e).toLowerCase();
+  const foldedSelf = typeof selfKey === 'string' ? selfKey.toLowerCase() : null;
+  // 1.36.171: 1.36.132 이전 POSIX 레코드는 파일명과 payload가 혼합 대소문자일 수 있다.
+  // 정규화 뒤 같은 주소라면 신뢰하되, 실제 삭제 대상은 언제나 원래 파일명으로 돌려준다.
+  const trusted = list.filter(e => e.record && isValidKey(e.record.sessionKey)
+    && String(e.record.sessionKey).toLowerCase() === foldedKeyOf(e));
   const doomed = new Set();
-  //   이름과 키가 어긋난 것은 **그 파일만** 정리 후보로 본다(그 레코드의 말을 믿고 남을 지우지 않는다).
-  for (const e of list) { if (!trusted.includes(e) && keyOf(e) !== selfKey) doomed.add(e.name); }
+  // 이름과 키가 어긋나도 열린 기록은 다른 에이전트의 마지막 흔적일 수 있다. close/tombstone이
+  // 확인된 파일만 정리한다. 저장소 상한 때문에 **열린 동료 기록을 삭제하지 않는다**.
+  for (const e of list) {
+    if (!trusted.includes(e) && foldedKeyOf(e) !== foldedSelf && hasConfirmedClose(e.record)) doomed.add(e.name);
+  }
   for (const e of trusted) {
-    if (keyOf(e) === selfKey) continue;
-    const c = Date.parse((e.record && e.record.closedAt) || '');
-    if (Number.isFinite(c) && nowMs && (nowMs - c) > ttl) doomed.add(e.name);
+    if (foldedKeyOf(e) === foldedSelf) continue;
+    const c = confirmedCloseMs(e.record);
+    if (c !== null && nowMs && (nowMs - c) > ttl) doomed.add(e.name);
   }
-  const alive = trusted.filter(e => !doomed.has(e.name));
-  //   ⚠ (검수 P2, 실측 재현) `openedAt` 만으로 줄 세우면 **오래 열려 있었지만 방금 handoff 한 세션**이
-  //     상한 밖으로 밀려 삭제됐다. 지키려는 것은 '최근에 살아 있던 기록' 이므로 최근 활동을 함께 본다.
+  // 상한은 닫힌 tombstone에만 적용한다. 열린 기록은 라이브니스가 아니라도 충돌 회피를 위한 유일한
+  // 증거라서, 임의의 20개 제한으로 버리면 안 된다.
+  const closed = trusted.filter(e => !doomed.has(e.name) && hasConfirmedClose(e.record));
   const activity = (e) => Math.max(Date.parse((e.record && e.record.lastHandoffAt) || '') || 0,
+    Date.parse((e.record && e.record.closedAt) || '') || 0,
     Date.parse((e.record && e.record.openedAt) || '') || 0);
-  const ranked = alive.slice().sort((a, b) => activity(b) - activity(a));
-  for (const e of ranked.slice(keep)) { if (keyOf(e) !== selfKey) doomed.add(e.name); }
+  const ranked = closed.slice().sort((a, b) => activity(b) - activity(a));
+  for (const e of ranked.slice(keep)) { if (foldedKeyOf(e) !== foldedSelf) doomed.add(e.name); }
   return [...doomed];
 }
 
 // 헤드라인은 **0이면 침묵**한다. "다른 세션 0건" 은 '아무도 없다' 로 읽히는데, 이 레지스트리는
-//   (a) handoff 를 안 부르는 에이전트 (b) 업그레이드 전에 시작된 세션 (c) 다른 머신 (d) MCP 전용 클라이언트를
+//   (a) handoff 를 안 부르는 에이전트 (b) 업그레이드 전에 시작된 세션 (c) 다른 머신 (d) sessionKey 없는 MCP 클라이언트를
 //   **구조적으로 못 본다**. 못 본 것을 없다고 단언하지 않는다.
 //   ⚠ hostId 를 모르면(둘 중 하나가 null) '같은 머신' 이라고도 '다른 머신' 이라고도 하지 않는다 — 세지 않는다.
 function countOtherSessions(records, selfKey, selfHostId) {
+  const foldedSelf = typeof selfKey === 'string' ? selfKey.toLowerCase() : null;
   return (records || []).filter(r => r && isValidKey(r.sessionKey)
-    && r.sessionKey !== selfKey
+    && String(r.sessionKey).toLowerCase() !== foldedSelf
     && r.hostId && selfHostId && r.hostId === selfHostId
-    && !r.closedAt).length;
+    && !hasConfirmedClose(r)).length;
 }
 
 // 같은 머신인지 **모를 수 있다** — 3상태로 답한다(검수 P2: null 을 '다른 머신' 으로 단정했다).
@@ -176,6 +248,7 @@ function hostRelation(recordHostId, selfHostId) {
 module.exports = {
   KEY_SOURCES, keySource, invalidExplicitKey,
   SESSIONS_KEEP, SESSIONS_CLOSED_TTL_MS, KEY_RE, FILE_RE, RESERVED_KEYS, RESERVED_PREFIXES, FORBIDDEN_SIGNALS,
-  isValidKey, isTruthyEnv, deriveSessionKey, detectOutermostAgent, suppressionReason,
+  PRESENCE_ENV_KEYS, normalizePresenceEnv, isValidKey, confirmedCloseMs, hasConfirmedClose, caseVariantConflict,
+  isTruthyEnv, deriveSessionKey, detectOutermostAgent, suppressionReason,
   selectPrunable, countOtherSessions, hostRelation,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.170",
+  "version": "1.36.171",
   "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,13 +48,14 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js && npm run test:commands && npm run test:installed && node ./scripts/e2e.js",
-    "test:core": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js",
+    "test": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js && node ./scripts/mcp-presence-probe.js && npm run test:commands && npm run test:installed && node ./scripts/e2e.js",
+    "test:core": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js && node ./scripts/mcp-presence-probe.js",
     "test:commands": "node ./scripts/command-flags-probe.js && node ./scripts/next-action-suggestion-probe.js && node ./scripts/claims-baseline-probe.js && node ./scripts/claims-baseline-concurrency-probe.js && node ./scripts/e2e-command-surface.js",
     "test:next-actions": "node ./scripts/next-action-suggestion-probe.js",
     "test:installed": "node ./scripts/installed-cleanroom-probe.js",
     "test:handoff": "node ./scripts/handoff-readonly-probe.js",
-    "test:fast": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/smoke.js",
+    "test:fast": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/mcp-presence-probe.js && node ./scripts/smoke.js",
+    "test:mcp-presence": "node ./scripts/mcp-presence-probe.js",
     "test:smoke": "node ./scripts/smoke.js",
     "lint": "node ./scripts/lint.js",
     "prepack": "node ./bin/leerness.js readme sync . && node ./bin/leerness.js --version"

package/scripts/e2e.js

@@ -15029,6 +15029,7 @@ total++;
       if (!s1 || !s2 || s1.started === s2.started) bad.push('①MCP 두 세션이 같은 run 을 받음 — 판별 불가');
       else {
         if (!rec || rec.recorded !== s1.started) bad.push(`①MCP: A 의 증거가 A 의 run 이 아닌 곳에 붙음(${rec && rec.recorded})`);
+        if (!ver || ver.result !== 'pass' || !ver.run || ver.run.verification_result !== 'pass') bad.push(`①MCP: B verify pass 응답이 없거나 실패(${JSON.stringify(ver)})`);
         const allowed = ver && ver.completion_claim_allowed && ver.completion_claim_allowed.allowed;
         if (allowed) bad.push('①MCP: 일하지 않은 세션이 완료 허용을 받음 — 증거 게이트가 뒤집힘');
       }
@@ -15345,6 +15346,7 @@ total++;
       if (!s1 || !s2 || s1.started === s2.started) bad.push('②자식 env 에서 두 세션이 같은 run — 판별 불가');
       else {
         if (!rec || rec.recorded !== s1.started) bad.push(`②자식 env 에서 증거가 엉뚱한 run 에 붙음(${rec && rec.recorded})`);
+        if (!ver || ver.result !== 'pass' || !ver.run || ver.run.verification_result !== 'pass') bad.push(`②자식 env verify pass 응답이 없거나 실패(${JSON.stringify(ver)})`);
         if (ver && ver.completion_claim_allowed && ver.completion_claim_allowed.allowed) bad.push('②자식 env 에서 놀던 세션이 완료 허용을 받음');
       }
       dbg.mcpChild = { A: s1 && s1.started, recordedTo: rec && rec.recorded,

package/scripts/mcp-presence-probe.js

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+'use strict';
+
+// T-0110: MCP lifecycle calls with an explicit sessionKey must participate in
+// the same presence registry as direct CLI handoff/session-close calls. Generic
+// internal subprocesses and unaddressed MCP calls must remain invisible.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const cp = require('child_process');
+const SP = require('../lib/session-presence');
+
+const CLI = path.resolve(__dirname, '..', 'bin', 'leerness.js');
+const roots = [];
+let total = 0;
+let failed = 0;
+
+const baseEnv = {
+  ...process.env,
+  LEERNESS_OFFLINE: '1',
+  LEERNESS_NO_PROMPT: '1',
+  LEERNESS_NO_AUTOCHCP: '1',
+};
+const controlledEnvKeys = new Set([
+  'CLAUDE_CODE_SESSION_ID', 'CLAUDE_CODE_HOST_SESSION_ID', 'CLAUDE_CODE_CHILD_SESSION',
+  'LEERNESS_INTERNAL', 'LEERNESS_HOOK', 'LEERNESS_SESSION_ID', 'CODEX_THREAD_ID',
+  'LEERNESS_MCP_ADDRESS_EXPLICIT', 'LEERNESS_MCP_PROFILE', 'LEERNESS_NO_SESSION_PRESENCE',
+  'LEERNESS_NO_SUGGEST', 'LEERNESS_NO_SKILL_SUGGEST', 'LEERNESS_WORKSPACE_DIR', 'LEERNESS_LANG',
+  'CI', 'GITHUB_ACTIONS', 'CLAUDECODE', 'CURSOR_AGENT', 'CODEX_MANAGED_BY_NPM',
+].map(key => key.toLowerCase()));
+// Windows에서 실제로 발생한 lower-case 상속 오염을 모든 OS에서 재현한다. scrub이 다시
+// exact-case delete로 퇴행하면 첫 assertion이 실패하므로, 뒤의 "파일 없음" 검사가 거짓 통과하지 않는다.
+baseEnv.leerness_no_session_presence = '1';
+for (const key of Object.keys(baseEnv)) {
+  if (controlledEnvKeys.has(key.toLowerCase())) delete baseEnv[key];
+}
+const baseEnvIsolated = !Object.keys(baseEnv).some(key => controlledEnvKeys.has(key.toLowerCase()));
+
+function check(label, condition, detail = '') {
+  total++;
+  const ok = !!condition;
+  process.stdout.write(`${ok ? '✓' : '✗'} ${label}${!ok && detail ? `\n    ${detail}` : ''}\n`);
+  if (!ok) failed++;
+}
+
+function fresh(name) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), `leerness-mcp-presence-${name}-`));
+  roots.push(root);
+  const result = cp.spawnSync(process.execPath, [CLI, 'init', root, '--yes', '--minimal'], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: 120000,
+    env: baseEnv,
+  });
+  if (result.status !== 0) throw new Error(`init failed (${result.status}): ${result.stderr || result.stdout}`);
+  return root;
+}
+
+function rpcCall(name, args, id) {
+  return JSON.stringify({ jsonrpc: '2.0', id, method: 'tools/call', params: { name, arguments: args } });
+}
+
+function runMcp(root, calls, extraEnv = {}) {
+  const input = [
+    JSON.stringify({ jsonrpc: '2.0', id: 0, method: 'initialize', params: {
+      protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'presence-probe', version: '1' },
+    } }),
+    JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }),
+    ...calls,
+  ].join('\n') + '\n';
+  const result = cp.spawnSync(process.execPath, [CLI, 'mcp', 'serve', '--profile', 'full'], {
+    cwd: root,
+    input,
+    encoding: 'utf8',
+    timeout: 300000,
+    maxBuffer: 32 * 1024 * 1024,
+    env: { ...baseEnv, ...extraEnv },
+  });
+  const messages = String(result.stdout || '').split(/\r?\n/).filter(Boolean).map((line) => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+  return { result, messages, byId: (id) => messages.find((message) => message.id === id) || null };
+}
+
+function sessionDir(root) {
+  return path.join(root, '.leerness', 'cache', 'sessions');
+}
+
+function sessionFiles(root) {
+  try { return fs.readdirSync(sessionDir(root)).filter((name) => /^[A-Za-z0-9_-]{8,64}\.json$/.test(name)); }
+  catch { return []; }
+}
+
+function readSession(root, key) {
+  try { return JSON.parse(fs.readFileSync(path.join(sessionDir(root), `${key}.json`), 'utf8')); }
+  catch { return null; }
+}
+
+function runFiles(root) {
+  try { return fs.readdirSync(path.join(root, '.leerness', 'runs')).filter((name) => /^run-\d+\.json$/.test(name)); }
+  catch { return []; }
+}
+
+function rpcErrorCode(batch, id) {
+  return batch.byId(id) && batch.byId(id).error && batch.byId(id).error.code;
+}
+
+try {
+  check('probe environment cleanup is case-insensitive', baseEnvIsolated,
+    JSON.stringify(Object.keys(baseEnv).filter(key => controlledEnvKeys.has(key.toLowerCase()))));
+  const mixedCaseOptOut = SP.normalizePresenceEnv({
+    LeErNeSs_No_SeSsIoN_PrEsEnCe: '1',
+    LeErNeSs_SeSsIoN_Id: 'mixed-case-session',
+  }, { caseInsensitive: true });
+  check('presence evaluation preserves Windows case-insensitive env semantics',
+    SP.suppressionReason(mixedCaseOptOut, true) === 'opt-out'
+      && SP.deriveSessionKey(mixedCaseOptOut) === 'mixed-case-session',
+    JSON.stringify(mixedCaseOptOut));
+
+  const alpha = 'mcp-alpha-session';
+  const bravo = 'mcp-bravo-session';
+  const root = fresh('lifecycle');
+  const batch = runMcp(root, [
+    rpcCall('leerness_handoff', { path: root, sessionKey: alpha }, 2),
+    rpcCall('leerness_handoff', { path: root, sessionKey: bravo }, 3),
+    rpcCall('leerness_handoff', { path: root, sessionKey: alpha }, 4),
+    rpcCall('leerness_session_close', { path: root, sessionKey: alpha }, 5),
+  ]);
+  check('MCP lifecycle batch exits successfully', batch.result.status === 0,
+    `exit=${batch.result.status} stderr=${String(batch.result.stderr || '').slice(0, 300)}`);
+
+  const listed = batch.byId(1);
+  const tools = listed && listed.result && Array.isArray(listed.result.tools) ? listed.result.tools : [];
+  for (const name of ['leerness_handoff', 'leerness_session_close']) {
+    const tool = tools.find((entry) => entry.name === name);
+    const hasSessionKey = !!(tool && tool.inputSchema && tool.inputSchema.properties
+      && tool.inputSchema.properties.sessionKey);
+    check(`${name} advertises sessionKey`, hasSessionKey);
+  }
+
+  const files = sessionFiles(root);
+  check('addressed MCP handoffs register both sessions', files.includes(`${alpha}.json`) && files.includes(`${bravo}.json`),
+    `files=${JSON.stringify(files)}`);
+  const thirdText = batch.byId(4)?.result?.content?.[0]?.text || '';
+  check('addressed MCP handoff sees the other session', /다른 세션 1/.test(thirdText), thirdText.slice(0, 300));
+  const alphaRecord = readSession(root, alpha);
+  const bravoRecord = readSession(root, bravo);
+  check('MCP session_close closes only its addressed session',
+    !!(alphaRecord && alphaRecord.closedAt) && !!(bravoRecord && !bravoRecord.closedAt),
+    `alpha=${JSON.stringify(alphaRecord)} bravo=${JSON.stringify(bravoRecord)}`);
+
+  // 외부 Codex P2: lifecycle이 아닌 도구에 숨은 sessionKey를 주면 marker가 agent-mode의
+  // nested handoff까지 전파됐다. 광고하지 않은 주소 입력은 실행 전에 거절해야 한다.
+  const unsupportedRoot = fresh('unsupported-address');
+  const unsupported = runMcp(unsupportedRoot, [
+    rpcCall('leerness_agent_mode', { path: unsupportedRoot, sub: 'start', sessionKey: 'mcp-hidden-address' }, 2),
+  ]);
+  check('non-addressable MCP tools reject hidden sessionKey without side effects',
+    rpcErrorCode(unsupported, 2) === -32602 && sessionFiles(unsupportedRoot).length === 0,
+    `reply=${JSON.stringify(unsupported.byId(2))} files=${JSON.stringify(sessionFiles(unsupportedRoot))}`);
+
+  const anonymousRoot = fresh('anonymous');
+  const anonymous = runMcp(anonymousRoot, [rpcCall('leerness_handoff', { path: anonymousRoot }, 2)]);
+  check('unaddressed MCP handoff stays unregistered', anonymous.result.status === 0 && sessionFiles(anonymousRoot).length === 0,
+    `exit=${anonymous.result.status} files=${JSON.stringify(sessionFiles(anonymousRoot))}`);
+
+  const internalRoot = fresh('internal');
+  const internal = cp.spawnSync(process.execPath, [CLI, 'handoff', internalRoot, '--compact'], {
+    cwd: internalRoot,
+    encoding: 'utf8',
+    timeout: 120000,
+    env: { ...baseEnv, LEERNESS_INTERNAL: '1', LEERNESS_SESSION_ID: 'generic-internal-session' },
+  });
+  check('generic internal subprocess stays unregistered', internal.status === 0 && sessionFiles(internalRoot).length === 0,
+    `exit=${internal.status} files=${JSON.stringify(sessionFiles(internalRoot))}`);
+
+  const childRoot = fresh('child');
+  const child = runMcp(childRoot, [
+    rpcCall('leerness_handoff', { path: childRoot, sessionKey: 'mcp-child-addressed' }, 2),
+  ], { CLAUDE_CODE_CHILD_SESSION: '1' });
+  check('per-call MCP sessionKey survives inherited child marker',
+    child.result.status === 0 && sessionFiles(childRoot).includes('mcp-child-addressed.json'),
+    `exit=${child.result.status} files=${JSON.stringify(sessionFiles(childRoot))}`);
+
+  // 공백이 있는 임시 경로에서도 NODE_OPTIONS preload가 한 토큰으로 전달되어야 한다.
+  const suppressedRoot = fresh('hook ci suppression');
+  const childEnvLog = path.join(suppressedRoot, 'child-env.ndjson');
+  const noRecordEnvLog = path.join(suppressedRoot, 'no-record-child-env.ndjson');
+  const preloadPath = path.join(suppressedRoot, 'capture-child-env.js');
+  // NODE_OPTIONS 파서는 인용된 Windows 역슬래시도 escape로 소비한다. Node가 Windows에서도
+  // 절대 경로로 이해하는 forward-slash 표기로 바꾼 뒤 한 인자로 묶는다.
+  const preloadModule = preloadPath.replace(/\\/g, '/');
+  const preloadOption = `--require="${preloadModule.replace(/"/g, '\\"')}"`;
+  fs.writeFileSync(preloadPath, [
+    "'use strict';",
+    "const fs = require('fs');",
+    "const row = { argv: process.argv.slice(1, 8), marker: process.env.LEERNESS_MCP_ADDRESS_EXPLICIT || null };",
+    "process.on('exit', () => { try { fs.appendFileSync(process.env.LEERNESS_TEST_CHILD_ENV_LOG, JSON.stringify(row) + '\\n'); } catch {} });",
+  ].join('\n') + '\n', 'utf8');
+  const hookSuppressed = runMcp(suppressedRoot, [
+    rpcCall('leerness_handoff', { path: suppressedRoot, sessionKey: 'mcp-hook-address' }, 2),
+  ], { LEERNESS_HOOK: '1' });
+  const hookClose = runMcp(suppressedRoot, [
+    rpcCall('leerness_session_close', { path: suppressedRoot, sessionKey: 'mcp-hook-close' }, 2),
+  ], {
+    LEERNESS_HOOK: '1',
+    NODE_OPTIONS: preloadOption,
+    LEERNESS_TEST_CHILD_ENV_LOG: childEnvLog,
+  });
+  const ciSuppressed = runMcp(suppressedRoot, [
+    rpcCall('leerness_handoff', { path: suppressedRoot, sessionKey: 'mcp-ci-addressed' }, 2),
+  ], { CI: '1' });
+  check('hook and CI suppression still win over lifecycle marker',
+    hookSuppressed.result.status === 0 && ciSuppressed.result.status === 0 && sessionFiles(suppressedRoot).length === 0,
+    `files=${JSON.stringify(sessionFiles(suppressedRoot))}`);
+  let childEnvRows = [];
+  try { childEnvRows = fs.readFileSync(childEnvLog, 'utf8').split(/\r?\n/).filter(Boolean).map(line => JSON.parse(line)); } catch {}
+  const nestedRows = childEnvRows.filter(row => Array.isArray(row.argv)
+    && (row.argv.includes('skill') || row.argv.includes('drift')));
+  check('hook-suppressed MCP session_close strips marker before nested children',
+    hookClose.result.status === 0 && nestedRows.length >= 2 && nestedRows.every(row => row.marker === null),
+    `exit=${hookClose.result.status} rows=${JSON.stringify(childEnvRows)}`);
+
+  const noRecordClose = cp.spawnSync(process.execPath,
+    [CLI, 'session', 'close', suppressedRoot, '--no-record'], {
+      cwd: suppressedRoot,
+      encoding: 'utf8',
+      timeout: 120000,
+      env: {
+        ...baseEnv,
+        LEERNESS_INTERNAL: '1',
+        LEERNESS_SESSION_ID: 'mcp-no-record-close',
+        LEERNESS_MCP_ADDRESS_EXPLICIT: '1',
+        NODE_OPTIONS: preloadOption,
+        LEERNESS_TEST_CHILD_ENV_LOG: noRecordEnvLog,
+      },
+    });
+  let noRecordRows = [];
+  try { noRecordRows = fs.readFileSync(noRecordEnvLog, 'utf8').split(/\r?\n/).filter(Boolean).map(line => JSON.parse(line)); } catch {}
+  const noRecordNestedRows = noRecordRows.filter(row => Array.isArray(row.argv)
+    && (row.argv.includes('skill') || row.argv.includes('drift')));
+  check('marker-bearing session_close --no-record strips marker before nested children',
+    noRecordClose.status === 0 && noRecordNestedRows.length >= 2
+      && noRecordNestedRows.every(row => row.marker === null) && sessionFiles(suppressedRoot).length === 0,
+    `exit=${noRecordClose.status} stderr=${String(noRecordClose.stderr || '').slice(0, 300)} rows=${JSON.stringify(noRecordRows)}`);
+
+  // T-0110의 옛 currentRunId 단일 슬롯 결함은 1.36.145 이후 이미 sessionKey별 run으로
+  // 격리돼 있다. lifecycle presence 수정이 그 상태 귀속을 되돌리지 않는지 같은 MCP 경계에서 확인한다.
+  const stateRoot = fresh('state-isolation');
+  const state = runMcp(stateRoot, [
+    rpcCall('leerness_state_start', { path: stateRoot, goal: 'alpha', sessionKey: alpha }, 2),
+    rpcCall('leerness_state_start', { path: stateRoot, goal: 'bravo', sessionKey: bravo }, 3),
+    rpcCall('leerness_state_record', { path: stateRoot, filesChanged: 'alpha.js', sessionKey: alpha }, 4),
+    rpcCall('leerness_state_verify', { path: stateRoot, result: 'pass', sessionKey: bravo }, 5),
+  ]);
+  const resultJson = (id) => {
+    try { return JSON.parse(state.byId(id).result.content[0].text); } catch { return null; }
+  };
+  const startedAlpha = resultJson(2);
+  const startedBravo = resultJson(3);
+  const recordedAlpha = resultJson(4);
+  const verifiedBravo = resultJson(5);
+  check('MCP state runs remain isolated by sessionKey',
+    !!(startedAlpha && startedBravo && startedAlpha.started !== startedBravo.started
+      && recordedAlpha && recordedAlpha.recorded === startedAlpha.started
+      && verifiedBravo && verifiedBravo.verified === startedBravo.started
+      && verifiedBravo.result === 'pass' && verifiedBravo.run
+      && verifiedBravo.run.verification_result === 'pass'),
+    `alpha=${JSON.stringify(startedAlpha)} bravo=${JSON.stringify(startedBravo)} record=${JSON.stringify(recordedAlpha)} verify=${JSON.stringify(verifiedBravo)}`);
+  check('one session cannot borrow another session evidence',
+    !!(verifiedBravo && verifiedBravo.completion_claim_allowed
+      && verifiedBravo.completion_claim_allowed.allowed === false),
+    JSON.stringify(verifiedBravo));
+  check('state-only MCP calls do not create presence records', sessionFiles(stateRoot).length === 0,
+    `files=${JSON.stringify(sessionFiles(stateRoot))}`);
+
+  // 외부 Codex P1: 명시된 잘못된 값이 서버의 CODEX_THREAD_ID로 폴백하면 호출자는 주소가
+  // 거절된 줄 모르고 공유 run 슬롯을 다시 쓴다. 세 형태 모두 -32602이며 파일을 만들지 않아야 한다.
+  const invalidRoot = fresh('invalid-address');
+  const beforeRuns = runFiles(invalidRoot);
+  const invalid = runMcp(invalidRoot, [
+    rpcCall('leerness_state_start', { path: invalidRoot, goal: 'bad-space', sessionKey: 'bad key' }, 2),
+    rpcCall('leerness_state_start', { path: invalidRoot, goal: 'blank', sessionKey: '   ' }, 3),
+    rpcCall('leerness_state_start', { path: invalidRoot, goal: 'reserved', sessionKey: 'unaddressed' }, 4),
+    rpcCall('leerness_state_start', { path: invalidRoot, goal: 'trim-bypass', sessionKey: ' mcp-alpha-session ' }, 5),
+  ], { CODEX_THREAD_ID: 'server-fallback-session' });
+  check('invalid MCP sessionKey values are rejected before inherited fallback',
+    [2, 3, 4, 5].every((id) => rpcErrorCode(invalid, id) === -32602)
+      && JSON.stringify(runFiles(invalidRoot)) === JSON.stringify(beforeRuns)
+      && sessionFiles(invalidRoot).length === 0,
+    `replies=${JSON.stringify([invalid.byId(2), invalid.byId(3), invalid.byId(4), invalid.byId(5)])} runs=${JSON.stringify(runFiles(invalidRoot))}`);
+
+  const malformedValues = [
+    'not-a-date', '0', '1', '2024-02-30T00:00:00.000Z',
+    '2024-02-30T00:00:00Z', ' 2024-01-01T00:00:00.000Z ',
+  ];
+  const malformed = Array.from({ length: 21 }, (_, i) => {
+    const key = `broken${String(i).padStart(3, '0')}`;
+    return { name: `${key}.json`, record: { sessionKey: key, hostId: 'same-host', closedAt: malformedValues[i % malformedValues.length] } };
+  });
+  malformed.push({ name: 'wrongpeer.json', record: { sessionKey: 'otherpeer', hostId: 'same-host', closedAt: 'not-a-date' } });
+  const validClose = new Date(1700000000000).toISOString();
+  check('only canonical real closedAt values are confirmed; malformed values stay unconfirmed',
+    SP.selectPrunable(malformed, { selfKey: 'selfpeer', nowMs: Date.now() }).length === 0
+      && malformed.every(entry => !SP.hasConfirmedClose(entry.record))
+      && SP.countOtherSessions([malformed[0].record], 'selfpeer', 'same-host') === 1
+      && SP.confirmedCloseMs({ closedAt: validClose }) === 1700000000000,
+    JSON.stringify(SP.selectPrunable(malformed, { selfKey: 'selfpeer', nowMs: Date.now() })));
+
+  // POSIX legacy case variants are logically collapsed by read-only sessions, then migrated on the
+  // next canonical write. Windows cannot hold two case variants, so only the logical assertion applies.
+  const legacyRoot = fresh('legacy-case');
+  fs.mkdirSync(sessionDir(legacyRoot), { recursive: true });
+  const legacyName = 'CaseGhost01';
+  const foldedLegacy = legacyName.toLowerCase();
+  const legacyPath = path.join(sessionDir(legacyRoot), `${legacyName}.json`);
+  fs.writeFileSync(legacyPath, JSON.stringify({
+    schemaVersion: 1, sessionKey: legacyName, openedAt: new Date().toISOString(),
+    lastHandoffAt: new Date().toISOString(), closedAt: null,
+  }, null, 2) + '\n', 'utf8');
+  const caseSensitive = !fs.existsSync(path.join(sessionDir(legacyRoot), `${foldedLegacy}.json`));
+  const listedLegacy = cp.spawnSync(process.execPath, [CLI, 'sessions', legacyRoot, '--json'], {
+    cwd: legacyRoot, encoding: 'utf8', timeout: 120000,
+    env: { ...baseEnv, LEERNESS_SESSION_ID: foldedLegacy },
+  });
+  let legacyJson = null;
+  try { legacyJson = JSON.parse(listedLegacy.stdout); } catch {}
+  const migratedLegacy = cp.spawnSync(process.execPath, [CLI, 'handoff', legacyRoot, '--compact'], {
+    cwd: legacyRoot, encoding: 'utf8', timeout: 120000,
+    env: { ...baseEnv, LEERNESS_SESSION_ID: foldedLegacy },
+  });
+  const migratedFiles = sessionFiles(legacyRoot);
+  check('legacy mixed-case presence is one self record and migrates without a ghost',
+    listedLegacy.status === 0 && legacyJson && legacyJson.total === 1 && legacyJson.selfRecordPresent === true
+      && legacyJson.sessions[0].sessionKey === foldedLegacy && migratedLegacy.status === 0
+      && (!caseSensitive || (migratedFiles.includes(`${foldedLegacy}.json`) && !migratedFiles.includes(`${legacyName}.json`))),
+    `caseSensitive=${caseSensitive} listed=${JSON.stringify(legacyJson)} files=${JSON.stringify(migratedFiles)}`);
+
+  // 대소문자 구분 저장소의 두 열린 legacy variant는 서로 다른 구버전 세션일 수 있다.
+  // 자동 병합/삭제하지 않고 canonical record와 조회 표면에 충돌을 남긴다.
+  const ambiguousRoot = fresh('legacy-case-conflict');
+  fs.mkdirSync(sessionDir(ambiguousRoot), { recursive: true });
+  const variantA = 'CaseTwin01';
+  const variantB = 'CASETWIN01';
+  const canonicalTwin = variantA.toLowerCase();
+  const openRecord = (sessionKey) => ({
+    schemaVersion: 1, sessionKey, openedAt: new Date().toISOString(),
+    lastHandoffAt: new Date().toISOString(), closedAt: null,
+  });
+  fs.writeFileSync(path.join(sessionDir(ambiguousRoot), `${variantA}.json`),
+    JSON.stringify(openRecord(variantA), null, 2) + '\n', 'utf8');
+  const ambiguousCaseSensitive = !fs.existsSync(path.join(sessionDir(ambiguousRoot), `${canonicalTwin}.json`));
+  const pureConflict = SP.caseVariantConflict([
+    { name: `${variantA}.json`, record: openRecord(variantA) },
+    { name: `${variantB}.json`, record: openRecord(variantB) },
+  ]);
+  let physicalConflictOk = true;
+  let physicalDetail = { caseSensitive: ambiguousCaseSensitive };
+  if (ambiguousCaseSensitive) {
+    fs.writeFileSync(path.join(sessionDir(ambiguousRoot), `${variantB}.json`),
+      JSON.stringify(openRecord(variantB), null, 2) + '\n', 'utf8');
+    const wrote = cp.spawnSync(process.execPath, [CLI, 'handoff', ambiguousRoot, '--compact'], {
+      cwd: ambiguousRoot, encoding: 'utf8', timeout: 120000,
+      env: { ...baseEnv, LEERNESS_SESSION_ID: canonicalTwin },
+    });
+    const filesAfter = sessionFiles(ambiguousRoot);
+    const canonicalRecord = readSession(ambiguousRoot, canonicalTwin);
+    const listed = cp.spawnSync(process.execPath, [CLI, 'sessions', ambiguousRoot, '--json'], {
+      cwd: ambiguousRoot, encoding: 'utf8', timeout: 120000,
+      env: { ...baseEnv, LEERNESS_SESSION_ID: canonicalTwin },
+    });
+    let listedJson = null;
+    try { listedJson = JSON.parse(listed.stdout); } catch {}
+    const row = listedJson && listedJson.sessions && listedJson.sessions.find(item => item.sessionKey === canonicalTwin);
+    physicalConflictOk = wrote.status === 0
+      && filesAfter.includes(`${variantA}.json`) && filesAfter.includes(`${variantB}.json`)
+      && canonicalRecord && canonicalRecord.caseVariantConflict && canonicalRecord.caseVariantConflict.count === 2
+      && row && row.caseVariantConflict && row.caseVariantConflict.count === 3;
+    physicalDetail = { caseSensitive: true, filesAfter, canonicalRecord, row };
+  }
+  check('ambiguous open case variants are preserved and explicitly flagged',
+    pureConflict && pureConflict.count === 2 && physicalConflictOk,
+    JSON.stringify(physicalDetail));
+} catch (error) {
+  check('probe completed without exception', false, error && error.stack ? error.stack : String(error));
+} finally {
+  for (const root of roots) {
+    try { fs.rmSync(root, { recursive: true, force: true }); } catch {}
+  }
+}
+
+process.stdout.write(`MCP presence probe: ${total - failed}/${total} passed\n`);
+process.exitCode = failed ? 1 : 0;