elanous 0.2.19 → 0.2.20

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/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> {
@@ -120,20 +154,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 +194,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 +214,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') {

package/src/task-agent/live-moves.ts

@@ -8,8 +8,11 @@
  * - 관측: 실행한 수마다 `debug.log('task-agent', 'live-move', {kind, card, ok, detail, live:true})`.
  */
 import { spawn, spawnSync } from 'node:child_process';
-import { resolve } from 'node:path';
+import { statSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
+import { findGitDir } from '../git-fs/locate.js';
+import { getUserConfig } from '../user-config.js';
 import type { DetachedSpawn } from '../cli/tasks-cli.js';
 import { taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
 
@@ -53,22 +56,98 @@ export async function configuredTaskAgentLiveMoves(): Promise<ReadonlySet<TaskAg
 export interface LiveMoveDeps {
   statePath?: string;
   now?: () => Date;
-  /** PR 머리 sha·상태 — 시험은 주입한다. 기본은 `gh pr view`(작업 트리 cwd). */
-  prHead?: (pr: number, cwd?: string) => Promise<{ head: string; state: string } | null>;
+  /** PR 머리 sha·상태(·브랜치·URL) — 시험은 주입한다. 기본은 `gh pr view`(작업 트리 cwd). */
+  prHead?: (pr: number, cwd?: string) => Promise<PrHeadView | null>;
+  /** TA-LIVE-REVIEW-POD — 작업 트리가 없는 런(Pod)의 리뷰 저장소 후보. 기본은 카드 project.target → harness.defaultRepo → 호스트 checkout. */
+  repoCandidates?: (card: TaskCard) => readonly ReviewRepoCandidate[];
   /** 리뷰 요청(떼어 띄운다) — 시험은 반드시 주입한다. */
   requestReview?: (pr: number, intent: string, cwd?: string) => Promise<void>;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
 }
 
 /** `executed` = 부작용을 실제로 냈다(리뷰를 띄웠다 · 제안을 적었다). ok 이지만 이미 한 수(같은 머리·이미 제안)면 false. */
-export interface LiveMoveResult { kind: TaskAgentLiveMove; card: string | null; ok: boolean; executed: boolean; detail: string }
+export interface LiveMoveResult {
+  kind: TaskAgentLiveMove; card: string | null; ok: boolean; executed: boolean; detail: string;
+  /** TA-LIVE-REVIEW-POD — 작업 트리 없이 리뷰 저장소를 찾았을 때(또는 못 찾았을 때)의 근거 한 줄. */
+  reviewRepo?: { resolved: boolean; source?: ReviewRepoCandidate['source']; cwd?: string; proof?: 'head-sha' | 'branch'; reason: string };
+}
+
+export interface PrHeadView { head: string; state: string; branch?: string; url?: string }
+
+/** 리뷰 저장소 후보 — 과제를 넘길 때 카드가 안 대상 · 하니스 기본 저장소(harness.defaultRepo · harness.repo 의 로컬 뿌리) · 호스트 checkout. */
+export interface ReviewRepoCandidate { source: 'card.project' | 'harness.defaultRepo' | 'host'; cwd: string }
+
+/** 기본 후보 — 존재하는 디렉터리만 · 같은 경로는 한 번. 읽기 실패는 그 후보를 뺀다(없음 ≠ 통과). */
+export function defaultReviewRepoCandidates(card: TaskCard, opts: { defaultRepo?: () => string | undefined; hostRoot?: () => string | undefined } = {}): ReviewRepoCandidate[] {
+  const raw: ReviewRepoCandidate[] = [];
+  if (card.project?.target && isAbsolute(card.project.target)) raw.push({ source: 'card.project', cwd: card.project.target });
+  try {
+    const configured = opts.defaultRepo ? opts.defaultRepo() : getUserConfig().harness?.defaultRepo;
+    if (configured && isAbsolute(configured)) raw.push({ source: 'harness.defaultRepo', cwd: configured });
+  } catch { /* 후보에서 뺀다 */ }
+  try {
+    const host = opts.hostRoot ? opts.hostRoot() : findGitDir(process.cwd())?.root;
+    if (host) raw.push({ source: 'host', cwd: host });
+  } catch { /* 후보에서 뺀다 */ }
+  const seen = new Set<string>();
+  const out: ReviewRepoCandidate[] = [];
+  for (const candidate of raw) {
+    if (!isAbsolute(candidate.cwd)) continue;
+    const cwd = resolve(candidate.cwd);
+    if (seen.has(cwd)) continue;
+    seen.add(cwd);
+    try { if (statSync(cwd).isDirectory()) out.push({ source: candidate.source, cwd }); } catch { /* 없는 디렉터리는 뺀다 */ }
+  }
+  return out;
+}
+
+/**
+ * TA-LIVE-REVIEW-POD — 작업 트리가 없을 때(Pod 런) 리뷰 cwd 를 정한다.
+ * 후보 저장소에서 `gh pr view <pr>` 가 «런이 낸 머리»(기록된 sha · 없으면 런의 브랜치)를 돌려줄 때만 그 저장소를 쓴다 —
+ * «다른 저장소에서 gh·self review 를 돌리지 않는다»(TA-JUDGE-LIVE-SAFE)는 계약을 지킨다. 못 정하면 이유 한 줄.
+ */
+export async function resolveReviewRepo(
+  card: TaskCard, pr: number,
+  produced: { headCommit?: string; branch?: string; prUrl?: string } | undefined,
+  deps: LiveMoveDeps = {},
+): Promise<{ resolved: true; cwd: string; source: ReviewRepoCandidate['source']; proof: 'head-sha' | 'branch'; view: PrHeadView; reason: string } | { resolved: false; reason: string }> {
+  // 호출자가 런 근거를 «안 넘긴» 것과 런이 «기록하지 않은» 것은 다른 사실이다 — 섞어 적지 않는다.
+  if (produced === undefined) return { resolved: false, reason: 'caller passed no run evidence (produced) — head/branch not checked' };
+  // 기록된 머리가 «있으면» 그것만 근거다 — 모양이 틀린 sha 를 브랜치로 대체하지 않는다(확인 못 한 머리로 리뷰하지 않게).
+  if (produced?.headCommit !== undefined && !/^[0-9a-f]{40}$/i.test(produced.headCommit)) {
+    return { resolved: false, reason: `run head ${JSON.stringify(produced.headCommit.slice(0, 40))} is not a full commit sha` };
+  }
+  const expectedHead = produced?.headCommit?.toLowerCase();
+  const expectedBranch = produced?.branch?.trim() || undefined;
+  if (!expectedHead && !expectedBranch) return { resolved: false, reason: 'run result carries no PR head or branch to confirm against' };
+  let candidates: readonly ReviewRepoCandidate[];
+  try { candidates = (deps.repoCandidates ?? defaultReviewRepoCandidates)(card); } catch { candidates = []; }
+  if (!candidates.length) return { resolved: false, reason: 'no target repository (card project · harness.defaultRepo · host checkout)' };
+  const sameUrl = (a: string, b: string) => a.trim().replace(/\/+$/, '').toLowerCase() === b.trim().replace(/\/+$/, '').toLowerCase();
+  const misses: string[] = [];
+  for (const candidate of candidates) {
+    let view: PrHeadView | null;
+    try { view = await (deps.prHead ?? defaultPrHead)(pr, candidate.cwd); } catch { view = null; }
+    if (!view) { misses.push(`${candidate.source}: PR #${pr} unreadable`); continue; }
+    if (produced?.prUrl && view.url && !sameUrl(view.url, produced.prUrl)) { misses.push(`${candidate.source}: PR url ${view.url} ≠ run ${produced.prUrl}`); continue; }
+    if (expectedHead) {
+      if (view.head.toLowerCase() !== expectedHead) { misses.push(`${candidate.source}: head ${view.head.slice(0, 12)} ≠ run ${expectedHead.slice(0, 12)}`); continue; }
+      return { resolved: true, cwd: candidate.cwd, source: candidate.source, proof: 'head-sha', view, reason: `${candidate.source} PR #${pr} head matches run` };
+    }
+    if (view.branch !== expectedBranch) { misses.push(`${candidate.source}: branch ${view.branch ?? '?'} ≠ run ${expectedBranch}`); continue; }
+    // 브랜치 근거는 sha 보다 약하다 — 같은 PR(저장소 · 번호)임을 URL 로 «양쪽 다» 확인할 때만 쓴다.
+    if (!produced?.prUrl || !view.url) { misses.push(`${candidate.source}: branch matches but PR url unconfirmed (run ${produced?.prUrl ?? 'none'} · repo ${view.url ?? 'none'})`); continue; }
+    return { resolved: true, cwd: candidate.cwd, source: candidate.source, proof: 'branch', view, reason: `${candidate.source} PR #${pr} head branch matches run` };
+  }
+  return { resolved: false, reason: misses.join(' · ') };
+}
 
 /** 받은 환경 그대로 먼저 묻고, 실패하면 프록시만 뺀 환경으로 한 번 더(이 저장소의 gh 운영 관행 — 프록시 경유가 gh 를 깨는 호스트). */
 export type GhRun = (args: string[], options: { env: NodeJS.ProcessEnv; cwd?: string }) => { status: number | null; stdout: string };
 const runGh: GhRun = (args, options) => spawnSync('gh', args, { encoding: 'utf8', timeout: 30_000, env: options.env, ...(options.cwd ? { cwd: options.cwd } : {}) });
 
-export async function defaultPrHead(pr: number, cwd?: string, gh: GhRun = runGh): Promise<{ head: string; state: string } | null> {
-  const view = (env: NodeJS.ProcessEnv) => gh(['pr', 'view', String(pr), '--json', 'headRefOid,state'], { env, ...(cwd ? { cwd } : {}) });
+export async function defaultPrHead(pr: number, cwd?: string, gh: GhRun = runGh): Promise<PrHeadView | null> {
+  const view = (env: NodeJS.ProcessEnv) => gh(['pr', 'view', String(pr), '--json', 'headRefOid,headRefName,state,url'], { env, ...(cwd ? { cwd } : {}) });
   let out = view(process.env);
   if (out.status !== 0) {
     const noProxy = { ...process.env };
@@ -77,9 +156,13 @@ export async function defaultPrHead(pr: number, cwd?: string, gh: GhRun = runGh)
   }
   if (out.status !== 0) return null;
   try {
-    const value = JSON.parse(out.stdout) as { headRefOid?: unknown; state?: unknown };
+    const value = JSON.parse(out.stdout) as { headRefOid?: unknown; headRefName?: unknown; state?: unknown; url?: unknown };
     return typeof value.headRefOid === 'string' && /^[a-f0-9]{40}$/i.test(value.headRefOid) && typeof value.state === 'string'
-      ? { head: value.headRefOid, state: value.state } : null;
+      ? {
+        head: value.headRefOid, state: value.state,
+        ...(typeof value.headRefName === 'string' && value.headRefName ? { branch: value.headRefName } : {}),
+        ...(typeof value.url === 'string' && value.url ? { url: value.url } : {}),
+      } : null;
   } catch { return null; }
 }
 
@@ -121,16 +204,33 @@ function observe(deps: LiveMoveDeps, result: LiveMoveResult): LiveMoveResult {
  * 다음 틱에 한 번 더 요청될 수 있다(초과는 많아야 한 번 · 리뷰는 읽기 전용이라 착지·재발사로 번지지 않는다).
  */
 /** `review` — PR 머리마다 한 번. 카드에 먼저 적고(잠금 안) 그다음 띄운다 · 띄우기 실패는 카드에 오류로 남기고 같은 머리는 다시 안 띄운다. */
-export async function executeLiveReview(card: TaskCard | undefined, pr: number | undefined, ctx: { runId: string | null; stopReason: string; cwd?: string }, deps: LiveMoveDeps = {}): Promise<LiveMoveResult> {
+export async function executeLiveReview(
+  card: TaskCard | undefined, pr: number | undefined,
+  ctx: { runId: string | null; stopReason: string; cwd?: string; produced?: { headCommit?: string; branch?: string; prUrl?: string } },
+  deps: LiveMoveDeps = {},
+): Promise<LiveMoveResult> {
   const kind = 'review' as const;
   if (!card) return observe(deps, { kind, executed: false, card: null, ok: false, detail: 'no task card — stays shadow' });
   if (!pr || !Number.isSafeInteger(pr) || pr < 1) return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: 'no PR — stays shadow' });
-  // PR 의 저장소(그 PR 을 낸 결과의 작업 트리)를 모르면 보류한다 — 다른 저장소에서 gh·self review 를 돌리지 않게.
-  if (!ctx.cwd) return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} worktree unknown — stays shadow` });
-  let head: { head: string; state: string } | null;
-  try { head = await (deps.prHead ?? defaultPrHead)(pr, ctx.cwd); } catch { head = null; }
-  if (!head) return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} head unknown` });
-  if (head.state !== 'OPEN') return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} is ${head.state}` });
+  // PR 의 저장소를 모르면 보류한다 — 다른 저장소에서 gh·self review 를 돌리지 않게. 작업 트리가 없으면(Pod 런 ·
+  // TA-LIVE-REVIEW-POD) 후보 저장소 중 «런이 낸 PR 머리»가 확인되는 곳만 쓰고, 못 정하면 이유 한 줄을 관측에 싣는다.
+  let cwd = ctx.cwd;
+  let head: PrHeadView | null = null;
+  let reviewRepo: LiveMoveResult['reviewRepo'];
+  if (!cwd) {
+    const found = await resolveReviewRepo(card, pr, ctx.produced, deps);
+    if (!found.resolved) {
+      return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} worktree unknown — stays shadow`, reviewRepo: { resolved: false, reason: found.reason } });
+    }
+    cwd = found.cwd;
+    head = found.view;
+    reviewRepo = { resolved: true, source: found.source, cwd: found.cwd, proof: found.proof, reason: found.reason };
+  } else {
+    try { head = await (deps.prHead ?? defaultPrHead)(pr, cwd); } catch { head = null; }
+  }
+  const withRepo = (result: LiveMoveResult): LiveMoveResult => reviewRepo ? { ...result, reviewRepo } : result;
+  if (!head) return observe(deps, withRepo({ kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} head unknown` }));
+  if (head.state !== 'OPEN') return observe(deps, withRepo({ kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} is ${head.state}` }));
   const path = deps.statePath ?? taskAgentStatePath();
   const at = (deps.now ?? (() => new Date()))().toISOString();
   const claim = { claimed: false, missing: false };
