elanous 0.2.37 → 0.2.40

package/src/self-implement/doctor-visit.ts

@@ -1,6 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
 import { debug } from '../debug/log.js';
+import { selectKnowhowPack } from './knowhow-pack.js';
 import { loadReviewRoundBrief, type ReviewRoundBrief } from './review-round-brief.js';
 import { findIncidentPrecedents, type IncidentPrecedent } from '../harness/harness-incidents.js';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
@@ -10,7 +11,7 @@ import {
   listRunLedgers,
   loadRunLedger,
   lookupRunLedger,
-  RunLedgerCheckedAppendRunIdMismatchError,
+  runLedgerDir,
   type RunLedgerCheckedAppendOutcome,
   type RunLedgerLookupOptions,
 } from './run-ledger.js';
@@ -319,6 +320,18 @@ export function recordShadowDoctorReevaluation(runId: string, dir?: string): {
   const visit = entries[visitIndex]!;
 
   const evidence = typeof visit.data.evidence === 'string' ? visit.data.evidence.trim() : '';
+  // The pack selected for this run was observed before the visit. Keep its actual slice ids;
+  // an absent or malformed observation must remain unknown, never imply an empty pack.
+  const pack = entries.slice(0, visitIndex).reverse().find((entry) => entry.event === 'knowhow-pack');
+  const packIds = Array.isArray(pack?.data?.ids) && pack.data.ids.length > 0
+    && pack.data.ids.every((id: unknown) => typeof id === 'string' && id.length > 0)
+    ? pack.data.ids as string[] : 'unknown';
+  // Pull the repository lesson at prescription time. A vanished worktree leaves the prior observed ids
+  // as provenance only; it must never manufacture a current remedy.
+  const sourceRepo = typeof pack?.data?.repoPath === 'string' ? pack.data.repoPath : null;
+  const sourceGoal = typeof pack?.data?.goal === 'string' ? pack.data.goal : null;
+  const pulled = sourceRepo && sourceGoal ? selectKnowhowPack(sourceRepo, sourceGoal) : null;
+  const currentIds = pulled?.ids.length ? pulled.ids : packIds;
   const rx = evidence ? 're-evaluate-member' as const : null;
   const outcome = evidence ? 'shadow-recorded' as const : 'needs-evidence' as const;
   const data: Record<string, unknown> = {
@@ -326,17 +339,38 @@ export function recordShadowDoctorReevaluation(runId: string, dir?: string): {
     visitIndex,
     visit: { runId, from: visit.data.from, symptom: 'admit-starved', timestamp: visit.timestamp, evidence: evidence || null },
     diagnosis: evidence ? 'admit-starved-reported' : 'evidence-unmeasured',
+    knowhowPackSliceIds: currentIds,
+    knowhowPackDecision: { source: pulled ? 'repository' : 'unavailable', ids: pulled?.ids ?? [], reason: pulled?.reason ?? 'source-unavailable',
+      reference: pulled?.text || null },
     rx,
     cost: { estimatedTokens: 0, usedTokens: 0 },
     outcome,
     execution: 'none',
-    handoff: evidence ? 'parent-re-evaluate-member' : 'visit-owner-provide-admission-evidence',
+    handoff: evidence ? `parent-re-evaluate-member${pulled?.ids.length ? ` · 검토할 노하우 ${pulled.ids.join(',')}` : ''}` : 'visit-owner-provide-admission-evidence',
   };
   appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId, event: 'doctor-rx', data }, dir);
   debug.log('run-doctor', 'rx', { runId, visitIndex, rx, outcome, shadow: true, executed: false });
   return { status: 'recorded', ...(rx ? { rx } : {}), outcome, visitIndex };
 }
 
