elanous 0.2.38 → 0.2.41

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';
@@ -325,6 +326,12 @@ export function recordShadowDoctorReevaluation(runId: string, dir?: string): {
   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> = {
@@ -332,12 +339,14 @@ 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: packIds,
+    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 });
@@ -386,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` 한 행을 남긴다.
@@ -395,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
@@ -409,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}`);
+      return { append: false as const, result: { status: 'already-recorded' as const, visitIndex, shadowRxIndex, rx, outcome: shadowOutcome, opResult: judgment.result } };
     }
-    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}`);
-    }
-    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

@@ -78,6 +78,8 @@ export interface GateArtifactSummary extends GateArtifactCounts {
   head40: string | null;
   base40: string | null;
   envKey: string;
+  /** Seat self-gate marker observed at process entry (true only for ELANOUS_TRAIN_GATE=1). */
+  trainGate?: boolean;
   shards: number;
   cohort: string[];
   shardsDetail: GateArtifactShard[];
@@ -86,6 +88,7 @@ export interface GateArtifactSummary extends GateArtifactCounts {
   /** 판정 줄(`tests: …` / `[gate-baseline] …` / `shards: unmeasured (…)`) 그대로. */
   verdictLine?: 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;
@@ -127,10 +130,12 @@ export interface GateArtifactInput {
   head40: string | null;
   base40: string | null;
   envKey: string;
+  trainGate?: boolean;
   testFiles: readonly string[];
   verdict: string | null;
   verdictLine?: 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;
@@ -216,12 +221,14 @@ export function writeGateArtifacts(input: GateArtifactInput): { summaryPath: str
     head40: input.head40,
     base40: input.base40,
     envKey: input.envKey,
+    ...(input.trainGate !== undefined ? { trainGate: input.trainGate } : {}),
     shards: input.sharded ? input.sharded.shards.length : 0,
     cohort: sorted(input.testFiles),
     shardsDetail,
     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,
@@ -248,12 +255,14 @@ export function writeRemoteUnavailableGateArtifacts(
   reason: 'remote-unsupported' | 'remote-fetch-failed',
   resolveRev: RevResolver = defaultRevResolver(cwd),
   envKey: () => string = defaultGateEnvKey,
+  trainGate?: boolean,
 ): { summaryPath: string; junitFiles: string[] } {
   return writeGateArtifacts({
     dir: resolveArtifactDir(dir, cwd),
     head40: resolveRev('HEAD'),
     base40: baseRef ? resolveRev(baseRef) : null,
     envKey: envKey(),
+    trainGate,
     testFiles: [],
     verdict: null,
     exitCode,
@@ -263,6 +272,13 @@ export function writeRemoteUnavailableGateArtifacts(
   });
 }
 
+/** The local train wrapper owns the receipt marker, including when artifacts came from a remote host. */
+export function recordGateTrainMarker(summaryPath: string, trainGate: boolean): void {
+  const summary = JSON.parse(readFileSync(summaryPath, 'utf8')) as Record<string, unknown>;
+  summary.trainGate = trainGate;
+  writeFileSync(summaryPath, `${JSON.stringify(summary, null, 2)}\n`);
+}
+
 // ── 원격 산출 회수 (SIDE-VERIFY-GATE-SHARDS ②) ──────────────────────────────
 // 원격 run 은 `$W` 임시 트리에서 돌고 끝나면 trap 이 `$W` 를 지운다(gate-remote.ts remoteScript). 그래서 원격 쪽
 // `--artifact-dir` 는 `$W` «밖»의 호스트 디스크 경로(/var/tmp/elanous-gate-artifacts-<nonce>)로 준다 — run 이 끝나도 남고, 회수

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

@@ -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 {
@@ -74,6 +76,15 @@ export interface GateBaselineReport extends GateBaselineSummary {
   log: string;
   timeoutRechecks?: TimeoutRecheckRecord[];
   loadTimeout?: number;
+  interferenceRechecks?: InterferenceRecheckRecord[];
+}
+
+export interface InterferenceRecheckRecord {
+  name: string;
+  file: string;
+  head: TimeoutRerunObservation | 'unknown';
+  base: TimeoutRerunObservation | 'unknown';
+  classification: 'interference' | 'unchanged';
 }
 
 export interface TimeoutRecheckRecord {
@@ -355,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;
@@ -405,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;
@@ -540,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[] => {
@@ -547,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;
@@ -736,6 +755,52 @@ 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,
@@ -1547,6 +1612,7 @@ export function buildGateBaselineReport(
   baseline: BaselineProcessResult,
   rerunObservations?: GateRerunObservations,
   rerunNotRun = 0,
+  currentFileExists?: (file: string) => boolean,
 ): GateBaselineReport {
   let failures = classifyGateTestFailures(
     worktreeLog,
@@ -1554,6 +1620,7 @@ export function buildGateBaselineReport(
     baseline.missingAtBase ?? [],
     rerunObservations,
     baseline.passedTestEvidence,
+    currentFileExists,
   );
   const worktreeFailuresParsed = failures.length > 0;
   if (!worktreeFailuresParsed) {
@@ -1629,11 +1696,15 @@ export function formatGateBaselineNote(report: GateBaselineReport, unrunImporter
   const timeoutRecheckLines = report.timeoutRechecks?.length
     ? `\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의 책임이 아니다.' : '');
 }
 
@@ -1649,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;
 }