elanous 0.2.36 → 0.2.38

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

@@ -1,4 +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 { 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 {
@@ -16,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',
@@ -180,8 +219,52 @@ export function recordTaskAgentNeedsOwnerVisit(input: {
   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;
@@ -236,6 +319,12 @@ 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';
   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> = {
@@ -243,6 +332,7 @@ 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,
     rx,
     cost: { estimatedTokens: 0, usedTokens: 0 },
     outcome,
@@ -254,6 +344,24 @@ export function recordShadowDoctorReevaluation(runId: string, dir?: string): {
   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). */

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; originalDiagnostic?: 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; originalDiagnostic: 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' | 'load-timeout';
 export type GateBaselinePresence = 'present' | 'missing' | 'unknown';
 export type TimeoutVariability = 'may-vary' | 'same' | 'unknown';
 
@@ -72,6 +72,17 @@ export interface GateBaselineReport extends GateBaselineSummary {
   files: string[];
   baselineStatus: BaselineProcessStatus;
   log: string;
+  timeoutRechecks?: TimeoutRecheckRecord[];
+  loadTimeout?: number;
+}
+
+export interface TimeoutRecheckRecord {
+  name: string;
+  file: string;
+  originalDiagnostic: string;
+  result: 'pass' | 'timeout' | 'failure' | 'unknown';
+  elapsedMs: number;
+  rawResultLine: string;
 }
 
 interface GateTestCountChange {
@@ -697,6 +708,9 @@ function summarizeGateBaseline(failures: readonly GateTestFailure[]): GateBaseli
       if (failure.attribution === 'flaky-rerun') {
         return { ...withPresence, flakyRerun: withPresence.flakyRerun + 1 };
       }
+      if (failure.attribution === 'load-timeout') {
+        return withPresence;
+      }
       const withTimeoutRegression = failure.timeoutRegression === 'passed-at-base'
         ? { ...withPresence, timeoutPassedAtBase: withPresence.timeoutPassedAtBase + 1 }
         : withPresence;
@@ -722,6 +736,56 @@ 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 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
+      && timeoutOnlyDiagnostic(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, 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: 'load-timeout' as const } : failure;
+  });
+  return {
+    ...report,
+    ...summarizeGateBaseline(failures),
+    failures,
+    timeoutRechecks: records,
+    loadTimeout: failures.filter((failure) => failure.attribution === 'load-timeout').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;
 
@@ -1019,6 +1083,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 +1605,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.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}`
@@ -1532,10 +1626,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 · original=${flattenControlChars(item.originalDiagnostic).slice(-500)} · ${item.rawResultLine}`).join('\n')}`
+    : '';
   return `${head}\n${lines.join('\n')}\n${report.log}`
     + timedOutLine
     + mayVaryNonTimeoutLine
     + rerunLine
+    + timeoutRecheckLines
     + (report.preexisting > 0 ? '\n⚠️ preexisting 실패는 base에서도 재현됨 — 이 PR의 책임이 아니다.' : '');
 }