+/** Guardian shadow tick: prescribe only for ledgers with an admit-starved visit. Repeated ticks are idempotent. */
+export function recordPendingShadowDoctorReevaluations(dir?: string): { recorded: number; alreadyRecorded: number } {
+  let recorded = 0;
+  let alreadyRecorded = 0;
+  for (const ledger of listRunLedgers(dir ? { dir } : {}).matches) {
+    const visits = ledger.entries.flatMap((entry, index) => entry.event === 'doctor-visit' && entry.data.symptom === 'admit-starved' ? [index] : []);
+    if (visits.length === 0) continue;
+    const prescribed = new Set(ledger.entries.flatMap(entry => entry.event === 'doctor-rx' && entry.data.shadow === true
+      && typeof entry.data.visitIndex === 'number' ? [entry.data.visitIndex] : []));
+    if (visits.every(index => prescribed.has(index))) { alreadyRecorded++; continue; }
+    const result = recordShadowDoctorReevaluation(ledger.runId, ledger.ledgerDirectory);
+    if (result.status === 'recorded') recorded++;
+    else if (result.status === 'already-recorded') alreadyRecorded++;
+  }
+  debug.log('run-doctor', 'shadow-tick', { recorded, alreadyRecorded });
+  return { recorded, alreadyRecorded };
+}
+
 /** OP 손판정 한 건 — 시각과 결과만 받는다(그 밖의 입력은 받지 않는다). */
 export interface DoctorOpJudgment {
   /** 손판정 시각(ISO). */
@@ -361,6 +395,18 @@ export interface DoctorComparisonRecord {
   opResult: string;
 }
 
+/**
+ * 하류 계약: 운영/시험 원장 쓰기 거부는 message 문자열이 아니라 typed identity(`reason`·`runId`·
+ * `ledgerDir`)로 도착한다. 사람이 읽는 문면은 종전과 같은 문장 그대로다.
+ */
+export class DoctorComparisonLedgerWriteRefusedError extends Error {
+  readonly reason = 'ledger-write-refused' as const;
+  constructor(readonly runId: string, readonly ledgerDir: string) {
+    super(`ledger-write-refused: 테스트 우주가 운영 원장 쓰기를 거부했습니다 (runId=${runId}) — 운영 원장에 쓰지 않았습니다`);
+    this.name = 'DoctorComparisonLedgerWriteRefusedError';
+  }
+}
+
 /**
  * RUN-DOCTOR-LIVE 0.2.36 첫 비교 슬라이스 — 그 정확한 runId 의 OP 손판정 1건(timestamp·result)을
  * 이미 기록된 shadow doctor-rx/visit 에 결속해 원장에 `doctor-compare` 한 행을 남긴다.
@@ -370,6 +416,11 @@ export interface DoctorComparisonRecord {
  * 명명된 실패 — invalid-op-judgment · run-ledger-missing · shadow-rx-missing · runId-mismatch ·
  * visit-missing. 어떤 경우도 shadow 결과를 지어내지 않는다. 같은 shadow rx 에 대한 재시도는
  * already-recorded 로 원장에 한 행만 남긴다(멱등).
+ * 하류 계약(typed identity) — ① 원장 쓰기 거부는 DoctorComparisonLedgerWriteRefusedError
+ * (`reason='ledger-write-refused'`·`runId`·`ledgerDir`), ② runId 불일치는 원장 바이트와 checked
+ * append 양쪽 모두 RunLedgerCheckedAppendRunIdMismatchError(`reason='runId-mismatch'`·
+ * `decisionRunId`·`lockedRunId`)로 도착한다. 문자열 파싱 없이 분류하고, 실제로 없는 원장만
+ * `run-ledger-missing` 이다.
  *
  * 배선 경계(의도적): 이 슬라이스의 호출자는 시험 경로뿐이다 — live dispatch·stall-watch retirement
  * 은 후속 cross-judgment 증거 슬라이스에서 붙는다(현행 `eln doctor status --json` = total 0
@@ -384,65 +435,57 @@ export function recordDoctorComparison(input: RecordDoctorComparisonInput): Doct
     throw new Error(`invalid-op-judgment: OP 손판정은 timestamp·result 문자열이 필요합니다 (runId=${runId})`);
   }
   const holder: { recorded?: DoctorComparisonRecord } = {};
-  let outcome: RunLedgerCheckedAppendOutcome<DoctorComparisonRecord>;
-  try {
-    // 단일 per-run lock 안에서 비교 행 존재 판정과 단일 append를 원자적으로 수행한다(#30403 동시 중복 결함).
-    // lock 안에서 appendRunLedgerEntry 를 다시 부르지 않는다(중첩 lock 시간초과).
-    outcome = appendRunLedgerEntryChecked<DoctorComparisonRecord>(runId, (entries) => {
-      if (entries === null) {
-        throw new Error(`run-ledger-missing: 런 원장이 없습니다 (runId=${runId}) — 새 원장을 만들지 않습니다`);
-      }
-      let shadowRxIndex = -1;
-      for (let index = 0; index < entries.length; index++) {
-        const entry = entries[index]!;
-        if (entry.event === 'doctor-rx' && entry.data.shadow === true) shadowRxIndex = index;
-      }
-      if (shadowRxIndex < 0) {
-        throw new Error(`shadow-rx-missing: 이 runId 의 shadow doctor-rx 가 없습니다 (runId=${runId}) — shadow 결과를 지어내지 않습니다`);
-      }
-      const shadowRx = entries[shadowRxIndex]!;
-      const rx = typeof shadowRx.data.rx === 'string' ? shadowRx.data.rx : null;
-      const shadowOutcome = typeof shadowRx.data.outcome === 'string' ? shadowRx.data.outcome : null;
-      const visitIndex = typeof shadowRx.data.visitIndex === 'number' ? shadowRx.data.visitIndex : -1;
-      const visit = visitIndex >= 0 && visitIndex < entries.length ? entries[visitIndex] : undefined;
-      if (visit === undefined || visit.event !== 'doctor-visit' || visit.runId !== runId) {
-        throw new Error(`visit-missing: shadow doctor-rx 가 가리키는 doctor-visit 행이 없습니다 (runId=${runId}, visitIndex=${visitIndex})`);
+  // ⛔ typed identity 를 «문자열 하나»로 뭉개지 않는다 — checked append 가 던지는
+  // RunLedgerCheckedAppendRunIdMismatchError(원장 바이트 불일치는 같은 reason 의
+  // RunLedgerEntryRunIdMismatchError)의 reason·decisionRunId·lockedRunId 가 그대로 하류까지 간다.
+  // 그래서 이 호출을 try/catch 로 감싸 재발사하지 않는다(감싸면 identity 가 사라진다).
+  // 단일 per-run lock 안에서 비교 행 존재 판정과 단일 append를 원자적으로 수행한다(#30403 동시 중복 결함).
+  // lock 안에서 appendRunLedgerEntry 를 다시 부르지 않는다(중첩 lock 시간초과).
+  const outcome: RunLedgerCheckedAppendOutcome<DoctorComparisonRecord> = appendRunLedgerEntryChecked<DoctorComparisonRecord>(runId, (entries) => {
+    if (entries === null) {
+      throw new Error(`run-ledger-missing: 런 원장이 없습니다 (runId=${runId}) — 새 원장을 만들지 않습니다`);
+    }
+    let shadowRxIndex = -1;
+    for (let index = 0; index < entries.length; index++) {
+      const entry = entries[index]!;
+      if (entry.event === 'doctor-rx' && entry.data.shadow === true) shadowRxIndex = index;
+    }
+    if (shadowRxIndex < 0) {
+      throw new Error(`shadow-rx-missing: 이 runId 의 shadow doctor-rx 가 없습니다 (runId=${runId}) — shadow 결과를 지어내지 않습니다`);
+    }
+    const shadowRx = entries[shadowRxIndex]!;
+    const rx = typeof shadowRx.data.rx === 'string' ? shadowRx.data.rx : null;
+    const shadowOutcome = typeof shadowRx.data.outcome === 'string' ? shadowRx.data.outcome : null;
+    const visitIndex = typeof shadowRx.data.visitIndex === 'number' ? shadowRx.data.visitIndex : -1;
+    const visit = visitIndex >= 0 && visitIndex < entries.length ? entries[visitIndex] : undefined;
+    if (visit === undefined || visit.event !== 'doctor-visit' || visit.runId !== runId) {
+      throw new Error(`visit-missing: shadow doctor-rx 가 가리키는 doctor-visit 행이 없습니다 (runId=${runId}, visitIndex=${visitIndex})`);
+    }
+    const existing = entries.find((entry) => entry.event === 'doctor-compare' && entry.data.shadowRxIndex === shadowRxIndex);
+    if (existing !== undefined) {
+      const stored = existing.data.opJudgment as { timestamp?: unknown; result?: unknown };
+      if (typeof stored?.timestamp !== 'string' || stored.timestamp.length === 0
+        || typeof stored?.result !== 'string' || stored.result.length === 0) {
+        throw new Error(`comparison-corrupt: 이미 기록된 doctor-compare 의 저장 판단이 손상됐습니다 (runId=${runId}, shadowRxIndex=${shadowRxIndex}, stored=${JSON.stringify(stored)}) — 거짓 already-recorded 를 승인하지 않습니다`);
       }
-      const existing = entries.find((entry) => entry.event === 'doctor-compare' && entry.data.shadowRxIndex === shadowRxIndex);
-      if (existing !== undefined) {
-        const stored = existing.data.opJudgment as { timestamp?: unknown; result?: unknown };
-        if (typeof stored?.timestamp !== 'string' || stored.timestamp.length === 0
-          || typeof stored?.result !== 'string' || stored.result.length === 0) {
-          throw new Error(`comparison-corrupt: 이미 기록된 doctor-compare 의 저장 판단이 손상됐습니다 (runId=${runId}, shadowRxIndex=${shadowRxIndex}, stored=${JSON.stringify(stored)}) — 거짓 already-recorded 를 승인하지 않습니다`);
-        }
-        if (stored.timestamp !== judgment.timestamp || stored.result !== judgment.result) {
-          throw new Error(`comparison-conflict: 이미 기록된 doctor-compare 와 손판정이 다릅니다 (runId=${runId}, shadowRxIndex=${shadowRxIndex}, stored=${JSON.stringify(stored)}, received=${JSON.stringify(judgment)}) — 기존 행을 유지합니다`);
-        }
-        return { append: false as const, result: { status: 'already-recorded' as const, visitIndex, shadowRxIndex, rx, outcome: shadowOutcome, opResult: judgment.result } };
+      if (stored.timestamp !== judgment.timestamp || stored.result !== judgment.result) {
+        throw new Error(`comparison-conflict: 이미 기록된 doctor-compare 와 손판정이 다릅니다 (runId=${runId}, shadowRxIndex=${shadowRxIndex}, stored=${JSON.stringify(stored)}, received=${JSON.stringify(judgment)}) — 기존 행을 유지합니다`);
       }
-      const data: Record<string, unknown> = {
-        shadow: true,
-        visitIndex,
-        shadowRxIndex,
-        visit: { runId, from: visit.data.from, symptom: visit.data.symptom, timestamp: visit.timestamp },
-        shadowRx: { timestamp: shadowRx.timestamp, rx, outcome: shadowOutcome },
-        opJudgment: { timestamp: judgment.timestamp, result: judgment.result },
-      };
-      holder.recorded = { status: 'recorded', visitIndex, shadowRxIndex, rx, outcome: shadowOutcome, opResult: judgment.result };
-      return { append: true as const, entry: { timestamp: new Date().toISOString(), runId, event: 'doctor-compare', data } };
-    }, input.dir);
-  } catch (error) {
-    if (error instanceof RunLedgerCheckedAppendRunIdMismatchError) {
-      throw new Error(`runId-mismatch: 원장 항목의 runId 가 요청 runId 와 다릅니다 (runId=${runId}) — ${error.message}`);
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes('runId does not match')) {
-      throw new Error(`runId-mismatch: 원장 항목의 runId 가 요청 runId 와 다릅니다 (runId=${runId}) — ${message}`);
+      return { append: false as const, result: { status: 'already-recorded' as const, visitIndex, shadowRxIndex, rx, outcome: shadowOutcome, opResult: judgment.result } };
     }
-    throw error;
-  }
+    const data: Record<string, unknown> = {
+      shadow: true,
+      visitIndex,
+      shadowRxIndex,
+      visit: { runId, from: visit.data.from, symptom: visit.data.symptom, timestamp: visit.timestamp },
+      shadowRx: { timestamp: shadowRx.timestamp, rx, outcome: shadowOutcome },
+      opJudgment: { timestamp: judgment.timestamp, result: judgment.result },
+    };
+    holder.recorded = { status: 'recorded', visitIndex, shadowRxIndex, rx, outcome: shadowOutcome, opResult: judgment.result };
+    return { append: true as const, entry: { timestamp: new Date().toISOString(), runId, event: 'doctor-compare', data } };
+  }, input.dir);
   if (outcome.refusal === 'ledger-write-refused') {
-    throw new Error(`ledger-write-refused: 테스트 우주가 운영 원장 쓰기를 거부했습니다 (runId=${runId}) — 운영 원장에 쓰지 않았습니다`);
+    throw new DoctorComparisonLedgerWriteRefusedError(runId, input.dir ?? runLedgerDir());
   }
   if (outcome.result !== null) {
     return outcome.result;

package/src/self-implement/gate-artifacts.ts

@@ -85,7 +85,8 @@ export interface GateArtifactSummary extends GateArtifactCounts {
   verdict: string | null;
   /** 판정 줄(`tests: …` / `[gate-baseline] …` / `shards: unmeasured (…)`) 그대로. */
   verdictLine?: string;
-  timeoutRechecks?: readonly { name: string; file: string; result: 'pass' | 'timeout' | 'failure' | 'unknown'; elapsedMs: number; rawResultLine: string }[];
+  timeoutRechecks?: readonly { name: string; file: string; originalDiagnostic?: string; result: 'pass' | 'timeout' | 'failure' | 'unknown'; elapsedMs: number; rawResultLine: string }[];
+  interferenceRechecks?: readonly { name: string; file: string; head: 'pass' | 'timeout' | 'failure' | 'unknown'; base: 'pass' | 'timeout' | 'failure' | 'unknown'; classification: 'interference' | 'unchanged' }[];
   exitCode: number;
   /** 정수 칸 중 하나라도 null 일 때만 — 왜 못 셌나(한 줄). */
   countsUnavailableReason?: string;
@@ -130,7 +131,8 @@ export interface GateArtifactInput {
   testFiles: readonly string[];
   verdict: string | null;
   verdictLine?: string;
-  timeoutRechecks?: readonly { name: string; file: string; result: 'pass' | 'timeout' | 'failure' | 'unknown'; elapsedMs: number; rawResultLine: string }[];
+  timeoutRechecks?: readonly { name: string; file: string; originalDiagnostic: string; result: 'pass' | 'timeout' | 'failure' | 'unknown'; elapsedMs: number; rawResultLine: string }[];
+  interferenceRechecks?: readonly { name: string; file: string; head: 'pass' | 'timeout' | 'failure' | 'unknown'; base: 'pass' | 'timeout' | 'failure' | 'unknown'; classification: 'interference' | 'unchanged' }[];
   exitCode: number;
   /** 판정 정수(못 센 칸은 null ⊕ countsUnavailableReason). 안 주면 다섯 다 null · 이유 'not recorded' — 칸은 «늘» 쓴다. */
   counts?: GateArtifactCounts;
@@ -222,6 +224,7 @@ export function writeGateArtifacts(input: GateArtifactInput): { summaryPath: str
     verdict: input.verdict,
     ...(input.verdictLine !== undefined ? { verdictLine: input.verdictLine } : {}),
     ...(input.timeoutRechecks ? { timeoutRechecks: input.timeoutRechecks } : {}),
+    ...(input.interferenceRechecks ? { interferenceRechecks: input.interferenceRechecks } : {}),
     exitCode: input.exitCode,
     introduced: counts.introduced,
     preexisting: counts.preexisting,

package/src/self-implement/gate-baseline.ts

@@ -9,7 +9,7 @@ import type { GitRunResult } from '../git-fs/retry.js';
 import { linkWorktreeDependencies, worktreeAddTimeoutForRepo } from '../git-fs/worktree.js';
 import { reapStaleGateWorktrees } from './gate-baseline-reap.js';
 
-export type GateFailureAttribution = 'introduced' | 'preexisting' | 'unknown' | 'precondition-unmet' | 'flaky-timeout' | 'flaky-rerun' | 'timeout-recheck-passed';
+export type GateFailureAttribution = 'introduced' | 'preexisting' | 'unknown' | 'precondition-unmet' | 'flaky-timeout' | 'flaky-rerun' | 'load-timeout';
 export type GateBaselinePresence = 'present' | 'missing' | 'unknown';
 export type TimeoutVariability = 'may-vary' | 'same' | 'unknown';
 
@@ -30,11 +30,13 @@ export interface GateTestFailure {
   attributedBy?: 'name-across-files' | 'copied-across-files';
   precondition?: GateFailurePrecondition;
   /** 귀속 불일치 등으로 `unknown` 판정을 내린 이유. 판정 enum 은 바꾸지 않는다. */
-  unknownReason?: '귀속 불일치';
+  unknownReason?: '귀속 불일치' | 'interference';
   /** 같은 gate 실행 안에서 같은 시험의 통과 기록이 있으면 `may-vary`로 보존한다. 타임아웃은 재실행 결과 변동성도 함께 표현한다. */
   timeoutVariability?: TimeoutVariability;
   /** 시간 초과한 정확한 시험이 base 로그에서는 통과해 자식 회귀로 귀속됐는지 나타낸다. */
   timeoutRegression?: 'passed-at-base';
+  /** Unrelated file passed alone on both the candidate and base; this remains a blocking unknown. */
+  interference?: true;
 }
 
 export interface GateBaselineSummary {
@@ -73,12 +75,22 @@ export interface GateBaselineReport extends GateBaselineSummary {
   baselineStatus: BaselineProcessStatus;
   log: string;
   timeoutRechecks?: TimeoutRecheckRecord[];
-  timeoutRecheckPassed?: number;
+  loadTimeout?: number;
+  interferenceRechecks?: InterferenceRecheckRecord[];
+}
+
+export interface InterferenceRecheckRecord {
+  name: string;
+  file: string;
+  head: TimeoutRerunObservation | 'unknown';
+  base: TimeoutRerunObservation | 'unknown';
+  classification: 'interference' | 'unchanged';
 }
 
 export interface TimeoutRecheckRecord {
   name: string;
   file: string;
+  originalDiagnostic: string;
   result: 'pass' | 'timeout' | 'failure' | 'unknown';
   elapsedMs: number;
   rawResultLine: string;
@@ -354,7 +366,7 @@ function stripAnsi(text: string): string {
   return text.replace(/\u001B\[[0-9;]*[A-Za-z]/g, '');
 }
 
-export function extractGateTestFailures(log: string): Array<Omit<GateTestFailure, 'attribution' | 'baselinePresence'>> {
+export function extractGateTestFailures(log: string, currentFileExists?: (file: string) => boolean): Array<Omit<GateTestFailure, 'attribution' | 'baselinePresence'>> {
   const failures: Array<Omit<GateTestFailure, 'attribution' | 'baselinePresence'>> = [];
   const lines = stripAnsi(log).split('\n');
   let currentFile: string | undefined;
@@ -404,6 +416,13 @@ export function extractGateTestFailures(log: string): Array<Omit<GateTestFailure
     const rawName = normalizeFailureName(match[1]!);
     const inlineFile = rawName.match(TEST_FILE_RE)?.[1];
     const file = inlineFile ?? currentFile;
+    // A failing test may print a nested Bun run from a temporary repository in its diagnostic.
+    // Its reporter-shaped lines are not tests in this checkout. The outer failure remains;
+    // if none remains, the caller reports an unparsed failure instead of accepting the gate.
+    if (file && currentFileExists && !currentFileExists(file)) {
+      lastBoundary = i;
+      continue;
+    }
     const testName = inlineFile
       ? rawName.replace(new RegExp(`^${inlineFile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*>?\\s*`), '')
       : rawName;
@@ -539,6 +558,7 @@ export function classifyGateTestFailures(
   missingAtBase: readonly string[] = [],
   rerunObservations?: GateRerunObservations,
   baselinePassedEvidence?: GatePassedTestEvidence,
+  currentFileExists?: (file: string) => boolean,
 ): GateTestFailure[] {
   const missing = new Set(missingAtBase);
   const observationsFor = (name: string): readonly TimeoutRerunObservation[] => {
@@ -546,7 +566,7 @@ export function classifyGateTestFailures(
     if (rerunObservations instanceof Map) return rerunObservations.get(name) ?? [];
     return (rerunObservations as Readonly<Record<string, readonly TimeoutRerunObservation[]>>)[name] ?? [];
   };
-  const worktreeFailures = extractGateTestFailures(worktreeLog);
+  const worktreeFailures = extractGateTestFailures(worktreeLog, currentFileExists);
   const baselineFailures = baselineLog === undefined ? [] : extractGateTestFailures(baselineLog);
   const testPath = ({ file, name }: GateTestIdentitySource): string | undefined =>
     file && name.startsWith(`${file} > `) ? name.slice(file.length + 3) : undefined;
@@ -707,7 +727,7 @@ function summarizeGateBaseline(failures: readonly GateTestFailure[]): GateBaseli
       if (failure.attribution === 'flaky-rerun') {
         return { ...withPresence, flakyRerun: withPresence.flakyRerun + 1 };
       }
-      if (failure.attribution === 'timeout-recheck-passed') {
+      if (failure.attribution === 'load-timeout') {
         return withPresence;
       }
       const withTimeoutRegression = failure.timeoutRegression === 'passed-at-base'
@@ -735,16 +755,67 @@ export function rerunBunSingleTest(cwd: string, file: string, testName: string,
   return classifyBunSingleTestRerun(result);
 }
 
+/** An unrelated failing test is interference only when the same host passes it alone on both trees.
+ *  Interference is a blocking unknown, never an exemption or a green gate. */
+export function recheckOutsideScopeFailures(
+  cwd: string,
+  report: GateBaselineReport,
+  baseRef: string,
+  relatedTestFiles: readonly string[],
+  runOne: (dir: string, file: string, name: string) => TimeoutRerunObservation | undefined =
+    (dir, file, name) => rerunBunSingleTest(dir, file, name, 60_000),
+  runBase: (dir: string, ref: string, cases: readonly { file: string; name: string }[], run: typeof runOne) =>
+    ReadonlyMap<string, TimeoutRerunObservation | undefined> | undefined = defaultInterferenceBaseRecheck,
+): GateBaselineReport {
+  const related = new Set(relatedTestFiles);
+  const candidates = report.failures.filter((failure) => failure.attribution === 'introduced'
+    && failure.file && !related.has(failure.file) && failure.baselinePresence === 'present')
+    .map((failure) => {
+      const file = failure.file!;
+      const prefix = `${file} > `;
+      return { failure, file, name: failure.name.startsWith(prefix) ? failure.name.slice(prefix.length) : failure.name };
+    });
+  if (!candidates.length) return report;
+  const head = candidates.map(({ file, name }) => runOne(cwd, file, name) ?? 'unknown');
+  const base = runBase(cwd, baseRef, candidates.map(({ file, name }) => ({ file, name })), runOne);
+  const records: InterferenceRecheckRecord[] = candidates.map(({ failure, file }, index) => {
+    const baseObservation = base?.get(`${file}\u0000${candidates[index]!.name}`) ?? 'unknown';
+    const classification = head[index] === 'pass' && baseObservation === 'pass' ? 'interference' : 'unchanged';
+    return { name: failure.name, file, head: head[index]!, base: baseObservation, classification };
+  });
+  const interference = new Set(records.filter((record) => record.classification === 'interference')
+    .map((record) => `${record.file}\u0000${record.name}`));
+  const failures = report.failures.map((failure) => failure.attribution === 'introduced'
+    && interference.has(`${failure.file}\u0000${failure.name}`)
+    ? { ...failure, attribution: 'unknown' as const, unknownReason: 'interference' as const, interference: true as const }
+    : failure);
+  return { ...report, ...summarizeGateBaseline(failures), failures, interferenceRechecks: records };
+}
+
+function defaultInterferenceBaseRecheck(
+  cwd: string, baseRef: string, cases: readonly { file: string; name: string }[],
+  runOne: (dir: string, file: string, name: string) => TimeoutRerunObservation | undefined,
+): ReadonlyMap<string, TimeoutRerunObservation | undefined> | undefined {
+  const result = withBaselineWorktree(cwd, baseRef, (baseDir) => new Map(cases.map(({ file, name }) =>
+    [`${file}\u0000${name}`, runOne(baseDir, file, name)] as const)));
+  return result instanceof Map ? result : undefined;
+}
+
 /** A standalone timeout-only retry is allowed only when every introduced failure is explicitly a Bun timeout. */
 export function recheckTimeoutOnlyIntroducedFailures(
   cwd: string,
   report: GateBaselineReport,
   run: (cwd: string, file: string, name: string, timeoutMs: number) => { observation?: TimeoutRerunObservation; elapsedMs: number; output: string } = runTimeoutRecheck,
 ): GateBaselineReport {
+  const timeoutOnlyDiagnostic = (diagnostic: string | undefined): boolean => {
+    if (!diagnostic) return false;
+    const lines = diagnostic.split('\n').map((line) => line.trim()).filter(Boolean);
+    return lines.length === 1 && /^\^ this test timed out after \d+ms\.?$/i.test(lines[0]!);
+  };
   const eligible = report.failures.length > 0
     && report.introduced === report.failures.length
     && report.failures.every((failure) => failure.attribution === 'introduced' && !!failure.file
-      && /\bthis test timed out after \d+ms\b/i.test(failure.diagnostic ?? ''));
+      && timeoutOnlyDiagnostic(failure.diagnostic));
   if (!eligible) return report;
   const records: TimeoutRecheckRecord[] = [];
   const failures = report.failures.map((failure) => {
@@ -754,19 +825,19 @@ export function recheckTimeoutOnlyIntroducedFailures(
     const { observation, elapsedMs, output } = run(cwd, failure.file, name, 60_000);
     const result = observation ?? 'unknown';
     const record: TimeoutRecheckRecord = {
-      name: failure.name, file: failure.file, result, elapsedMs,
+      name: failure.name, file: failure.file, originalDiagnostic: failure.diagnostic ?? '', result, elapsedMs,
       rawResultLine: flattenControlChars(redactSecretText(output)).slice(-500),
     };
     records.push(record);
     debug.log('gate.baseline', 'timeout-recheck', record);
-    return result === 'pass' ? { ...failure, attribution: 'timeout-recheck-passed' as const } : failure;
+    return result === 'pass' ? { ...failure, attribution: 'load-timeout' as const } : failure;
   });
   return {
     ...report,
     ...summarizeGateBaseline(failures),
     failures,
     timeoutRechecks: records,
-    timeoutRecheckPassed: failures.filter((failure) => failure.attribution === 'timeout-recheck-passed').length,
+    loadTimeout: failures.filter((failure) => failure.attribution === 'load-timeout').length,
   };
 }
 
@@ -1077,6 +1148,35 @@ export function withBaselineWorktree<T>(cwd: string, baseRef: string, run: (base
   }
 }
 
+/** Keep the baseline checkout attached until every asynchronous shard has settled. */
+export async function withBaselineWorktreeAsync<T>(cwd: string, baseRef: string, run: (baselineDir: string) => Promise<T>): Promise<T | BaselineProcessResult> {
+  reapBeforeGateAdd(cwd);
+  const baselineDir = mkdtempSync(join(tmpdir(), 'elanous-gate-baseline-'));
+  let attached = false;
+  try {
+    const started = Date.now();
+    const addTimeout = worktreeAddTimeoutForRepo(cwd, undefined, baseRef);
+    const add = runGitCommand(cwd, gateWorktreeAddArgs(baselineDir, baseRef), { encoding: 'utf8', timeout: addTimeout.ms, killSignal: 'SIGKILL' });
+    const elapsedMs = Date.now() - started;
+    debug.log('self-implement.gate-baseline', 'worktree-add-result', {
+      phase: 'baseline', status: add.status, signal: add.signal ?? null, errorCode: add.errorCode ?? null,
+      elapsedMs, timeoutMs: addTimeout.ms, trackedFileCount: addTimeout.trackedFileCount,
+      timeoutSource: addTimeout.source, parentRssBytes: process.memoryUsage().rss,
+      cgroupMemoryCurrentBytes: cgroupMemoryBytes('memory.current'), cgroupMemoryLimitBytes: cgroupMemoryBytes('memory.max'),
+    });
+    if (add.status !== 0) return classifyBaselineWorktreeAddFailure(add, elapsedMs, addTimeout.ms, worktreeAddFailureContext(cwd, baselineDir, baseRef));
+    attached = true;
+    linkDependencies(cwd, baselineDir);
+    return await run(baselineDir);
+  } catch (error) {
+    return { status: 'unknown', unknownReason: 'infrastructure-failure', childResponsibility: 'none', log: `baseline setup failed: ${String(error)}` };
+  } finally {
+    removeGateWorktree(cwd, baselineDir, !attached);
+    try { rmSync(baselineDir, { recursive: true, force: true }); }
+    catch (error) { debug.log('self-implement', 'gate.baseline.cleanup', { stage: 'exception', dir: baselineDir, error: String(error) }); }
+  }
+}
+
 function linkDependencies(cwd: string, dir: string): void {
   const dependencyLinks = linkWorktreeDependencies(cwd, dir, ['node_modules']);
   debug.log('self-implement', 'gate.baseline.dependencies', { cwd, dir, dependencyLinks });
@@ -1512,6 +1612,7 @@ export function buildGateBaselineReport(
   baseline: BaselineProcessResult,
   rerunObservations?: GateRerunObservations,
   rerunNotRun = 0,
+  currentFileExists?: (file: string) => boolean,
 ): GateBaselineReport {
   let failures = classifyGateTestFailures(
     worktreeLog,
@@ -1519,6 +1620,7 @@ export function buildGateBaselineReport(
     baseline.missingAtBase ?? [],
     rerunObservations,
     baseline.passedTestEvidence,
+    currentFileExists,
   );
   const worktreeFailuresParsed = failures.length > 0;
   if (!worktreeFailuresParsed) {
@@ -1570,7 +1672,7 @@ export function formatGateBaselineNote(report: GateBaselineReport, unrunImporter
     + `, unknown=${report.unknown}, precondition-unmet=${report.preconditionUnmet}`
     + (report.timedOut > 0 ? `, timed-out=${report.timedOut}` : '')
     + (report.flakyRerun > 0 ? `, flaky-rerun=${report.flakyRerun}` : '')
-    + ((report.timeoutRecheckPassed ?? 0) > 0 ? `, timeout-recheck-passed=${report.timeoutRecheckPassed}` : '')
+    + ((report.loadTimeout ?? 0) > 0 ? `, load-timeout=${report.loadTimeout}` : '')
     + (runId ? `, run=${runId}` : '')
     + (report.missingAtBase > 0 ? `, missing-at-base=${report.missingAtBase}` : '');
   const lines = report.failures.map((failure) => `- ${failure.attribution}: ${failure.name}`
@@ -1592,13 +1694,17 @@ export function formatGateBaselineNote(report: GateBaselineReport, unrunImporter
       ? `\n[gate-baseline] rerun not-run=${report.rerunNotRun}`
       : '';
   const timeoutRecheckLines = report.timeoutRechecks?.length
-    ? `\n[gate.baseline.timeout-recheck] ${report.timeoutRechecks.map((item) => `${item.name}: ${item.result} elapsed=${item.elapsedMs}ms · ${item.rawResultLine}`).join('\n')}`
+    ? `\n[gate.baseline.timeout-recheck] ${report.timeoutRechecks.map((item) => `${item.name}: ${item.result} elapsed=${item.elapsedMs}ms · original=${flattenControlChars(item.originalDiagnostic).slice(-500)} · ${item.rawResultLine}`).join('\n')}`
+    : '';
+  const interferenceLines = report.interferenceRechecks?.length
+    ? `\n[gate.interference] ${report.interferenceRechecks.map((item) => `${item.classification}: ${item.name} head=${item.head} base=${item.base}`).join('\n')}`
     : '';
   return `${head}\n${lines.join('\n')}\n${report.log}`
     + timedOutLine
     + mayVaryNonTimeoutLine
     + rerunLine
     + timeoutRecheckLines
+    + interferenceLines
     + (report.preexisting > 0 ? '\n⚠️ preexisting 실패는 base에서도 재현됨 — 이 PR의 책임이 아니다.' : '');
 }
 
@@ -1614,5 +1720,5 @@ export function formatVerifyByBreakingScopeSkipNote(reason: string, changedFiles
 export function allowsBaselineOnlyFailure(report: GateBaselineReport): boolean {
   if (report.baselineStatus === 'unknown') return false;
   if (!report.worktreeFailuresParsed) return false;
-  return report.introduced === 0 && report.preconditionUnmet === 0 && report.timedOut === 0 && report.flakyRerun === 0;
+  return report.introduced === 0 && report.unknown === 0 && report.preconditionUnmet === 0 && report.timedOut === 0 && report.flakyRerun === 0;
 }