leerness 1.36.170 → 1.36.172

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/lib/workspace-dir.js

@@ -376,18 +376,18 @@ function _sameDestinationSnapshot(a, b) {
   return !!a && !!b && a.kind === b.kind && a.hash === b.hash;
 }
 
-function migrateLegacyWorkspace(root, opts = {}) {
-  const state = inspectWorkspace(root);
-  const dryRun = opts.dryRun === true;
-  const force = opts.force === true;
-  const version = String(opts.version || 'unknown');
+const _MIGRATION_LOCK_OWNED = Symbol('leerness.workspace-migration-lock-owned');
+
+function _migrationLockWaitMs(opts = {}) {
+  const parsed = Number(opts.lockWaitMs);
+  return Number.isFinite(parsed) ? Math.max(0, Math.min(60000, parsed)) : 10000;
+}
+
+function _newMigrationReport(state, opts = {}) {
   const at = opts.at || new Date().toISOString();
-  const parsedLockWait = Number(opts.lockWaitMs);
-  const lockWaitMs = Number.isFinite(parsedLockWait)
-    ? Math.max(0, Math.min(60000, parsedLockWait))
-    : 10000;
-  const lockFile = path.join(state.root, '.leerness-workspace-migration.lock');
-  const report = {
+  const version = String(opts.version || 'unknown');
+  const dryRun = opts.dryRun === true;
+  return {
     at,
     version,
     src: state.legacy.abs,
@@ -410,6 +410,74 @@ function migrateLegacyWorkspace(root, opts = {}) {
     waitedForLock: false,
     lockWaitedMs: 0,
   };
+}
+
+// Live first migrations serialize before the second workspace inspection or
+// any destination conflict scan. Acquiring later leaves a TOCTOU window where
+// a peer's in-progress canonical copy is mistaken for user-authored conflict.
+// Dry-runs and already-canonical roots stay read-only and skip lock creation.
+function migrateLegacyWorkspace(root, opts = {}) {
+  const initial = inspectWorkspace(root);
+  if (opts.dryRun === true || opts[_MIGRATION_LOCK_OWNED] === true || !initial.legacy.exists) {
+    return _migrateLegacyWorkspace(initial.root, opts);
+  }
+
+  const lockWaitMs = _migrationLockWaitMs(opts);
+  const lockFile = path.join(initial.root, '.leerness-workspace-migration.lock');
+  const startedAt = Date.now();
+  const deadline = startedAt + lockWaitMs;
+  let lockFd = null;
+  let waited = false;
+
+  while (lockFd === null) {
+    try { lockFd = fs.openSync(lockFile, 'wx'); }
+    catch (error) {
+      if (!error || (error.code !== 'EEXIST' && !_isTransientLockFsError(error))) {
+        const report = _newMigrationReport(initial, opts);
+        report.blocked = true;
+        report.blockedReason = 'workspace-dir-migration-failed';
+        report.errors.push(error && error.message ? error.message : String(error));
+        report.waitedForLock = waited;
+        report.lockWaitedMs = waited ? Math.max(0, Date.now() - startedAt) : 0;
+        return report;
+      }
+      waited = true;
+      if (Date.now() >= deadline) {
+        const report = _newMigrationReport(initial, opts);
+        report.blocked = true;
+        report.blockedReason = 'workspace-dir-migration-locked';
+        report.errors.push(`another workspace migration still owns: ${lockFile}`);
+        report.waitedForLock = true;
+        report.lockWaitedMs = Math.max(0, Date.now() - startedAt);
+        return report;
+      }
+      _sleepSync(Math.min(50, Math.max(1, deadline - Date.now())));
+    }
+  }
+
+  try {
+    const report = _migrateLegacyWorkspace(initial.root, { ...opts, [_MIGRATION_LOCK_OWNED]: true });
+    if (waited) {
+      report.waitedForLock = true;
+      report.lockWaitedMs = Math.max(report.lockWaitedMs || 0, Date.now() - startedAt);
+    }
+    return report;
+  } finally {
+    try { fs.closeSync(lockFd); } catch {}
+    _removeOwnedLockFile(lockFile);
+  }
+}
+
+function _migrateLegacyWorkspace(root, opts = {}) {
+  const state = inspectWorkspace(root);
+  const dryRun = opts.dryRun === true;
+  const migrationLockOwned = opts[_MIGRATION_LOCK_OWNED] === true;
+  const force = opts.force === true;
+  const version = String(opts.version || 'unknown');
+  const at = opts.at || new Date().toISOString();
+  const lockWaitMs = _migrationLockWaitMs(opts);
+  const lockFile = path.join(state.root, '.leerness-workspace-migration.lock');
+  const report = _newMigrationReport(state, opts);
 
   const block = (reason, message, extra = {}) => {
     report.blocked = true;
@@ -423,7 +491,7 @@ function migrateLegacyWorkspace(root, opts = {}) {
   // look foreign or dual-live while copying. Observe that transaction before
   // applying any conflict verdict; otherwise simultaneous first handoffs race
   // against an intermediate state and some fail before reaching the lock.
-  if (!dryRun && fs.existsSync(lockFile)) {
+  if (!dryRun && !migrationLockOwned && fs.existsSync(lockFile)) {
     const peerStartedAt = Date.now();
     const peerDeadline = peerStartedAt + lockWaitMs;
     report.waitedForLock = true;
@@ -559,7 +627,7 @@ function migrateLegacyWorkspace(root, opts = {}) {
   const stamp = at.replace(/[^A-Za-z0-9_-]/g, '-').slice(0, 96) || String(Date.now());
   const migrationRoot = path.join(state.canonical.abs, 'archive', `workspace-dir-migration-${stamp}`);
   const canonicalBackup = path.join(migrationRoot, 'canonical-before-merge');
-  let lockFd = null;
+  let lockFd = migrationLockOwned ? undefined : null;
   const created = [];
   const overwritten = [];
   const canonicalExisted = state.canonical.exists;
@@ -750,7 +818,7 @@ function migrateLegacyWorkspace(root, opts = {}) {
     }
     return report;
   } finally {
-    if (lockFd !== null) {
+    if (!migrationLockOwned && lockFd !== null) {
       try { fs.closeSync(lockFd); } catch {}
       _removeOwnedLockFile(lockFile);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.170",
+  "version": "1.36.172",
   "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,15 @@
     "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/workspace-dir-lock-order-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/workspace-dir-lock-order-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/workspace-dir-lock-order-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:workspace-lock-order": "node ./scripts/workspace-dir-lock-order-probe.js",
+    "test:mcp-presence": "node ./scripts/mcp-presence-probe.js",
     "test:smoke": "node ./scripts/smoke.js",
     "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,