elanous 0.2.19 → 0.2.21

package/src/self-implement/stop-autoheal.ts

@@ -0,0 +1,204 @@
+/**
+ * STOP-AUTOHEAL (0.2.20 P0 · 첫 조각) — 멈춘 런의 stop 레코드(STOP-RECORD #24907)를 읽고
+ * 갈래마다 «한 번»만 스스로 고쳐 본다. 안 되면 `needs-owner` 로 사람에게 넘긴다.
+ *
+ * S: 런이 멈추면 원장에 `event='stop'` 한 줄(class·cause·evidenceRef·nextMove)이 남는다.
+ * C: 그 줄을 읽는 쪽이 없어서 환경 결손·main 동기화·Pod 사망·증거 누락처럼 «기계가 고칠 수 있는» 멈춤도 사람을 기다렸다.
+ * Q: 갈래별로 한 수를 정해 두고 «한 번만» 시도할 수 있나?
+ * A: `autohealFromStop` 하나가 class → action 을 고르고, 원장 `event='autoheal'` 줄로 시도를 남긴다.
+ *    같은 런·같은 갈래·같은 모드에 이미 줄이 있으면 다시 하지 않는다(원장 가드).
+ *
+ * 사다리(class → action):
+ *   env-unrelated      → clean-workspace-regate   깨끗한 자리에서 gate 만 다시 1회(GATE-ENV-RETRY 재사용 자리)
+ *   main-sync          → rebase-regate            리베이스(MERGE-INTENT-RESOLVE 의도 해석) 뒤 재게이트
+ *   pod-died           → resume-from-salvage      `salvage/run-<6hex>/<leaf>` 가지에서 resume(DRAFT-NOT-ARCHIVE)
+ *   evidence-uncovered → derive-evidence-rejudge  런 출력·시험·배선에서 증거를 끌어내 1회 재판정
+ *   review-repeat · review-out-of-scope · fabric · launch-failed · unclassified → needs-owner(새 라운드 없음)
+ *
+ * 모드 `tools.selfImplement.autoheal.mode` = `shadow`(기본: 할 일을 원장에만 적고 손대지 않는다) | `live`.
+ * ⛔ live 에서도 행동은 주입 seam 으로만 한다 — seam 이 없는 행동은 `needs-owner`(action-unwired)로 떨어진다.
+ *    «안 이어진 손»을 「고쳤다」로 읽지 않게.
+ * 관측 = `debug.log('self-implement.autoheal', …)` ⊕ 원장 `event='autoheal'`.
+ */
+import { debug } from '../debug/log.js';
+import { appendRunLedgerEntry, loadRunLedger, type RunLedgerEntry, type RunLedgerWriter } from './run-ledger.js';
+import type { RunStopClass, RunStopRecord } from './run-stop.js';
+
+export const AUTOHEAL_EVENT = 'autoheal';
+export type AutohealMode = 'shadow' | 'live';
+export const DEFAULT_AUTOHEAL_MODE: AutohealMode = 'shadow';
+
+export type AutohealAction =
+  | 'clean-workspace-regate'
+  | 'rebase-regate'
+  | 'resume-from-salvage'
+  | 'derive-evidence-rejudge'
+  | 'needs-owner';
+
+/** 닫힌 목록 전체를 덮는다 — 새 class 가 생기면 여기서 타입 오류가 난다. */
+export const AUTOHEAL_ACTION_BY_CLASS: Readonly<Record<RunStopClass, AutohealAction>> = {
+  'env-unrelated': 'clean-workspace-regate',
+  'main-sync': 'rebase-regate',
+  'pod-died': 'resume-from-salvage',
+  'evidence-uncovered': 'derive-evidence-rejudge',
+  'review-repeat': 'needs-owner',
+  'review-out-of-scope': 'needs-owner',
+  fabric: 'needs-owner',
+  'launch-failed': 'needs-owner',
+  unclassified: 'needs-owner',
+};
+
+/** 설정 원값 → 모드. 모르는 값은 «좁은 쪽»(shadow). */
+export function parseAutohealMode(raw: unknown): AutohealMode {
+  return raw === 'live' ? 'live' : 'shadow';
+}
+
+export interface AutohealContext {
+  runId: string;
+  goalId?: string;
+  record: RunStopRecord;
+}
+
+export interface AutohealActionResult {
+  ok: boolean;
+  /** 한 줄 — 무엇을 했나/왜 못 했나. */
+  detail?: string;
+}
+
+export type AutohealActionFn = (ctx: AutohealContext) => Promise<AutohealActionResult> | AutohealActionResult;
+
+/** 행동 seam — needs-owner 를 뺀 넷. 없는 seam 은 live 에서도 실행하지 않는다. */
+export type AutohealActions = Partial<Record<Exclude<AutohealAction, 'needs-owner'>, AutohealActionFn>>;
+
+export type AutohealOutcome =
+  /** shadow — 할 일을 적기만 했다. */
+  | 'would-act'
+  /** live — 행동을 했고 성공했다. */
+  | 'healed'
+  /** 사람에게 넘긴다(갈래가 needs-owner 이거나 행동이 실패·미배선). */
+  | 'needs-owner'
+  /** 같은 런·갈래·모드에 이미 시도가 있다 — 아무것도 안 했다(원장에 새 줄도 안 쓴다). */
+  | 'already-attempted';
+
+export interface AutohealResult {
+  runId: string;
+  class: RunStopClass;
+  action: AutohealAction;
+  mode: AutohealMode;
+  outcome: AutohealOutcome;
+  /** needs-owner 일 때 사람이 볼 이유(멈춘 원인 그대로 또는 행동 실패). */
+  reason?: string;
+  detail?: string;
+  entry?: RunLedgerEntry;
+}
+
+export interface AutohealDeps {
+  mode?: AutohealMode;
+  actions?: AutohealActions;
+  /** 가드용 원장 읽기 — 기본 `loadRunLedger(runId)`. null = 원장 없음(첫 시도). */
+  loadLedger?: (runId: string) => readonly RunLedgerEntry[] | null;
+  writeLedger?: RunLedgerWriter;
+}
+
+/**
+ * 이 프로세스가 쓴 autoheal 줄 — 원장 읽기가 주입 writer 와 다른 곳을 보거나(시험 seam) 비어 있어도
+ * 같은 프로세스 안에서는 «한 번»이 지켜지게 한다(리뷰 must-fix #24912).
+ */
+const writtenThisProcess = new Map<string, RunLedgerEntry[]>();
+const WRITTEN_MAX_RUNS = 4096;
+
+/** 시험용 — 프로세스 기억을 비운다. */
+export function resetAutohealProcessMemory(): void {
+  writtenThisProcess.clear();
+}
+
+/** 원장 가드 — 같은 런·같은 갈래·같은 모드의 autoheal 줄이 있으면 참. */
+export function autohealAlreadyAttempted(ledger: readonly RunLedgerEntry[] | null, cls: RunStopClass, mode: AutohealMode): boolean {
+  if (!ledger) return false;
+  return ledger.some((e) => e.event === AUTOHEAL_EVENT && e.data?.class === cls && e.data?.mode === mode);
+}
+
+function observe(event: string, data: Record<string, unknown>): void {
+  try { debug.log('self-implement.autoheal', event, data); } catch { /* observation is fail-soft */ }
+}
+
+/**
+ * stop 레코드 하나 → 최대 한 번의 힐 시도. 예외를 던지지 않는다(행동 seam 의 throw 도 needs-owner 로 접는다).
+ */
+export async function autohealFromStop(ctx: AutohealContext, deps: AutohealDeps = {}): Promise<AutohealResult> {
+  const mode = deps.mode ?? DEFAULT_AUTOHEAL_MODE;
+  const cls = ctx.record.class;
+  const action = AUTOHEAL_ACTION_BY_CLASS[cls] ?? 'needs-owner';
+  const base = { runId: ctx.runId, class: cls, action, mode };
+
+  let ledger: readonly RunLedgerEntry[] | null = null;
+  try {
+    ledger = (deps.loadLedger ?? ((id) => loadRunLedger(id)))(ctx.runId);
+  } catch (error) {
+    // ⛔ 가드를 못 읽으면 «한 번»을 보장할 수 없다 — live 행동을 하지 않고 사람에게 넘긴다.
+    const reason = `ledger-unreadable: ${error instanceof Error ? error.message : String(error)}`;
+    observe('guard-unreadable', { ...base, reason });
+    return { ...base, outcome: 'needs-owner', reason };
+  }
+  if (autohealAlreadyAttempted(ledger, cls, mode) || autohealAlreadyAttempted(writtenThisProcess.get(ctx.runId) ?? null, cls, mode)) {
+    observe('already-attempted', base);
+    return { ...base, outcome: 'already-attempted' };
+  }
+
+  let outcome: AutohealOutcome;
+  let reason: string | undefined;
+  let detail: string | undefined;
+  if (action === 'needs-owner') {
+    outcome = 'needs-owner';
+    reason = `stop ${cls}: ${ctx.record.cause}`;
+  } else if (mode === 'shadow') {
+    outcome = 'would-act';
+  } else {
+    const fn = deps.actions?.[action];
+    if (!fn) {
+      outcome = 'needs-owner';
+      reason = `action-unwired: ${action} (stop ${cls}: ${ctx.record.cause})`;
+    } else {
+      // ⭐ 시도 «전»에 원장 줄을 쓴다 — 행동 중 프로세스가 죽어도 두 번째 시도가 막힌다.
+      //    ⛔ 그 줄을 못 쓰면 «한 번»을 보장할 수 없으니 행동하지 않는다.
+      if (!writeEntry(ctx, deps, { ...base, phase: 'attempt' })) {
+        const unguarded = `guard-write-failed: ${action} not attempted (stop ${cls}: ${ctx.record.cause})`;
+        observe('needs-owner', { ...base, reason: unguarded });
+        return { ...base, outcome: 'needs-owner', reason: unguarded };
+      }
+      try {
+        const res = await fn(ctx);
+        detail = res.detail;
+        outcome = res.ok ? 'healed' : 'needs-owner';
+        if (!res.ok) reason = `${action} failed${res.detail ? `: ${res.detail}` : ''}`;
+      } catch (error) {
+        outcome = 'needs-owner';
+        reason = `${action} threw: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+  }
+
+  const entry = writeEntry(ctx, deps, {
+    ...base, phase: 'result', outcome,
+    ...(reason ? { reason } : {}), ...(detail ? { detail } : {}),
+    evidenceRef: ctx.record.evidenceRef, nextMove: ctx.record.nextMove,
+  });
+  observe(outcome, { ...base, ...(reason ? { reason } : {}), ...(detail ? { detail } : {}) });
+  return { ...base, outcome, ...(reason ? { reason } : {}), ...(detail ? { detail } : {}), ...(entry ? { entry } : {}) };
+}
+
+function writeEntry(ctx: AutohealContext, deps: AutohealDeps, data: Record<string, unknown>): RunLedgerEntry | undefined {
+  const entry: RunLedgerEntry = {
+    timestamp: new Date().toISOString(), runId: ctx.runId, event: AUTOHEAL_EVENT, data,
+    ...(ctx.goalId ? { goalId: ctx.goalId } : {}),
+  };
+  try {
+    (deps.writeLedger ?? appendRunLedgerEntry)(entry);
+    if (!writtenThisProcess.has(ctx.runId) && writtenThisProcess.size >= WRITTEN_MAX_RUNS) writtenThisProcess.clear();
+    writtenThisProcess.set(ctx.runId, [...(writtenThisProcess.get(ctx.runId) ?? []), entry]);
+    return entry;
+  } catch (error) {
+    observe('ledger-write-failed', { runId: ctx.runId, error: error instanceof Error ? error.message : String(error) });
+    return undefined;
+  }
+}

package/src/session-runtime/index.ts

@@ -162,6 +162,8 @@ export interface SessionPostureSnapshot {
 
 export interface SessionRuntimeDispatchDeps {
   signal?: AbortSignal;
+  /** Current LLM tool call, for correlating a foreground harness stop target with the TUI call. */
+  toolCallId?: string;
   userText?: string;
   modelFamily?: ModelFamily;
   /** Parent Agent capability context for an inline runtime fallback. */
@@ -183,7 +185,7 @@ export interface SessionRuntimeDispatchDeps {
   // scheduler-retirement R1 의 LLM tool unwire 후 모두 no-op stub 였고
   // 본 PR 에서 정식 폐기.
   getToolRuntime(name: string): ToolRuntime<Record<string, unknown>, ToolRunResult> | undefined;
-  dispatchToolRuntime(name: string, args: Record<string, unknown>): Promise<unknown>;
+  dispatchToolRuntime(name: string, args: Record<string, unknown>, toolCallId?: string): Promise<unknown>;
   dispatchPluginTool(name: string, args: Record<string, unknown>): Promise<
     { ok: true; result: unknown } | { ok: false; error: string }
   >;
@@ -2166,7 +2168,7 @@ export async function dispatchSessionRuntimeTool(
   //    registered runtimes) and drops `pathPolicy` on the floor.
   const nativeRuntime = nativeRule?.preferRuntime ? deps.getToolRuntime(name) : undefined;
   if (nativeRuntime) {
-    const result = await deps.dispatchToolRuntime(name, normalizedArgs);
+    const result = await deps.dispatchToolRuntime(name, normalizedArgs, deps.toolCallId);
     rememberCandidateListingResult(name, normalizedArgs, result, scopedAnalysis, deps.searchPlannerState);
     return result;
   }
@@ -2201,7 +2203,7 @@ export async function dispatchSessionRuntimeTool(
   if (rt) {
     const isPtyTool = name.startsWith('PtyShell') || name.startsWith('pty_shell');
     if (!isPtyTool || deps.ptyDashboardOn) {
-      const result = await deps.dispatchToolRuntime(name, normalizedArgs);
+      const result = await deps.dispatchToolRuntime(name, normalizedArgs, deps.toolCallId);
       rememberCandidateListingResult(name, normalizedArgs, result, scopedAnalysis, deps.searchPlannerState);
       return result;
     }

package/src/shell-env-bootstrap.ts

@@ -55,6 +55,11 @@ import { basename } from 'node:path';
 import { debug } from './debug/log.js';
 
 const TIMEOUT_MS = 3000;
+// An interactive shell (`-i`) ignores SIGTERM, so the default timeout signal never ends it: the
+// capture then blocks until the rc files finish. 10-08 TUI-BOOT-60: a stale pyenv rehash lock made
+// every `zsh -l -i` wait 60 s, and the «3 s» capture held the TUI boot for ~65 s. SIGKILL makes the
+// timeout real.
+const TIMEOUT_SIGNAL = 'SIGKILL' as const;
 const POSIX_SHELLS = new Set(['zsh', 'bash', 'fish', 'sh', 'dash', 'ksh']);
 
 let cached: Record<string, string> | null = null;
@@ -126,6 +131,7 @@ export function runPrintenvCapture(): Record<string, string> | null {
       env: seedEnv,
       encoding: 'utf8',
       timeout: TIMEOUT_MS,
+      killSignal: TIMEOUT_SIGNAL,
       stdio: ['ignore', 'pipe', 'pipe'],
       // Don't inherit our stdio — rc files that run `clear` or issue
       // OSC sequences would corrupt our TUI output otherwise.
@@ -133,6 +139,8 @@ export function runPrintenvCapture(): Record<string, string> | null {
   } catch {
     return null;
   }
+  // ETIMEDOUT with status 0 = the shell outlived the timeout; never trust a late capture.
+  if (res.error) return null;
   if (res.status !== 0 && res.status !== null) return null;
   if (res.signal) return null;
   return acceptCapture(typeof res.stdout === 'string' ? res.stdout : '');
@@ -149,10 +157,16 @@ export async function warmCapturedEnv(spawn: typeof Bun.spawn = Bun.spawn): Prom
   const start = Date.now();
   try {
     const proc = spawn([seed.shell, '-l', '-i', '-c', 'printenv'], { env: seed.seedEnv as Record<string, string>, stdin: 'ignore', stdout: 'pipe', stderr: 'ignore' });
-    const timer = setTimeout(() => proc.kill(), TIMEOUT_MS);
-    const [out, code] = await Promise.all([new Response(proc.stdout as ReadableStream).text(), proc.exited]);
+    // A grandchild (e.g. a pyenv rehash) can keep the stdout pipe open after the shell is killed,
+    // so the timeout settles the race itself instead of waiting for EOF.
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timedOut = new Promise<null>((resolve) => {
+      timer = setTimeout(() => { proc.kill(TIMEOUT_SIGNAL); resolve(null); }, TIMEOUT_MS);
+    });
+    const finished = Promise.all([new Response(proc.stdout as ReadableStream).text(), proc.exited]);
+    const result = await Promise.race([finished, timedOut]);
     clearTimeout(timer);
-    const parsed = code === 0 ? acceptCapture(out) : null;
+    const parsed = result && result[1] === 0 ? acceptCapture(result[0]) : null;
     if (captured) return cached !== null; // a synchronous capture won the race
     if (!parsed) return false;
     cached = parsed;

package/src/task-agent/board.ts

@@ -56,7 +56,7 @@ function aggregate(node: BoardNode): void {
 }
 
 function cardStatus(card: TaskCard): BoardStatus {
-  if (card.status === 'launch-failed') return 'blocked';
+  if (card.status === 'launch-failed' || card.status === 'failed') return 'blocked';
   return card.greenProposal ? 'done' : 'open';
 }
 

package/src/task-agent/card-evidence.ts

@@ -7,9 +7,15 @@
  * - 관측: `debug.log('task-agent', 'card-pr-bound', {card, runId, pr})`.
  */
 import { existsSync } from 'node:fs';
+import { STOP_CLASS_POD_FAILURE, STOP_CLASS_NO_LAUNCH } from '../task-orchestrator/surfaces/pod-failure-reason.js';
+import { readLaunchBinding } from '../harness/launch-registry.js';
+import { readRunExits, type RunExit } from '../harness/harness-incidents.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
+import { LogStore, logsDbPath } from '../mss/logging/log-store.js';
 import type { RunLedgerEntry } from '../self-implement/run-ledger.js';
 import { cardPrNumber, taskAgentStatePath, updateTaskCard, readTaskCard, type TaskCard } from './task-hand.js';
+import { judgeNextMove } from './judge.js';
 
 const GOAL_ID = /^[a-f0-9]{16}$/;
 const PR_URL = /^https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/(\d+)$/;
@@ -19,7 +25,7 @@ const RUN_ID = /^run-[A-Za-z0-9_-]{4,64}$/;
 export interface CardRunSnapshot {
   host: readonly RunLedgerEntry[] | null;
   children: Readonly<Record<string, readonly RunLedgerEntry[] | null>>;
-  podFinishes?: ReadonlyArray<{ childRunId: string; prUrl: string }>;
+  podFinishes?: ReadonlyArray<{ childRunId: string; prUrl: string; state?: string; childError?: string }>;
   /** 읽기 «실패»(원장·logs) — 부재(null)와 갈린다. 있으면 refresh 가 card-bind-failed 를 남긴다. */
   readErrors?: readonly string[];
 }
@@ -92,11 +98,39 @@ export function bindCardEvidence(card: Pick<TaskCard, 'runId'>, snapshot: CardRu
   return { ledgerFound: true, ...(goalId ? { goalId } : {}), ...(pr ? { pr } : {}), ...(childRunId ? { childRunId } : {}) };
 }
 
+/** DRAFT-NOT-ARCHIVE — 원장의 마지막 `salvaged`(self-implement.draft-not-archive) 줄이 남긴 수확 가지. 없으면 undefined. */
+export function salvageBranchOf(entries: readonly RunLedgerEntry[] | null | undefined): string | undefined {
+  return lastSalvaged(entries)?.branch;
+}
+
+function lastSalvaged(entries: readonly RunLedgerEntry[] | null | undefined): { branch: string; at: number; order: number } | undefined {
+  for (let at = (entries?.length ?? 0) - 1; at >= 0; at--) {
+    const entry = entries![at]!;
+    const branch = entry.event === 'salvaged' ? entry.data?.salvageBranch : undefined;
+    if (typeof branch === 'string' && branch.startsWith('salvage/')) return { branch, at: Date.parse(entry.timestamp ?? ''), order: at };
+  }
+  return undefined;
+}
+
+/** 카드 런(호스트 → 자식 나중 것부터)의 수확 가지. 원장을 못 읽었으면 `readErrors` 로 갈린다(⛔ «없음» 이 아니다). */
+export async function readCardSalvageBranch(card: Pick<TaskCard, 'runId' | 'createdAt'>, deps: CardRunEvidenceDeps = {}): Promise<{ salvageBranch: string | null; readErrors?: readonly string[] }> {
+  if (!card.runId) return { salvageBranch: null };
+  const snapshot = await readCardRunSnapshot(card, { ...deps, podFinishes: () => [] });
+  // 호스트 ⊕ Pod 자식 원장 전체에서 «가장 나중»(타임스탬프) 수확 가지. 시각이 같거나 못 읽으면 호스트가 이긴다.
+  const candidates = [lastSalvaged(snapshot.host), ...podChildRunIds(snapshot.host, card.runId).map((id) => lastSalvaged(snapshot.children[id]))]
+    .filter((row): row is NonNullable<typeof row> => row !== undefined);
+  const latest = candidates.reduce<typeof candidates[number] | undefined>((best, row) => !best || (Number.isFinite(row.at) && (!Number.isFinite(best.at) || row.at > best.at)) ? row : best, undefined);
+  return { salvageBranch: latest?.branch ?? null, ...(snapshot.readErrors?.length ? { readErrors: snapshot.readErrors } : {}) };
+}
+
 /** 원장·logs 읽기(시험 주입). */
 export interface CardRunEvidenceDeps {
   loadLedger?: (runId: string) => RunLedgerEntry[] | null;
-  podFinishes?: (childRunIds: readonly string[], sinceIso: string) => Array<{ childRunId: string; prUrl: string }>;
+  podFinishes?: (childRunIds: readonly string[], sinceIso: string) => Array<{ childRunId: string; prUrl: string; state?: string; childError?: string }>;
   now?: () => Date;
+  launchBound?: (runId: string) => boolean;
+  dispatchPod?: (runId: string, sinceIso: string) => boolean;
+  runExit?: (runId: string) => RunExit | undefined;
 }
 
 async function defaultLoadLedger(): Promise<(runId: string) => RunLedgerEntry[] | null> {
@@ -105,6 +139,12 @@ async function defaultLoadLedger(): Promise<(runId: string) => RunLedgerEntry[]
   // 연합 목록을 못 읽으면 이 우주만 읽되, 여기서 못 찾으면 «없음»이 아니라 실패로 올린다(card-bind-failed).
   let federationFailure: unknown;
   try { dirs = [...new Set([...dirs, ...resolveFederatedRunLedgerDirectories({})])]; } catch (error) { federationFailure = new Error(`federated run-ledger lookup failed: ${error instanceof Error ? error.message : String(error)}`); }
+  // HARNESS-PARENT-ON-MSB1: 원격 부모 런의 원장 거울(`tasks show` 가 ssh 로 당긴다) — 이 우주 ⊕ 연합 «뒤»에만 붙는다.
+  try {
+    const { remoteLedgerMirrorDirs } = await import('./parent-host.js');
+    const { prodInstanceRoot } = await import('../instance/resolve.js');
+    dirs = [...new Set([...dirs, ...remoteLedgerMirrorDirs(prodInstanceRoot())])];
+  } catch { /* 거울이 없으면 종전 그대로 */ }
   return ledgerLoader(dirs, (runId, dir) => loadRunLedger(runId, dir), federationFailure);
 }
 
@@ -120,20 +160,30 @@ export function ledgerLoader(dirs: readonly string[], load: (runId: string, dir:
   };
 }
 
+function defaultDispatchPod(runId: string, sinceIso: string): boolean {
+  const path = logsDbPath();
+  if (!existsSync(path)) return false;
+  const store = LogStore.openReadOnly(path);
+  try {
+    const sinceMs = Date.parse(sinceIso);
+    return store.queryAll({ exactCategories: ['harness.substrate'], events: ['dispatch-pod'], ...(Number.isFinite(sinceMs) ? { sinceMs } : {}) })
+      .some((row) => { try { return (JSON.parse(row.data ?? '{}') as { runId?: string }).runId === runId; } catch { return false; } });
+  } finally { store.close(); }
+}
+
 async function defaultPodFinishes(): Promise<NonNullable<CardRunEvidenceDeps['podFinishes']>> {
-  const { LogStore, logsDbPath } = await import('../mss/logging/log-store.js');
   return (childRunIds, sinceIso) => {
     const path = logsDbPath();
     if (!childRunIds.length || !existsSync(path)) return [];
     const store = LogStore.openReadOnly(path);
     try {
       const wanted = new Set(childRunIds);
-      const rows: Array<{ childRunId: string; prUrl: string }> = [];
+      const rows: Array<{ childRunId: string; prUrl: string; state?: string; childError?: string }> = [];
       const sinceMs = Date.parse(sinceIso);
       for (const row of store.queryAll({ exactCategories: ['self-implement.pod'], events: ['job-finished'], ...(Number.isFinite(sinceMs) ? { sinceMs } : {}) })) {
-        let data: { childRunId?: unknown; prUrl?: unknown } | null = null;
+        let data: { childRunId?: unknown; prUrl?: unknown; state?: unknown; childError?: unknown } | null = null;
         try { data = row.data ? JSON.parse(row.data) : null; } catch { continue; }
-        if (typeof data?.childRunId === 'string' && wanted.has(data.childRunId) && typeof data.prUrl === 'string') rows.push({ childRunId: data.childRunId, prUrl: data.prUrl });
+        if (typeof data?.childRunId === 'string' && wanted.has(data.childRunId)) rows.push({ childRunId: data.childRunId, prUrl: typeof data.prUrl === 'string' ? data.prUrl : '', ...(typeof data.state === 'string' ? { state: data.state } : {}), ...(typeof data.childError === 'string' ? { childError: data.childError } : {}) });
       }
       return rows;
     } finally { store.close(); }
@@ -150,10 +200,9 @@ export async function readCardRunSnapshot(card: Pick<TaskCard, 'runId' | 'create
   const host = safe(card.runId);
   const childIds = podChildRunIds(host, card.runId);
   const children = Object.fromEntries(childIds.map((id) => [id, safe(id)]));
-  let podFinishes: Array<{ childRunId: string; prUrl: string }> = [];
-  const missing = childIds.filter((id) => !children[id] || !lastPr(children[id]!));
-  if (missing.length && (!host || !lastPr(host))) {
-    try { podFinishes = (deps.podFinishes ?? await defaultPodFinishes())(missing, card.createdAt); } catch (error) { readErrors.push(`logs: ${reason(error)}`); }
+  let podFinishes: NonNullable<CardRunSnapshot['podFinishes']> = [];
+  if (childIds.length && (!host || !lastPr(host))) {
+    try { podFinishes = (deps.podFinishes ?? await defaultPodFinishes())(childIds, card.createdAt); } catch (error) { readErrors.push(`logs: ${reason(error)}`); }
   }
   return { host, children, podFinishes, ...(readErrors.length ? { readErrors } : {}) };
 }
@@ -171,6 +220,52 @@ export async function refreshCardRunBinding(cardId: string, statePath = taskAgen
     try { debug.log('task-agent', 'card-bind-failed', { card: cardId, runId: card.runId, errors: snapshot.readErrors }); } catch { /* fail-soft */ }
   }
   const evidence = bindCardEvidence(card, snapshot);
+  if (card.status === 'launched' && !card.pr && !evidence.pr && !snapshot.readErrors?.length) {
+    const rows = [...(snapshot.host ?? []), ...Object.values(snapshot.children).flatMap((entries) => entries ?? [])];
+    let exit: RunExit | undefined;
+    let exitReadFailed = false;
+    try { exit = (deps.runExit ?? ((id) => readRunExits(effectiveInstanceRoot()).find((row) => row.runId === id)))(card.runId); }
+    catch { exitReadFailed = true; }
+    const finished = [...(snapshot.podFinishes ?? [])].reverse().find((item) => item.state === 'failed');
+    const parentTerminal = [...(snapshot.host ?? [])].reverse().find((item) => item.event === 'run-status');
+    const parentFailed = parentTerminal?.data?.runStatus === 'failed';
+    const boundAt = card.history.find((item) => item.event === 'run-bound')?.at;
+    const elapsed = boundAt ? (deps.now ?? (() => new Date()))().getTime() - Date.parse(boundAt) : NaN;
+    const launched = rows.some((entry) => entry.event === 'pod-child-run');
+    let dispatched = false;
+    let dispatchReadFailed = false;
+    try { dispatched = (deps.dispatchPod ?? defaultDispatchPod)(card.runId, boundAt ?? card.createdAt); }
+    catch { dispatchReadFailed = true; }
+    let launchBound = false;
+    let launchReadFailed = false;
+    try { launchBound = (deps.launchBound ?? ((id) => !!readLaunchBinding(id)))(card.runId); }
+    catch { launchReadFailed = true; }
+    const timedOut = !finished && !launched && !dispatched && !dispatchReadFailed && !exit && !exitReadFailed && !launchBound && !launchReadFailed && Number.isFinite(elapsed) && elapsed >= 600_000;
+    const hasPr = !!card.pr || !!evidence.pr;
+    const exitHarvestBranch = exit?.lastLines?.some((line) => /(?:수확할 브랜치: |ELANOUS_POD_SALVAGE )(?:salvage\/|self-impl\/)[^\s]+/.test(line)) ?? false;
+    const ledgerFailure = rows.find((entry) => entry.event === 'run-status' && entry.data?.runStatus === 'failed'
+      && (entry.data?.failureKind === STOP_CLASS_POD_FAILURE || entry.data?.stop_class === STOP_CLASS_POD_FAILURE));
+    const resultFailure = rows.find((entry) => entry.event === 'result-without-error' && entry.data?.ok === false);
+    const noLaunchExit = exit?.reason === STOP_CLASS_NO_LAUNCH && exit.status !== null && exit.status !== 0 && !launched && !dispatched && !dispatchReadFailed;
+    // 발사 근거가 있는 런이 nonzero 로 끝났고 분류기가 pod-failure 나 unknown(원인 미상)을 냈다 = 죽은 런(TA-JUDGE-DEAD-RUN ③ «exit 1 · unknown/pod-failure»).
+    const deadExit = (exit?.reason === STOP_CLASS_POD_FAILURE || exit?.reason === 'unknown') && exit.status !== null && exit.status !== 0;
+    const podFailure = !noLaunchExit && (launched || dispatched) && (parentFailed && (finished || !!ledgerFailure || !!resultFailure) || deadExit)
+      && (finished || ledgerFailure || resultFailure || deadExit);
+    const failure = podFailure ? judgeNextMove({ terminalRun: {
+      kind: STOP_CLASS_POD_FAILURE,
+      reason: finished?.childError || (exit?.status != null ? `exit ${exit.status} · ${exit.reason || STOP_CLASS_POD_FAILURE}` : resultFailure ? 'result-without-error · failed' : finished ? `job-finished failed · ${STOP_CLASS_POD_FAILURE}` : `run-status failed · ${STOP_CLASS_POD_FAILURE}`),
+      hasPr,
+      hasHarvestBranch: exitHarvestBranch || rows.some((entry) => typeof entry.data?.harvestBranch === 'string' && !!entry.data.harvestBranch) || !!salvageBranchOf(rows),
+    } }) : noLaunchExit ? judgeNextMove({ terminalRun: { kind: STOP_CLASS_NO_LAUNCH, reason: `exit ${exit!.status} · ${exit!.reason}`, hasPr, hasHarvestBranch: false } })
+      : timedOut ? judgeNextMove({ terminalRun: { kind: STOP_CLASS_NO_LAUNCH, reason: 'card-run-bound 뒤 10분 동안 Pod 발사 근거 없음', hasPr: false, hasHarvestBranch: false } }) : undefined;
+    if (failure?.reason.startsWith('failed/')) {
+      const at = (deps.now ?? (() => new Date()))().toISOString();
+      const next = updateTaskCard(statePath, cardId, (current) => current?.status === 'launched' && current.runId === card.runId && !current.pr && current.refSource !== 'manual' ? {
+        ...current, status: 'failed', history: [...current.history, { at, event: 'failed', detail: failure.reason, runId: card.runId }],
+      } : undefined);
+      return { card: next, evidence };
+    }
+  }
   // 이미 묶인 PR 이 있으면 «같은» PR(번호 ⊕ 낸 자식)을 다시 찾았을 때만 뒤늦은 골을 채운다.
   const samePr = (current: TaskCard) => current.pr === undefined
     || (evidence.pr !== undefined && cardPrNumber(current) === evidence.pr.number && current.runChildId === evidence.childRunId);

package/src/task-agent/judge.ts

@@ -4,6 +4,7 @@
  * RFC-task-agent-any-task-to-completion-2026-10-06 §A2 표를 순수 함수로 옮긴다.
  * 부작용이 없다(발사·리뷰·착지는 실행부 `actions.ts` 의 몫). 수확 원천 = run-c9ad6d6d `chooseTaskAction`.
  */
+import { STOP_CLASS_POD_FAILURE, STOP_CLASS_NO_LAUNCH } from '../task-orchestrator/surfaces/pod-failure-reason.js';
 import type { SupervisorStopReason } from '../self-dev/run-supervisor.js';
 import type { NextActionKind, RetryVariant } from './actions.js';
 import type { CompletionKind } from './task-hand.js';
@@ -33,6 +34,8 @@ export interface TaskJudgeInput {
   completion?: CompletionKind;
   /** code-pr 밖 종류의 확인 증거(`completion-evidence.ts` 판독). 비면 «아직 못 받았다» — 통과로 읽지 않는다. */
   evidence?: { ok: boolean; ref: string };
+  /** Only classified terminal evidence; an absent input preserves the existing stop-reason table. */
+  terminalRun?: { kind: typeof STOP_CLASS_POD_FAILURE | typeof STOP_CLASS_NO_LAUNCH; reason: string; hasPr: boolean; hasHarvestBranch: boolean };
 }
 
 export interface TaskJudgement {
@@ -73,6 +76,10 @@ function base(input: TaskJudgeInput): Omit<TaskJudgement, 'executorKind'> {
   if (input.deliveryEvidence) return input.deliveryEvidence.ok
     ? { move: 'propose-green', stage: 'closing', reason: `전달 근거 확인: ${input.deliveryEvidence.files.join(', ')}` }
     : { move: 'wait', stage: 'waiting', reason: input.deliveryEvidence.reason };
+  if (input.terminalRun && !input.terminalRun.hasPr && !input.terminalRun.hasHarvestBranch) {
+    const disposition = input.terminalRun.kind === STOP_CLASS_POD_FAILURE ? 'needs-owner' : 'needs-relaunch';
+    return { move: 'wait', stage: 'escalated', reason: `failed/${disposition} — ${input.terminalRun.reason.replace(/[\r\n]+/gu, ' ').trim() || input.terminalRun.kind}` };
+  }
   const stop = input.stopReason;
   const kind = input.completion;
   if (kind !== undefined && kind !== 'code-pr') {