elanous 0.2.41 → 0.2.43

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 { readRunChart, recordRunChartDecision } from './run-chart.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';
@@ -15,6 +16,8 @@ import {
   type RunLedgerCheckedAppendOutcome,
   type RunLedgerLookupOptions,
 } from './run-ledger.js';
+import { pickAutohealAction, type AutohealAction } from './stop-autoheal.js';
+import { RUN_STOP_CLASSES, type RunStopClass } from './run-stop.js';
 /** 사고 원장 루트 기본값 — 운영/시험 우주 상태 디렉터리(없으면 빈 선례 · fail-soft). */
 export function doctorVisitIncidentRoot(): string {
   return elanousStateRoot();
@@ -250,6 +253,91 @@ export function recordParentNeedsOwnerVisit(input: {
 
 export type ReadDoctorVisitsOptions = RunLedgerLookupOptions;
 
+export interface RunDoctorHandoffResult {
+  status: 'acted' | 'already-acted' | 'needs-human' | 'missing-handoff';
+  action?: AutohealAction;
+  outcome?: string;
+  stopKey: string;
+}
+
+/** Consume one persisted run-supervisor handoff through PR1's graph-aware stop prescription. */
+export async function runDoctorHandoff(input: {
+  runId: string;
+  stopKey: string;
+  dir?: string;
+  dispatch: (action: AutohealAction, handoff: Record<string, unknown>) => Promise<{ outcome: string; detail?: string }> | { outcome: string; detail?: string };
+}): Promise<RunDoctorHandoffResult> {
+  const entries = loadRunLedger(input.runId, input.dir);
+  if (entries === null) return { status: 'missing-handoff', stopKey: input.stopKey };
+  const latestHandoff = [...entries].reverse().find((entry) => entry.event === 'run-chart-cell'
+    && entry.data.device === 'run-supervisor' && entry.data.handoff === 'run-doctor');
+  const handoff = latestHandoff?.data.stopKey === input.stopKey ? latestHandoff : undefined;
+  if (!handoff) return { status: 'missing-handoff', stopKey: input.stopKey };
+  const prior = entries.filter((entry) => entry.event === 'doctor-rx' && entry.data.stopKey === input.stopKey);
+  const completed = prior.find((entry) => entry.data.status === 'completed' || entry.data.status === 'needs-human');
+  if (completed) return { status: completed.data.status === 'completed' ? 'already-acted' : 'needs-human',
+    ...(typeof completed.data.action === 'string' ? { action: completed.data.action as AutohealAction } : {}),
+    ...(typeof completed.data.outcome === 'string' ? { outcome: completed.data.outcome } : {}), stopKey: input.stopKey };
+  if (prior.some((entry) => entry.data.status === 'started')) {
+    const outcome = 'needs-human: prior doctor action started without a recorded result';
+    return { status: 'needs-human', outcome, stopKey: input.stopKey };
+  }
+
+  const chartBefore = readRunChart(input.runId, 'run-doctor', input.dir ?? runLedgerDir());
+  const rawClass = handoff.data.failureClass ?? (handoff.data.verdict === 'wait' ? 'implement-aborted' : undefined);
+  const failureClass = typeof rawClass === 'string' && (RUN_STOP_CLASSES as readonly string[]).includes(rawClass)
+    ? rawClass as RunStopClass : 'unclassified';
+  const prescription = pickAutohealAction(failureClass);
+  const visitAppend = appendRunLedgerEntryChecked(input.runId, (current) => {
+    if (current === null) return { append: false, result: false };
+    if (current.some((entry) => entry.event === 'doctor-visit' && entry.data.stopKey === input.stopKey)) return { append: false, result: true };
+    return { append: true, entry: { timestamp: new Date().toISOString(), runId: input.runId,
+      event: 'doctor-visit', data: { from: 'supervisor', symptom: 'no-progress', stopKey: input.stopKey,
+        evidence: `consecutive wait decisions=${String(handoff.data.waitCount ?? 'unknown')}`, prescription: prescription.action } } };
+  }, input.dir);
+  if (!visitAppend.appended && visitAppend.result !== true) return { status: 'missing-handoff', stopKey: input.stopKey };
+  const claim = appendRunLedgerEntryChecked(input.runId, (current) => {
+    if (current === null) return { append: false, result: 'missing-ledger' as const };
+    const priorAction = current.find((entry) => entry.event === 'doctor-rx' && entry.data.stopKey === input.stopKey);
+    if (priorAction) return { append: false, result: priorAction.data.status === 'completed' ? 'completed' as const
+      : priorAction.data.status === 'needs-human' ? 'needs-human' as const : 'in-progress' as const };
+    return { append: true, entry: { timestamp: new Date().toISOString(), runId: input.runId, event: 'doctor-rx',
+      data: { device: 'run-doctor', stopKey: input.stopKey, status: 'started', action: prescription.action,
+        source: prescription.source, ...(prescription.overlayId ? { overlayId: prescription.overlayId } : {}), executed: false } } };
+  }, input.dir);
+  if (!claim.appended) {
+    if (claim.result === 'completed') return { status: 'already-acted', action: prescription.action, stopKey: input.stopKey };
+    return { status: 'needs-human', action: prescription.action,
+      outcome: claim.result === 'needs-human' ? 'needs-human: prior action requires a person'
+        : claim.result === 'missing-ledger' ? 'needs-human: run ledger missing' : 'needs-human: doctor action already in progress',
+      stopKey: input.stopKey };
+  }
+
+  let outcome: string;
+  let detail: string | undefined;
+  try {
+    const result = await input.dispatch(prescription.action, handoff.data);
+    outcome = result.outcome;
+    detail = result.detail;
+  } catch (error) {
+    outcome = 'needs-human';
+    detail = error instanceof Error ? error.message : String(error);
+  }
+  const needsHuman = outcome === 'needs-human' || outcome.startsWith('needs-human:');
+  appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId: input.runId, event: 'doctor-rx',
+    data: { device: 'run-doctor', stopKey: input.stopKey, status: needsHuman ? 'needs-human' : 'completed',
+      action: prescription.action, source: prescription.source, outcome, executed: !needsHuman,
+      ...(detail ? { detail: detail.slice(0, 300) } : {}) } }, input.dir);
+  recordRunChartDecision({ runId: input.runId, device: 'run-doctor', stopKey: input.stopKey,
+    observed: String(handoff.data.observed ?? 'supervisor handoff'), verdict: needsHuman ? 'needs-human' : 'acted',
+    action: prescription.action, handoff: needsHuman ? 'outer-supervisor'
+      : prescription.action === 'reauthor-from-materialized' ? 'reauthor' : null,
+    why: detail ?? outcome, readStopKeys: chartBefore.map((cell) => cell.stopKey), dir: input.dir ?? runLedgerDir() });
+  debug.log('run-doctor', 'action', { runId: input.runId, stopKey: input.stopKey, action: prescription.action,
+    source: prescription.source, outcome, executed: !needsHuman });
+  return { status: needsHuman ? 'needs-human' : 'acted', action: prescription.action, outcome, stopKey: input.stopKey };
+}
+
 /** 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>();
@@ -395,6 +483,26 @@ export interface DoctorComparisonRecord {
   opResult: string;
 }
 
+/**
+ * 하류 계약: 비교 판정의 명명된 실패는 message 문자열이 아니라 typed identity(`reason`)로도 도착한다.
+ * 사람이 읽는 문면은 종전과 같은 문장 그대로다(문장 접두사 = reason). 실제로 없는 원장만
+ * `run-ledger-missing` 이고, 운영/시험 원장 쓰기 거부는 이 클래스가 아니라
+ * `DoctorComparisonLedgerWriteRefusedError` 다.
+ */
+export type DoctorComparisonFailureReason =
+  | 'run-ledger-missing'
+  | 'shadow-rx-missing'
+  | 'visit-missing'
+  | 'comparison-corrupt'
+  | 'comparison-conflict';
+
+export class DoctorComparisonFailureError extends Error {
+  constructor(readonly reason: DoctorComparisonFailureReason, message: string) {
+    super(message);
+    this.name = 'DoctorComparisonFailureError';
+  }
+}
+
 /**
  * 하류 계약: 운영/시험 원장 쓰기 거부는 message 문자열이 아니라 typed identity(`reason`·`runId`·
  * `ledgerDir`)로 도착한다. 사람이 읽는 문면은 종전과 같은 문장 그대로다.
@@ -419,8 +527,10 @@ export class DoctorComparisonLedgerWriteRefusedError extends Error {
  * 하류 계약(typed identity) — ① 원장 쓰기 거부는 DoctorComparisonLedgerWriteRefusedError
  * (`reason='ledger-write-refused'`·`runId`·`ledgerDir`), ② runId 불일치는 원장 바이트와 checked
  * append 양쪽 모두 RunLedgerCheckedAppendRunIdMismatchError(`reason='runId-mismatch'`·
- * `decisionRunId`·`lockedRunId`)로 도착한다. 문자열 파싱 없이 분류하고, 실제로 없는 원장만
- * `run-ledger-missing` 이다.
+ * `decisionRunId`·`lockedRunId`)로 도착한다, ③ 나머지 명명된 실패(run-ledger-missing·
+ * shadow-rx-missing·visit-missing·comparison-corrupt·comparison-conflict)는
+ * DoctorComparisonFailureError(`reason` = 그 이름, 사람 문면은 접두사 그대로)로 도착한다.
+ * 문자열 파싱 없이 분류하고, 실제로 없는 원장만 `run-ledger-missing` 이다.
  *
  * 배선 경계(의도적): 이 슬라이스의 호출자는 시험 경로뿐이다 — live dispatch·stall-watch retirement
  * 은 후속 cross-judgment 증거 슬라이스에서 붙는다(현행 `eln doctor status --json` = total 0
@@ -443,7 +553,7 @@ export function recordDoctorComparison(input: RecordDoctorComparisonInput): Doct
   // lock 안에서 appendRunLedgerEntry 를 다시 부르지 않는다(중첩 lock 시간초과).
   const outcome: RunLedgerCheckedAppendOutcome<DoctorComparisonRecord> = appendRunLedgerEntryChecked<DoctorComparisonRecord>(runId, (entries) => {
     if (entries === null) {
-      throw new Error(`run-ledger-missing: 런 원장이 없습니다 (runId=${runId}) — 새 원장을 만들지 않습니다`);
+      throw new DoctorComparisonFailureError('run-ledger-missing', `run-ledger-missing: 런 원장이 없습니다 (runId=${runId}) — 새 원장을 만들지 않습니다`);
     }
     let shadowRxIndex = -1;
     for (let index = 0; index < entries.length; index++) {
@@ -451,7 +561,7 @@ export function recordDoctorComparison(input: RecordDoctorComparisonInput): Doct
       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 결과를 지어내지 않습니다`);
+      throw new DoctorComparisonFailureError('shadow-rx-missing', `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;
@@ -459,17 +569,17 @@ export function recordDoctorComparison(input: RecordDoctorComparisonInput): Doct
     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})`);
+      throw new DoctorComparisonFailureError('visit-missing', `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 를 승인하지 않습니다`);
+        throw new DoctorComparisonFailureError('comparison-corrupt', `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)}) — 기존 행을 유지합니다`);
+        throw new DoctorComparisonFailureError('comparison-conflict', `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 } };
     }
@@ -491,7 +601,7 @@ export function recordDoctorComparison(input: RecordDoctorComparisonInput): Doct
     return outcome.result;
   }
   if (holder.recorded === undefined) {
-    throw new Error(`run-ledger-missing: 런 원장이 없습니다 (runId=${runId}) — 새 원장을 만들지 않습니다`);
+    throw new DoctorComparisonFailureError('run-ledger-missing', `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 });

package/src/self-implement/elanous-tui-spawn.ts

@@ -17,6 +17,9 @@ import { debug } from '../debug/log.js';
  *  같은 값인지는 elanous-tui-spawn-identity.test.ts 가 잡는다. */
 export const PREAMBLE_SYNC_BLOCK_ENV = 'ELANOUS_TEST_PREAMBLE_SYNC_BLOCK_MS';
 
+/** Bare held TUI startup includes Nexus/test-universe initialization; 30s is below observed cold-start latency. */
+export const DEFAULT_TUI_TEST_READY_TIMEOUT_MS = 180_000;
+
 export interface ElanousTuiSpawnOptions {
   readonly repoRoot: string;
   readonly cwd: string;

package/src/self-implement/fixtures/tdd-green-missing-passing-child-transcript.txt

@@ -0,0 +1,2 @@
+⏺ Bash({\"command\":\"bun test -- 'src/ux-sim/service-key-setup.test.ts'\",\"timeout\":120000,\"sandbox\":\"off\",\"network\":\"inherit\"})
+     ↳ bun test v1.4.2 (744846f84) --- stderr --- 2 pass 0 fail 32 expect() calls Ran 2 tests across 1 file. [1099.00ms]

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

@@ -52,6 +52,7 @@ export interface GateArtifactRun {
 export interface GateArtifactShard {
   shardId: string;
   attempt: number;
+  elapsedMs?: number;
   files: string[];
   current: GateArtifactRun;
   baseline: GateArtifactRun;
@@ -210,7 +211,7 @@ export function writeGateArtifacts(input: GateArtifactInput): { summaryPath: str
       return run;
     };
     shardsDetail.push({
-      shardId: attempt.shardId, attempt: attempt.attempt, files, current: side('current'), baseline: side('baseline'),
+      shardId: attempt.shardId, attempt: attempt.attempt, ...(attempt.elapsedMs !== undefined ? { elapsedMs: attempt.elapsedMs } : {}), files, current: side('current'), baseline: side('baseline'),
       ...(input.sharded?.unmeasuredByShard?.[attempt.shardId] !== undefined
         && attempt === input.sharded.attempts.filter((item) => item.shardId === attempt.shardId).at(-1)
         ? { unmeasuredReason: input.sharded.unmeasuredByShard[attempt.shardId] } : {}),

package/src/self-implement/goal-author-cli.ts

@@ -19,6 +19,7 @@ import {
   type GoalAuthorDeps,
   type GoalAuthorGradeSelection,
   resolveGoalAuthorGrade,
+  resolveGoalAuthorReviewerPrecheckEnabled,
   type GoalType,
   type GoalFileLintFinding,
 } from './goal-author.js';
@@ -292,9 +293,10 @@ export async function runGoalAuthorCli(
     ? { passed: false }
     : { passed: true, titleChars: proseTitle.length });
   const gradeDeps = authorGrade.grade === 'lite' || opts.authorGrade ? { authorGrade } : {};
+  const reviewerPrecheckDeps = { reviewerPrecheckEnabled: resolveGoalAuthorReviewerPrecheckEnabled() };
   const authorDeps: Partial<GoalAuthorDeps> = parentGoalFile && parentQuestionId
-    ? { parent: { goalFile: parentGoalFile, questionId: parentQuestionId }, parentDocument, clarificationAnswers, ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps }
-    : { ...(clarificationAnswers && { clarificationAnswers }), ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps };
+    ? { parent: { goalFile: parentGoalFile, questionId: parentQuestionId }, parentDocument, clarificationAnswers, ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...reviewerPrecheckDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps }
+    : { ...(clarificationAnswers && { clarificationAnswers }), ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...reviewerPrecheckDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps };
   const write = deps.write ?? writeAuthoredGoal;
   const result = opts.groundingCwd === undefined
     ? await write(ask, opts.cwd, authorDeps, superseded ? { supersedes: superseded } : undefined)