@@ -141,18 +241,18 @@ export async function executeLiveReview(card: TaskCard | undefined, pr: number |
     claim.claimed = true;
     return { ...current, reviewRequests: [...(current.reviewRequests ?? []), { pr, head: head!.head, at }] };
   });
-  if (claim.missing) return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: 'task card not in state file' });
-  if (!claim.claimed) return observe(deps, { kind, executed: false, card: card.id, ok: true, detail: `already requested for #${pr} head ${head.head.slice(0, 12)}` });
+  if (claim.missing) return observe(deps, withRepo({ kind, executed: false, card: card.id, ok: false, detail: 'task card not in state file' }));
+  if (!claim.claimed) return observe(deps, withRepo({ kind, executed: false, card: card.id, ok: true, detail: `already requested for #${pr} head ${head.head.slice(0, 12)}` }));
   try {
-    await (deps.requestReview ?? defaultRequestReview)(pr, liveReviewIntent(card, ctx.runId, ctx.stopReason), ctx.cwd);
+    await (deps.requestReview ?? defaultRequestReview)(pr, liveReviewIntent(card, ctx.runId, ctx.stopReason), cwd);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     updateTaskCard(path, card.id, (current) => current?.reviewRequests?.some((entry) => entry.pr === pr && entry.head === head!.head && entry.at === at)
       ? { ...current, reviewRequests: current.reviewRequests.map((entry) => entry.pr === pr && entry.head === head!.head && entry.at === at ? { ...entry, error: reason } : entry) }
       : undefined);
-    return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: `review request failed for #${pr} head ${head.head.slice(0, 12)}: ${reason}` });
+    return observe(deps, withRepo({ kind, executed: false, card: card.id, ok: false, detail: `review request failed for #${pr} head ${head.head.slice(0, 12)}: ${reason}` }));
   }
