elanous 0.2.35 → 0.2.37

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

@@ -1,11 +1,17 @@
+import { spawnSync } from 'node:child_process';
+import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
 import { debug } from '../debug/log.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';
 import {
   appendRunLedgerEntry,
+  appendRunLedgerEntryChecked,
   listRunLedgers,
   loadRunLedger,
   lookupRunLedger,
+  RunLedgerCheckedAppendRunIdMismatchError,
+  type RunLedgerCheckedAppendOutcome,
   type RunLedgerLookupOptions,
 } from './run-ledger.js';
 /** 사고 원장 루트 기본값 — 운영/시험 우주 상태 디렉터리(없으면 빈 선례 · fail-soft). */
@@ -13,6 +19,42 @@ export function doctorVisitIncidentRoot(): string {
   return elanousStateRoot();
 }
 
+export interface DoctorReviewPrMetadata { headRefOid: string; body: string; files: string[]; comments?: Array<{ body: string; author: string }> }
+
+/** Fetch only the metadata needed to anchor a saved review to the current PR head. */
+export function readDoctorReviewPr(pr: number): DoctorReviewPrMetadata {
+  const result = spawnSync('gh', ['pr', 'view', String(pr), '--json', 'headRefOid,body,files,author,comments'], {
+    encoding: 'utf8', timeout: 30_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER, stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (result.error || result.status !== 0) throw new Error(`PR #${pr} unavailable: ${result.error?.message ?? result.stderr?.trim() ?? 'gh failed'}`);
+  const data = JSON.parse(result.stdout) as { headRefOid?: unknown; body?: unknown; files?: unknown; author?: { login?: unknown }; comments?: unknown };
+  if (typeof data.headRefOid !== 'string' || !/^[a-f0-9]{40}$/i.test(data.headRefOid)) throw new Error('PR headRefOid is missing or invalid');
+  return {
+    headRefOid: data.headRefOid,
+    body: typeof data.body === 'string' ? data.body : '',
+    files: Array.isArray(data.files) ? data.files.flatMap((file: unknown) => {
+      if (typeof file === 'string') return [file];
+      if (file && typeof file === 'object' && typeof (file as { path?: unknown }).path === 'string') return [(file as { path: string }).path];
+      return [];
+    }) : [],
+    comments: typeof data.author?.login === 'string' && Array.isArray(data.comments) ? data.comments.flatMap((comment: unknown) => {
+      if (!comment || typeof comment !== 'object') return [];
+      const item = comment as { body?: unknown; author?: { login?: unknown } };
+      const login = item.author?.login;
+      return typeof item.body === 'string' && typeof login === 'string' && login === data.author?.login
+        ? [{ body: item.body, author: login }] : [];
+    }) : [],
+  };
+}
+
+/** Doctor's saved-review view; never records a run-ledger visit for a PR. */
+export function readDoctorReviewBrief(pr: number, read: (pr: number) => DoctorReviewPrMetadata = readDoctorReviewPr, reviewResultsDir?: string): ReviewRoundBrief {
+  if (!Number.isSafeInteger(pr) || pr <= 0) throw new Error('PR number must be a positive integer');
+  const metadata = read(pr);
+  return loadReviewRoundBrief({ pr, head: metadata.headRefOid, body: metadata.body, changedFiles: metadata.files, comments: metadata.comments?.map((comment) => comment.body),
+    ...(reviewResultsDir ? { reviewResultsDir } : {}) });
+}
+
 /** DOCTOR-VISIT 증상 닫힌 목록 — 이 밖의 값은 기록·조회 모두 거부한다. */
 export const DOCTOR_SYMPTOMS = [
   'admit-starved',
@@ -28,12 +70,14 @@ export const DOCTOR_SYMPTOMS = [
   'review-loop',
   'knowledge-gap',
   'too-big',
+  'long-run',
+  'needs-owner',
 ] as const;
 
 export type DoctorSymptom = (typeof DOCTOR_SYMPTOMS)[number];
 
 /** 진료 요청을 보낸 쪽 닫힌 목록. */
-export const DOCTOR_VISIT_SOURCES = ['supervisor', 'parent', 'child', 'judge', 'seat'] as const;
+export const DOCTOR_VISIT_SOURCES = ['supervisor', 'parent', 'child', 'judge', 'seat', 'auto', 'task-agent'] as const;
 
 export type DoctorVisitSource = (typeof DOCTOR_VISIT_SOURCES)[number];
 
@@ -104,8 +148,123 @@ export function recordDoctorVisit(visit: RecordDoctorVisitInput): DoctorVisit {
   };
 }
 
+const AUTO_LONG_RUN_THRESHOLD_MS = 60 * 60 * 1000;
+const AUTO_LONG_RUN_WINDOW = '60m';
+
+/** A running Pod crossing 60 minutes records one visit per run and threshold window. */
+export function recordAutoLongRunVisit(input: {
+  runId: string;
+  startedAt: string;
+  now?: string;
+  dir?: string;
+}): { status: 'below-threshold' | 'recorded' | 'already-recorded' } {
+  const startedMs = Date.parse(input.startedAt);
+  const nowMs = input.now === undefined ? Date.now() : Date.parse(input.now);
+  if (!Number.isFinite(startedMs) || !Number.isFinite(nowMs)) {
+    throw new Error('invalid-long-run-time: startedAt/now must be ISO timestamps');
+  }
+  if (loadRunLedger(input.runId, input.dir) === null) throw new Error(`run-ledger-missing: ${input.runId}`);
+  const ageMs = nowMs - startedMs;
+  if (ageMs < AUTO_LONG_RUN_THRESHOLD_MS) return { status: 'below-threshold' };
+  const timestamp = new Date(nowMs).toISOString();
+  const outcome = appendRunLedgerEntryChecked(input.runId, (entries) => {
+    if (entries === null) throw new Error(`run-ledger-missing: ${input.runId}`);
+    const seen = entries.some((entry) => entry.event === 'doctor-visit'
+      && entry.data.from === 'auto' && entry.data.symptom === 'long-run'
+      && entry.data.thresholdWindow === AUTO_LONG_RUN_WINDOW);
+    if (seen) return { append: false, result: 'already-recorded' as const };
+    return { append: true, entry: {
+      timestamp,
+      runId: input.runId,
+      event: 'doctor-visit',
+      data: { from: 'auto', symptom: 'long-run', thresholdMs: AUTO_LONG_RUN_THRESHOLD_MS,
+        thresholdWindow: AUTO_LONG_RUN_WINDOW, startedAt: input.startedAt, ageMs },
+    } };
+  }, input.dir);
+  if (outcome.appended) {
+    debug.log('run-doctor', 'visit', { runId: input.runId, from: 'auto', symptom: 'long-run', thresholdWindow: AUTO_LONG_RUN_WINDOW });
+    return { status: 'recorded' };
+  }
+  if (outcome.result === null) throw new Error(`run-ledger-write-refused: ${input.runId}`);
+  return { status: outcome.result };
+}
+
+/** A TA card's specific needs-owner transition creates one visit only if its run ledger exists. */
+export function recordTaskAgentNeedsOwnerVisit(input: {
+  runId: string;
+  cardId: string;
+  at: string;
+  reason: string;
+  transitionIndex: number;
+  dir?: string;
+}): { status: 'missing-ledger' | 'recorded' | 'already-recorded' } {
+  if (!input.reason.startsWith('failed/needs-owner')) throw new Error(`not-needs-owner: ${input.reason}`);
+  const key = JSON.stringify([input.cardId, input.transitionIndex, input.at, input.reason]);
+  const outcome = appendRunLedgerEntryChecked(input.runId, (entries) => {
+    if (entries === null) return { append: false, result: 'missing-ledger' as const };
+    if (entries.some((row) => row.event === 'doctor-visit' && row.data.from === 'task-agent'
+      && row.data.transitionKey === key)) return { append: false, result: 'already-recorded' as const };
+    return { append: true, entry: {
+      runId: input.runId,
+      timestamp: new Date().toISOString(),
+      event: 'doctor-visit',
+      data: { from: 'task-agent', symptom: 'needs-owner', evidence: input.reason,
+        cardId: input.cardId, transitionAt: input.at, transitionIndex: input.transitionIndex, transitionKey: key },
+    } };
+  }, input.dir);
+  if (outcome.appended) {
+    debug.log('run-doctor', 'visit', { runId: input.runId, from: 'task-agent', symptom: 'needs-owner', cardId: input.cardId });
+    return { status: 'recorded' };
+  }
+  return { status: outcome.result ?? 'missing-ledger' };
+}
+
+/** A parent stop that needs an owner records one shadow visit per stop, without running a prescription. */
+export function recordParentNeedsOwnerVisit(input: {
+  runId: string;
+  stopKey: string;
+  evidence: string;
+  dir?: string;
+}): { status: 'missing-ledger' | 'recorded' | 'already-recorded' } {
+  const outcome = appendRunLedgerEntryChecked(input.runId, (entries) => {
+    if (entries === null) return { append: false, result: 'missing-ledger' as const };
+    if (entries.some((entry) => entry.event === 'doctor-visit' && entry.data.from === 'parent'
+      && entry.data.symptom === 'needs-owner' && entry.data.stopKey === input.stopKey)) {
+      return { append: false, result: 'already-recorded' as const };
+    }
+    return { append: true, entry: {
+      runId: input.runId,
+      timestamp: new Date().toISOString(),
+      event: 'doctor-visit',
+      data: { from: 'parent', symptom: 'needs-owner', stopKey: input.stopKey, evidence: input.evidence },
+    } };
+  }, input.dir);
+  if (outcome.appended) {
+    debug.log('run-doctor', 'visit', { runId: input.runId, from: 'parent', symptom: 'needs-owner', stopKey: input.stopKey });
+    return { status: 'recorded' };
+  }
+  if (outcome.result === null) throw new Error(`run-ledger-write-refused: ${input.runId}`);
+  return { status: outcome.result };
+}
+
 export type ReadDoctorVisitsOptions = RunLedgerLookupOptions;
 
+/** Project logged review briefs into status without changing the run-ledger schema. Keep the latest observation per PR. */
+export function doctorReviewVisits(events: readonly { timestamp?: string; sequence?: number; runId?: string; key?: string; evidence?: string }[]): (Omit<DoctorVisit, 'runId'> & { runId?: string })[] {
+  const seenPrs = new Set<string>();
+  return [...events].sort((left, right) => {
+    const leftAt = left.timestamp ? Date.parse(left.timestamp) : 0;
+    const rightAt = right.timestamp ? Date.parse(right.timestamp) : 0;
+    return rightAt - leftAt || (right.sequence ?? 0) - (left.sequence ?? 0) || String(right.key ?? '').localeCompare(String(left.key ?? ''));
+  }).flatMap((event) => {
+    const pr = /^(\d+)(?::|$)/.exec(event.key ?? '')?.[1];
+    if (pr && seenPrs.has(pr)) return [];
+    if (pr) seenPrs.add(pr);
+    return [{ ...(event.runId ? { runId: event.runId } : {}), from: 'seat' as const, symptom: 'review-loop' as const,
+      ...(event.evidence ? { evidence: event.evidence } : {}), ...(event.timestamp ? { timestamp: event.timestamp } : {}) }];
+  });
+}
+
 /** `runId` 원장이 조회 범위 안에 있는가 — `doctor status --run` 이 없는 런을 «0건»으로 삼키지 않게 한다. */
 export function doctorVisitRunExists(runId: string, options: ReadDoctorVisitsOptions = {}): boolean {
   return lookupRunLedger(runId, options).matches.length > 0;
@@ -133,3 +292,165 @@ export function readDoctorVisits(runId?: string, options: ReadDoctorVisitsOption
   return visits.sort((left, right) =>
     (left.timestamp ?? '').localeCompare(right.timestamp ?? '') || left.runId.localeCompare(right.runId));
 }
+
+/** First RUN-DOCTOR-LOOP shadow prescription. It records advice and never dispatches it. */
+export function recordShadowDoctorReevaluation(runId: string, dir?: string): {
+  status: 'recorded' | 'already-recorded' | 'no-visit';
+  rx?: 're-evaluate-member';
+  outcome?: 'shadow-recorded' | 'needs-evidence';
+  visitIndex?: number;
+} {
+  const entries = loadRunLedger(runId, dir);
+  if (entries === null) throw new Error(`없음: 런 원장이 없습니다 (runId=${runId})`);
+  let visitIndex = -1;
+  let lastVisitIndex = -1;
+  for (let index = 0; index < entries.length; index++) {
+    if (entries[index]?.event !== 'doctor-visit' || entries[index]?.data.symptom !== 'admit-starved') continue;
+    lastVisitIndex = index;
+    if (!entries.some((entry) => entry.event === 'doctor-rx'
+      && entry.data.shadow === true && entry.data.visitIndex === index)) {
+      visitIndex = index;
+      break;
+    }
+  }
+  if (visitIndex < 0) return lastVisitIndex < 0
+    ? { status: 'no-visit' }
+    : { status: 'already-recorded', visitIndex: lastVisitIndex };
+  const visit = entries[visitIndex]!;
+
+  const evidence = typeof visit.data.evidence === 'string' ? visit.data.evidence.trim() : '';
+  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> = {
+    shadow: true,
+    visitIndex,
+    visit: { runId, from: visit.data.from, symptom: 'admit-starved', timestamp: visit.timestamp, evidence: evidence || null },
+    diagnosis: evidence ? 'admit-starved-reported' : 'evidence-unmeasured',
+    rx,
+    cost: { estimatedTokens: 0, usedTokens: 0 },
+    outcome,
+    execution: 'none',
+    handoff: evidence ? 'parent-re-evaluate-member' : '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 };
+}
+
+/** OP 손판정 한 건 — 시각과 결과만 받는다(그 밖의 입력은 받지 않는다). */
+export interface DoctorOpJudgment {
+  /** 손판정 시각(ISO). */
+  timestamp: string;
+  /** 손판정 결과 — 예: 'agree' | 'disagree'. */
+  result: string;
+}
+
+export interface RecordDoctorComparisonInput {
+  runId: string;
+  judgment: DoctorOpJudgment;
+  /** 원장 디렉터리(시험 seam) — 기본 = `runLedgerDir()`. */
+  dir?: string;
+}
+
+export interface DoctorComparisonRecord {
+  status: 'recorded' | 'already-recorded';
+  visitIndex: number;
+  shadowRxIndex: number;
+  rx: string | null;
+  outcome: string | null;
+  opResult: string;
+}
+
+/**
+ * RUN-DOCTOR-LIVE 0.2.36 첫 비교 슬라이스 — 그 정확한 runId 의 OP 손판정 1건(timestamp·result)을
+ * 이미 기록된 shadow doctor-rx/visit 에 결속해 원장에 `doctor-compare` 한 행을 남긴다.
+ * 행에는 양쪽 판단 시각(visit·shadowRx·OP), 원본 shadow rx/outcome, OP 판정 결과,
+ * 안정적 원본 인덱스(visitIndex·shadowRxIndex)를 담는다. 존재 판정과 단일 append 는
+ * appendRunLedgerEntryChecked 로 같은 per-run lock 안에서 원자적으로 이뤄진다(#30403).
+ * 명명된 실패 — invalid-op-judgment · run-ledger-missing · shadow-rx-missing · runId-mismatch ·
+ * visit-missing. 어떤 경우도 shadow 결과를 지어내지 않는다. 같은 shadow rx 에 대한 재시도는
+ * already-recorded 로 원장에 한 행만 남긴다(멱등).
+ *
+ * 배선 경계(의도적): 이 슬라이스의 호출자는 시험 경로뿐이다 — live dispatch·stall-watch retirement
+ * 은 후속 cross-judgment 증거 슬라이스에서 붙는다(현행 `eln doctor status --json` = total 0
+ * operating visits 이므로 live outcome 을 주장하지 않는다).
+ */
+export function recordDoctorComparison(input: RecordDoctorComparisonInput): DoctorComparisonRecord {
+  const runId = input.runId;
+  const judgment = input.judgment;
+  if (typeof judgment !== 'object' || judgment === null
+    || typeof judgment.timestamp !== 'string' || judgment.timestamp.length === 0
+    || typeof judgment.result !== 'string' || judgment.result.length === 0) {
+    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})`);
+      }
+      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 } };
+      }
+      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}`);
+    }
+    throw error;
+  }
+  if (outcome.refusal === 'ledger-write-refused') {
+    throw new Error(`ledger-write-refused: 테스트 우주가 운영 원장 쓰기를 거부했습니다 (runId=${runId}) — 운영 원장에 쓰지 않았습니다`);
+  }
+  if (outcome.result !== null) {
+    return outcome.result;
+  }
+  if (holder.recorded === undefined) {
+    throw new Error(`run-ledger-missing: 런 원장이 없습니다 (runId=${runId}) — 새 원장을 만들지 않습니다`);
+  }
+  const record = holder.recorded;
+  debug.log('run-doctor', 'compare', { runId, visitIndex: record.visitIndex, shadowRxIndex: record.shadowRxIndex, opResult: judgment.result, executed: false });
+  return record;
+}