-  return observe(deps, { kind, executed: true, card: card.id, ok: true, detail: `review requested for #${pr} head ${head.head.slice(0, 12)}` });
+  return observe(deps, withRepo({ kind, executed: true, card: card.id, ok: true, detail: `review requested for #${pr} head ${head.head.slice(0, 12)}` }));
 }
 
 /** `propose-green` — 비지 않은 근거가 있을 때만 카드에 제안을 적는다(한 번). 체크리스트는 쓰지 않는다. */

package/src/task-agent/mission.ts

@@ -296,7 +296,7 @@ export function recordPieceRef(pieceId: string, ref: { pr?: number; goalId?: str
 
 /** 이미 넘긴 조각인가 — live 는 live 넘김·발사·발사 실패면 다시 안 넘긴다 · shadow 는 어떤 넘김이든 있으면 안 넘긴다. */
 function alreadyHanded(card: TaskCard, mode: 'shadow' | 'live'): boolean {
-  if (card.status === 'launched' || card.status === 'launch-failed') return true;
+  if (card.status === 'launched' || card.status === 'launch-failed' || card.status === 'failed') return true;
   if (!card.handed) return false;
   return mode === 'shadow' || card.handed.mode === 'live';
 }

package/src/task-agent/shadow.ts

@@ -227,7 +227,16 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   if (live) {
     if (liveKind === 'review') {
       liveMove = await executeLiveReview(boundCard, prResult?.prNumber,
-        { runId: input.runId, stopReason: input.stopReason, ...(prResult?.worktreePath ? { cwd: prResult.worktreePath } : {}) }, { ...(deps.log ? { log: deps.log } : {}), ...deps.live });
+        {
+          runId: input.runId, stopReason: input.stopReason,
+          ...(prResult?.worktreePath ? { cwd: prResult.worktreePath } : {}),
+          // TA-LIVE-REVIEW-POD — 작업 트리가 없는 런(Pod)은 «런이 낸 머리»로 리뷰 저장소를 확인한다.
+          ...(prResult && !prResult.worktreePath ? { produced: {
+            ...(prResult.checkedHeadCommit !== undefined ? { headCommit: prResult.checkedHeadCommit } : {}),
+            ...(prResult.branch ? { branch: prResult.branch } : {}),
+            ...(prResult.prUrl ? { prUrl: prResult.prUrl } : {}),
+          } } : {}),
+        }, { ...(deps.log ? { log: deps.log } : {}), ...deps.live });
     } else {
       const evidence: Record<string, string> = {};
       if (boundCard && !delivery && judgeInput.prState === 'MERGED' && prResult) evidence[boundCard.id] = `#${prResult.prNumber}`;