package/src/self-implement/evidence-command-budget.ts

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { basename, dirname, resolve, sep } from 'node:path';
+import ts from 'typescript';
+import { siblingTestPath } from '../self-dev/launch-preflight-text.js';
+
+// A generated evidence check is a smoke test. Large integration files belong in the
+// changed gate, where they have a separate budget and failure attribution.
+export const EVIDENCE_TEST_MAX_BYTES = 64 * 1024;
+
+/** An empty seam value is unresolved and must use the real HEAD reader. */
+export function resolveEvidenceHeadCommit(seamHead: string | undefined, readHead: () => string | undefined): string | undefined {
+  return seamHead?.trim() || readHead()?.trim() || undefined;
+}
+
+function directlyImportsTarget(path: string, source: string, targetSpecifiers: ReadonlySet<string>): boolean {
+  const ast = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, false);
+  let found = false;
+  const visit = (node: ts.Node): void => {
+    if (found) return;
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)
+      && !node.importClause?.isTypeOnly
+      && !(node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)
+        && !node.importClause.name && node.importClause.namedBindings.elements.every((element) => element.isTypeOnly))) {
+      found = targetSpecifiers.has(node.moduleSpecifier.text);
+    } else if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword
+      && node.arguments.length === 1 && ts.isStringLiteral(node.arguments[0])) {
+      found = targetSpecifiers.has(node.arguments[0].text);
+    }
+    if (!found) ts.forEachChild(node, visit);
+  };
+  visit(ast);
+  return found;
+}
+
+/** Pick a small test that directly imports the target; never substitute an unrelated test. */
+export function focusedEvidenceTestPath(target: string, repositoryRoot?: string): string | null {
+  const sibling = siblingTestPath(target);
+  if (!sibling) return null;
+  if (!repositoryRoot) return sibling;
+  const root = resolve(repositoryRoot);
+  const absolute = resolve(root, sibling);
+  if (!absolute.startsWith(`${root}${sep}`)) return null;
+  try {
+    // Authoring can precede creation of its declared test file. Preserve that
+    // existing command contract; the size budget only applies to a measured file.
+    if (!existsSync(absolute)) return sibling;
+    // Follow a symlink so its target's measured size, not link text length, sets the budget.
+    const siblingStat = statSync(absolute);
+    if (siblingStat.isFile() && siblingStat.size <= EVIDENCE_TEST_MAX_BYTES) return sibling;
+    const stem = basename(target, '.ts');
+    const importName = `./${stem}`;
+    const targetSpecifiers = new Set([`${importName}.js`, `${importName}.ts`, importName]);
+    const candidates = readdirSync(dirname(absolute))
+      .filter((name) => name.startsWith(`${stem}-`) && name.endsWith('.test.ts') && !/['\\]/u.test(name))
+      .map((name) => ({ name, absolute: resolve(dirname(absolute), name) }))
+      .flatMap(({ name, absolute: path }) => {
+        // Match the sibling rule: a linked test is measured by its target.
+        const stat = statSync(path);
+        if (!stat.isFile() || stat.size > EVIDENCE_TEST_MAX_BYTES) return [];
+        const source = readFileSync(path, 'utf8');
+        return directlyImportsTarget(path, source, targetSpecifiers) ? [{ name, size: stat.size }] : [];
+      })
+      .sort((a, b) => a.size - b.size || a.name.localeCompare(b.name));
+    return candidates.length ? `${dirname(sibling)}/${candidates[0]!.name}` : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Only rewrite a single, safely quoted generated Bun test command. */
+export function narrowerEvidenceCommand(command: string, repositoryRoot: string): string | null {
+  const match = /^bun test -- '([^']+)'$/u.exec(command);
+  // Generated paths with shell quote escapes are deliberately left untouched here.
+  if (!match || match[1]!.includes('\\')) return null;
+  const testPath = match[1]!;
+  if (!testPath.endsWith('.test.ts')) return null;
+  const target = `${testPath.slice(0, -'.test.ts'.length)}.ts`;
+  const focused = focusedEvidenceTestPath(target, repositoryRoot);
+  return focused && focused !== testPath && !/['\\]/u.test(focused) ? `bun test -- '${focused}'` : null;
+}

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

@@ -85,6 +85,7 @@ 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 }[];
   exitCode: number;
   /** 정수 칸 중 하나라도 null 일 때만 — 왜 못 셌나(한 줄). */
   countsUnavailableReason?: string;
@@ -129,6 +130,7 @@ 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 }[];
   exitCode: number;
   /** 판정 정수(못 센 칸은 null ⊕ countsUnavailableReason). 안 주면 다섯 다 null · 이유 'not recorded' — 칸은 «늘» 쓴다. */
   counts?: GateArtifactCounts;
@@ -219,6 +221,7 @@ export function writeGateArtifacts(input: GateArtifactInput): { summaryPath: str
     shardsDetail,
     verdict: input.verdict,
     ...(input.verdictLine !== undefined ? { verdictLine: input.verdictLine } : {}),
+    ...(input.timeoutRechecks ? { timeoutRechecks: input.timeoutRechecks } : {}),
     exitCode: input.exitCode,
     introduced: counts.introduced,
     preexisting: counts.preexisting,
@@ -388,8 +391,9 @@ export function importRemoteGateArtifacts(dir: string, files: Map<string, Buffer
     writeFileSync(run.resultPath, `${JSON.stringify(result, null, 2)}\n`);
   };
   for (const shard of summary.shardsDetail) { relocate(shard?.current); relocate(shard?.baseline); }
-  // OP FU (MK #8178) — 원격 조각의 실패 증거(`<shardId>.failure.json`)도 그대로 가져온다(관측만 · summary 는 안 고친다).
-  for (const [name, bytes] of files) if (name.endsWith('.failure.json') && artifactNamePattern.test(name)) writeFileSync(join(dir, name), bytes);
+  // Optional observations stay optional for older remote commits. Neither changes the gate verdict.
+  for (const [name, bytes] of files) if ((name === 'progress.json' || name.endsWith('.failure.json'))
+    && artifactNamePattern.test(name)) writeFileSync(join(dir, name), bytes);
   summary.remoteHost = host;
   writeFileSync(summaryPath, `${JSON.stringify(summary, null, 2)}\n`);
   return { summaryPath, junitFiles };

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';
+export type GateFailureAttribution = 'introduced' | 'preexisting' | 'unknown' | 'precondition-unmet' | 'flaky-timeout' | 'flaky-rerun' | 'timeout-recheck-passed';
 export type GateBaselinePresence = 'present' | 'missing' | 'unknown';
 export type TimeoutVariability = 'may-vary' | 'same' | 'unknown';
 
@@ -72,6 +72,16 @@ export interface GateBaselineReport extends GateBaselineSummary {
   files: string[];
   baselineStatus: BaselineProcessStatus;
   log: string;
+  timeoutRechecks?: TimeoutRecheckRecord[];
+  timeoutRecheckPassed?: number;
+}
+
+export interface TimeoutRecheckRecord {
+  name: string;
+  file: string;
+  result: 'pass' | 'timeout' | 'failure' | 'unknown';
+  elapsedMs: number;
+  rawResultLine: string;
 }
 
 interface GateTestCountChange {
@@ -697,6 +707,9 @@ function summarizeGateBaseline(failures: readonly GateTestFailure[]): GateBaseli
       if (failure.attribution === 'flaky-rerun') {
         return { ...withPresence, flakyRerun: withPresence.flakyRerun + 1 };
       }
+      if (failure.attribution === 'timeout-recheck-passed') {
+        return withPresence;
+      }
       const withTimeoutRegression = failure.timeoutRegression === 'passed-at-base'
         ? { ...withPresence, timeoutPassedAtBase: withPresence.timeoutPassedAtBase + 1 }
         : withPresence;
@@ -722,6 +735,51 @@ export function rerunBunSingleTest(cwd: string, file: string, testName: string,
   return classifyBunSingleTestRerun(result);
 }
 
+/** 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 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 ?? ''));
+  if (!eligible) return report;
+  const records: TimeoutRecheckRecord[] = [];
+  const failures = report.failures.map((failure) => {
+    if (!failure.file) return failure;
+    const prefix = `${failure.file} > `;
+    const name = failure.name.startsWith(prefix) ? failure.name.slice(prefix.length) : failure.name;
+    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,
+      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 {
+    ...report,
+    ...summarizeGateBaseline(failures),
+    failures,
+    timeoutRechecks: records,
+    timeoutRecheckPassed: failures.filter((failure) => failure.attribution === 'timeout-recheck-passed').length,
+  };
+}
+
+function runTimeoutRecheck(cwd: string, file: string, name: string, timeoutMs: number): { observation?: TimeoutRerunObservation; elapsedMs: number; output: string } {
+  const started = Date.now();
+  const result = runIsolatedBunTest(cwd, ['--timeout', String(timeoutMs), '--test-name-pattern', buildBunSingleTestPattern(name), file], timeoutMs + 10_000);
+  return {
+    observation: classifyBunSingleTestRerun(result),
+    elapsedMs: Date.now() - started,
+    output: `${String(result.stdout ?? '')}\n${String(result.stderr ?? '')}`,
+  };
+}
+
 /** `introduced` 재실행 상한. 초과분은 돌리지 않고 보고서에 남긴다. 부하로 건너뛰지 않는다. */
 export const INTRODUCED_RERUN_CAP = 8;
 
@@ -1512,6 +1570,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}` : '')
     + (runId ? `, run=${runId}` : '')
     + (report.missingAtBase > 0 ? `, missing-at-base=${report.missingAtBase}` : '');
   const lines = report.failures.map((failure) => `- ${failure.attribution}: ${failure.name}`
@@ -1532,10 +1591,14 @@ export function formatGateBaselineNote(report: GateBaselineReport, unrunImporter
     : report.rerunNotRun > 0
       ? `\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')}`
+    : '';
   return `${head}\n${lines.join('\n')}\n${report.log}`
     + timedOutLine
     + mayVaryNonTimeoutLine
     + rerunLine
+    + timeoutRecheckLines
     + (report.preexisting > 0 ? '\n⚠️ preexisting 실패는 base에서도 재현됨 — 이 PR의 책임이 아니다.' : '');
 }