elanous 0.2.21 → 0.2.23

package/src/steward/launch.ts

@@ -1,6 +1,8 @@
 import { randomUUID } from 'node:crypto';
 import { closeSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { resolveHqLaunchSeat } from '../hq/seats.js';
 import { debug } from '../debug/log.js';
 import { publishInsideEvent } from '../nexus/api/inside-events.js';
 import { redactSecrets } from '../task-cards/card-store.js';
@@ -42,9 +44,11 @@ export interface LaunchDeps {
   settings: StewardSettings;
   ledger: LaunchLedger;
   /** Injected command boundary; the production adapter runs only argv, never a shell. */
-  command?: (args: string[]) => { exitCode: number; stdout: string; stderr?: string };
-  spawn?: (args: string[], log: string) => { pid: number };
+  command?: (args: string[], seat?: string) => { exitCode: number; stdout: string; stderr?: string };
+  spawn?: (args: string[], log: string, seat?: string) => { pid: number };
   gate?: (goalId: string, budget: BudgetDecision | 'unknown') => PreLaunchGateDecision;
+  /** Production commands run from the registered OP view; tests can supply an isolated view. */
+  launchSeat?: () => string;
 }
 
 const RUN_ID = /\brun-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i;
@@ -52,7 +56,7 @@ const DEFAULT_POOL = 'pool-node-b@node-b:8';
 // `harness budget --json` outcomes: proceed | next-provider | wait-reset | stop. next-provider still runs (the harness switches provider itself).
 const BUDGET_PROCEED: readonly string[] = ['proceed', 'next-provider'];
 const launchMode = (settings: StewardSettings): 'off' | 'shadow' | 'live' => launchModeOf(settings.mode ?? settings.launch ?? 'shadow');
-const cli = (args: string[]) => ['bun', 'bin/elanous.mjs', ...(process.env.NODE_ENV === 'test' ? ['--test'] : []), ...args];
+const cli = (args: string[]) => [process.execPath, resolve(import.meta.dir, '../../bin/elanous.mjs'), ...(process.env.NODE_ENV === 'test' ? ['--test'] : []), ...args];
 const sourceOf = (issue: TriageIssue): string => /^출처: (telegram|pwa|tui|cli)$/m.exec(issue.body)?.[1] ?? `linear:${issue.identifier}`;
 const promptOf = (issue: TriageIssue): string => `${issue.title}\n${issue.body.slice(0, 1500)}`;
 const argvFor = (issue: TriageIssue, settings: StewardSettings): string[] =>
@@ -100,15 +104,19 @@ export function planLaunches(rows: ScheduledDecision[], issues: TriageIssue[], l
   return { launches, hitl };
 }
 
-function runCommand(args: string[]): { exitCode: number; stdout: string; stderr: string } {
-  const result = Bun.spawnSync(args, { cwd: resolve(import.meta.dir, '../..'), stdout: 'pipe', stderr: 'pipe' });
+function stewardLaunchSeat(): string {
+  return resolveHqLaunchSeat('OP', getElanousConfigDir());
+}
+
+function runCommand(args: string[], cwd = resolve(import.meta.dir, '../..')): { exitCode: number; stdout: string; stderr: string } {
+  const result = Bun.spawnSync(args, { cwd, stdout: 'pipe', stderr: 'pipe' });
   return { exitCode: result.exitCode, stdout: result.stdout.toString(), stderr: result.stderr.toString() };
 }
 
-function spawnDetached(args: string[], log: string): { pid: number } {
+function spawnDetached(args: string[], log: string, seat = stewardLaunchSeat()): { pid: number } {
   const fd = openSync(log, 'a');
   try {
-    const child = Bun.spawn(args, { cwd: resolve(import.meta.dir, '../..'), stdout: fd, stderr: fd, stdin: 'ignore', detached: true });
+    const child = Bun.spawn(args, { cwd: seat, stdout: fd, stderr: fd, stdin: 'ignore', detached: true });
     child.unref();
     return { pid: child.pid };
   } finally { closeSync(fd); }
@@ -149,9 +157,12 @@ export function launch(item: LaunchItem, deps: LaunchDeps): LaunchEntry {
   // L6: a launch must remain on the isolated Pod pool, never fall back to the host or another substrate.
   if (!/^[a-zA-Z0-9_-]+(?:@[a-zA-Z0-9._-]+(?::[1-9][0-9]*)?)?$/.test(settings.podPool ?? DEFAULT_POOL))
     return blocked('blocked-location', 'invalid steward pod pool');
+  let seat: string;
+  try { seat = (deps.launchSeat ?? stewardLaunchSeat)(); }
+  catch (error) { return blocked('blocked-location', `steward OP seat unavailable: ${String(error)}`); }
   let budget: BudgetDecision | 'unknown' = 'unknown';
   try {
-    const result = command(cli(['harness', 'budget', '--json']));
+    const result = command(cli(['harness', 'budget', '--json']), seat);
     const decision = result.exitCode === 0 ? lastJson(result.stdout) : {};
     if (!BUDGET_PROCEED.includes(String(decision.outcome)))
       return blocked('skipped-budget', result.exitCode === 0 ? JSON.stringify(decision.reasons ?? ['budget unavailable']) : result.stderr ?? 'budget unavailable');
@@ -171,7 +182,7 @@ export function launch(item: LaunchItem, deps: LaunchDeps): LaunchEntry {
   ledger.launches[key] = entry;
   saveLaunchLedger(root, ledger);
   try {
-    entry.pid = (deps.spawn ?? spawnDetached)(argvFor(item.issue, settings), entry.log).pid;
+    entry.pid = (deps.spawn ?? spawnDetached)(argvFor(item.issue, settings), entry.log, seat).pid;
   } catch (error) {
     entry.status = 'failed';
     entry.reason = redactSecrets(String(error));

package/src/steward/triage.ts

@@ -57,9 +57,13 @@ export interface StewardDeps {
   cardStore?: StewardCardDeps['store'];
   warn?: (message: string) => void;
   ask?: StewardAsk;
+  /** Maximum time for each working-backwards wish draft in schedule (milliseconds). */
+  draftItemMs?: number;
   launchSettings?: Pick<StewardSettings, 'mode' | 'launch' | 'maxParallel' | 'podPool'>;
   launchCommand?: LaunchDeps['command'];
   spawnLaunch?: LaunchDeps['spawn'];
+  /** Isolated OP view for tests; production resolves the registered HQ seat (launch.ts stewardLaunchSeat). */
+  launchSeat?: LaunchDeps['launchSeat'];
   launchGate?: LaunchDeps['gate'];
   outcomeNotify?: Pick<OutcomeNotifyDeps, 'document' | 'message' | 'worktreeCommand' | 'loadOrigin' | 'loadOrigins'>;
   /** Internal command boundary: the current sync has already claimed this pid. */
@@ -413,27 +417,42 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       const wishes = rows.filter(row => present.has(row.issue) && row.capability === 'new-capability' && row.rung !== 'hitl');
       const store = wishes.length ? deps.cardStore ?? new CardStore(root) : undefined;
       const invalid = new Set<string>();
+      const carried = new Set<string>();
       if (store) try {
         recordTriageOnCards(wishes, issues, { root, store, now: deps.now });
         for (const wish of wishes) {
-          try { await recordWorkingBackwardsOnCards([wish], issues, store, deps.ask ?? askSteward); }
-          catch (error) {
-            if (!(error instanceof InvalidWorkingBackwardsDraft)) throw error;
-            invalid.add(wish.issue);
-            debug.log('steward.stage', 'draft-invalid', { issue: wish.issue });
-          }
+          const timedOut = Symbol('draft-timeout');
+          let timer: ReturnType<typeof setTimeout> | undefined;
+          const timeout = new Promise<never>((_, reject) => {
+            timer = setTimeout(() => reject(timedOut), deps.draftItemMs ?? 120_000);
+          });
+          // The draft may finish without ever racing this promise (no ask needed) — never leave its rejection unhandled.
+          timeout.catch(() => undefined);
+          try {
+            // Bound the ask itself so a late answer cannot write to a store closed after this tick.
+            const ask: StewardAsk = (prompt, role) => Promise.race([(deps.ask ?? askSteward)(prompt, role), timeout]);
+            await recordWorkingBackwardsOnCards([wish], issues, store, ask);
+          } catch (error) {
+            if (error instanceof InvalidWorkingBackwardsDraft) {
+              invalid.add(wish.issue);
+              debug.log('steward.stage', 'draft-invalid', { issue: wish.issue });
+            } else {
+              carried.add(wish.issue);
+              debug.log('steward.schedule', 'draft-carried', { issue: wish.issue, reason: error === timedOut ? 'timeout' : 'error' });
+            }
+          } finally { if (timer) clearTimeout(timer); }
         }
       } finally { if (!deps.cardStore) store.close(); }
-      if (invalid.size) rows = rows.map(row => invalid.has(row.issue)
+      if (invalid.size || carried.size) rows = rows.map(row => invalid.has(row.issue)
         ? { ...row, rung: 'hitl' as const, disposition: 'hitl' as const, hitlReason: 'other' as const, why: 'working-backwards draft invalid' }
-        : row);
+        : carried.has(row.issue) ? { ...row, deferred: true as const, disposition: 'wait' as const } : row);
     }
     for (const row of rows) try { debug.log('steward.schedule', 'decision', {
       kind: row.disposition, target: row.issue, wouldAct: row.disposition === 'now' && liveLike(settings.mode),
     }); } catch { /* logging must not change the schedule */ }
     writeFileSync(schedule, JSON.stringify(rows));
     const ledger = readLaunchLedger(root);
-    const launchDeps: LaunchDeps = { root, settings, ledger, command: deps.launchCommand, spawn: deps.spawnLaunch, gate: deps.launchGate };
+    const launchDeps: LaunchDeps = { root, settings, ledger, command: deps.launchCommand, spawn: deps.spawnLaunch, gate: deps.launchGate, launchSeat: deps.launchSeat };
     const cardDeps = { root, store: deps.cardStore, now: deps.now };
     collectOutcomes(ledger, launchDeps);
     const plan = planLaunches(rows, issues, ledger, settings);
@@ -493,7 +512,7 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       writeFileSync(path, JSON.stringify(state));
     }
     const ledger = readLaunchLedger(root);
-    const outcomes = collectOutcomes(ledger, { root, settings, ledger, command: deps.launchCommand, spawn: deps.spawnLaunch });
+    const outcomes = collectOutcomes(ledger, { root, settings, ledger, command: deps.launchCommand, spawn: deps.spawnLaunch, launchSeat: deps.launchSeat });
     for (const outcome of outcomes) {
       const issue = issues.find(item => item.identifier === outcome.issue) ??
         { identifier: outcome.issue, title: outcome.title, ref: '', body: '' };

package/src/storage/file-lock.ts

@@ -27,9 +27,13 @@ const STALE_MS = 30_000;
 const RETRY_BUSY_MS = 25;
 const MAX_TRIES = 240; // ~6s upper bound
 
+const SLEEP_CELL = new Int32Array(new SharedArrayBuffer(4));
+
 function busyWaitMs(ms: number): void {
+  // ⭐ A real sleep, not a CPU spin — a waiter may wait minutes (pod image ship lock, 10-08 flood).
+  try { Atomics.wait(SLEEP_CELL, 0, 0, ms); return; }
+  catch { /* Atomics.wait unavailable on this thread · fall back to the spin */ }
   const target = Date.now() + ms;
-  // Trivial busy-loop. Nothing else to do synchronously.
   while (Date.now() < target) { /* spin */ }
 }
 
@@ -37,6 +41,22 @@ export interface LockOpts {
   staleMs?: number;
   retryBusyMs?: number;
   maxTries?: number;
+  /**
+   * Sync lock only: also break the lock when the pid on its first line is a dead process
+   * (a holder killed with -9 must not wedge waiters for `staleMs`).
+   */
+  breakDeadHolder?: boolean;
+  /** Called once, the first time the lock is found held by someone else. */
+  onWait?: (holder: string) => void;
+}
+
+function holderIsDead(lockPath: string): boolean {
+  let pid: number;
+  try { pid = Number.parseInt(readFileSync(lockPath, 'utf8').split(/[\n:]/)[0] ?? '', 10); }
+  catch { return false; }
+  if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
+  try { process.kill(pid, 0); return false; }
+  catch (err) { return (err as NodeJS.ErrnoException).code === 'ESRCH'; }
 }
 
 export type ReleaseLock = () => void;
@@ -45,6 +65,7 @@ export function acquireLockSync(lockPath: string, opts: LockOpts = {}): ReleaseL
   const staleMs = opts.staleMs ?? STALE_MS;
   const retryBusyMs = opts.retryBusyMs ?? RETRY_BUSY_MS;
   const maxTries = opts.maxTries ?? MAX_TRIES;
+  let waited = false;
 
   for (let attempt = 0; attempt < maxTries; attempt += 1) {
     try {
@@ -63,15 +84,23 @@ export function acquireLockSync(lockPath: string, opts: LockOpts = {}): ReleaseL
       if (code !== 'EEXIST') throw err;
       // Lock exists · check for staleness.
       try {
-        const age = Date.now() - statSync(lockPath).mtimeMs;
-        if (age > staleMs) {
-          try { unlinkSync(lockPath); } catch { /* race · retry */ }
+        const seen = statSync(lockPath);
+        const age = Date.now() - seen.mtimeMs;
+        if (age > staleMs || (opts.breakDeadHolder && holderIsDead(lockPath))) {
+          // Narrow the race: only unlink the file we judged (a fresh holder may have replaced it meanwhile).
+          try { if (statSync(lockPath).ino === seen.ino) unlinkSync(lockPath); } catch { /* race · retry */ }
           continue;
         }
       } catch {
         // Race: lock disappeared between EEXIST and stat → retry.
         continue;
       }
+      if (!waited && opts.onWait) {
+        waited = true;
+        let holder = '';
+        try { holder = readFileSync(lockPath, 'utf8').trim(); } catch { /* gone */ }
+        try { opts.onWait(holder); } catch { /* observer only */ }
+      }
       busyWaitMs(retryBusyMs);
     }
   }
@@ -108,6 +137,7 @@ export async function acquireLockAsync(lockPath: string, opts: LockOpts = {}): P
   const heartbeatMs = Math.max(50, Math.floor(staleMs / 3));
   // ⭐ **소유 토큰** — inode 보다 강하다(inode 는 재사용된다). 파일 내용이 곧 소유 증명이다.
   const token = `${process.pid}:${randomUUID()}`;
+  let waited = false;
 
   for (let attempt = 0; attempt < maxTries; attempt += 1) {
     try {
@@ -158,6 +188,12 @@ export async function acquireLockAsync(lockPath: string, opts: LockOpts = {}): P
       } catch {
         continue;
       }
+      if (!waited && opts.onWait) {
+        waited = true;
+        let holder = '';
+        try { holder = readFileSync(lockPath, 'utf8').trim(); } catch { /* gone */ }
+        try { opts.onWait(holder); } catch { /* observer only */ }
+      }
       await new Promise((resolve) => { setTimeout(resolve, retryBusyMs); });
     }
   }

package/src/task-agent/actions.ts

@@ -164,6 +164,10 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
       parsed = item as typeof parsed;
     } catch { return record('failed', 'invalid review JSON'); }
     if (parsed.reviewed !== true) return record('failed', 'review was not performed');
+    // TA-LAND-MUSTFIX-ZERO — «pass» 라도 must-fix 가 남았거나 수를 못 읽으면 land 로 가지 않는다(#25941 `canAuto` 와 같은 축).
+    //   `self review --json` 은 mustFix 배열을 «항상» 싣는다 — 배열이 아니면 «0» 이 아니라 «모름»으로 읽는다(fail-closed).
+    if (parsed.verdict === 'pass' && (!Array.isArray(parsed.mustFix) || !parsed.mustFix.every(fix => typeof fix === 'string'))) return card('review-must-fix-unknown: pass verdict without a readable must-fix list');
+    if (parsed.verdict === 'pass' && parsed.mustFix!.length > 0) return card(`review-warn-with-must-fix: pass verdict carries ${parsed.mustFix!.length} must-fix`);
     if (parsed.verdict === 'pass') { record('done', 'review pass'); return executeNextAction({ ...action, kind: 'land', history: [...(action.history ?? []), 'review pass'] }, deps); }
     if (parsed.verdict === 'fail' && Array.isArray(parsed.mustFix) && parsed.mustFix.length > 0 && parsed.mustFix.every(fix => typeof fix === 'string' && fix.trim())) { record('done', 'review fail'); return executeNextAction({ ...action, kind: 'retry', mustFix: parsed.mustFix, history: [...(action.history ?? []), 'review fail'] }, deps); }
     return card('review verdict or must-fix unavailable');

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

@@ -15,11 +15,13 @@ 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';
+import { judgeNextMove, type TaskJudgeInput } from './judge.js';
+import { remoteParentAlive, type SshRunner } from './parent-host.js';
 
 const GOAL_ID = /^[a-f0-9]{16}$/;
 const PR_URL = /^https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/(\d+)$/;
 const RUN_ID = /^run-[A-Za-z0-9_-]{4,64}$/;
+const LATE_LAUNCH_FAILURE = 'failed/needs-relaunch — card-run-bound 뒤 10분 동안 Pod 발사 근거 없음';
 
 /** 카드 런 하나의 원장 사진 — host = 카드 런 원장(없으면 null) · children = `pod-child-run` 자식 원장 · podFinishes = 호스트 logs. */
 export interface CardRunSnapshot {
@@ -131,6 +133,7 @@ export interface CardRunEvidenceDeps {
   launchBound?: (runId: string) => boolean;
   dispatchPod?: (runId: string, sinceIso: string) => boolean;
   runExit?: (runId: string) => RunExit | undefined;
+  ssh?: SshRunner;
 }
 
 async function defaultLoadLedger(): Promise<(runId: string) => RunLedgerEntry[] | null> {
@@ -212,19 +215,53 @@ export async function readCardRunSnapshot(card: Pick<TaskCard, 'runId' | 'create
  * 찾지 못했으면 쓰지 않는다. 쓴(또는 그대로인) 카드를 돌려준다.
  */
 export async function refreshCardRunBinding(cardId: string, statePath = taskAgentStatePath(), deps: CardRunEvidenceDeps = {}): Promise<{ card: TaskCard | undefined; evidence?: CardRunEvidence }> {
-  const card = readTaskCard(cardId, statePath);
-  // 수동 근거(refSource manual)는 덮지 않는다 · 둘 다 차 있으면 다시 읽지 않는다(한 번만).
-  if (!card?.runId || card.refSource === 'manual' || (card.pr !== undefined && card.goalId !== undefined)) return { card };
+  let card = readTaskCard(cardId, statePath);
+  // 수동 근거(refSource manual)는 덮지 않는다 · 둘 다 차 있으면 다시 읽지 않는다(한 번만) —
+  // 단 «10분 발사 근거 없음»으로 failed 된 카드는 PR·골이 먼저 묶였어도 되살림 판정을 계속 받는다.
+  const awaitingRevival = card?.status === 'failed' && [...card.history].reverse().find((item) => item.event === 'failed')?.detail === LATE_LAUNCH_FAILURE;
+  if (!card?.runId || card.refSource === 'manual' || (card.pr !== undefined && card.goalId !== undefined && !awaitingRevival)) return { card };
+  const runId = card.runId;
   const snapshot = await readCardRunSnapshot(card, deps);
   if (snapshot.readErrors?.length) {
     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) {
+  let revived = false;
+  const lastFailure = [...card.history].reverse().find((item) => item.event === 'failed');
+  if (card.status === 'failed' && lastFailure?.event === 'failed' && lastFailure.detail === LATE_LAUNCH_FAILURE
+    && lastFailure.runId === runId && !snapshot.readErrors?.length) {
+    const afterFailure = (entry: RunLedgerEntry) => entry.runId === runId && Date.parse(entry.timestamp ?? '') > Date.parse(lastFailure.at);
+    const lateChild = (snapshot.host ?? []).some((entry) => entry.event === 'pod-child-run' && afterFailure(entry));
+    const prRows = [...(snapshot.host ?? []), ...Object.values(snapshot.children).flatMap((entries) => entries ?? [])]
+      .filter((entry) => entry.event === 'pr-opened' && entry.data?.number === evidence.pr?.number && (entry.runId === runId || entry.runId === evidence.childRunId));
+    // PR 근거는 원장 `pr-opened`(실패 뒤 시각) 또는 호스트 logs 의 `job-finished`(podFinishes · 시각 없음) — 후자는
+    // `pod-child-run` 자식에게만 붙고, failed 판정은 그 자식이 «없을 때»만 났으므로 지금 보이면 그 자체로 늦은 근거다.
+    const prFromJobFinished = !!evidence.pr && !!evidence.childRunId && prRows.length === 0
+      && (snapshot.podFinishes ?? []).some((row) => row.childRunId === evidence.childRunId && row.prUrl === evidence.pr?.url);
+    const latePr = !!evidence.pr && (prFromJobFinished || prRows.some((entry) => Date.parse(entry.timestamp ?? '') > Date.parse(lastFailure.at)));
+    let lateDispatch = false;
+    try { lateDispatch = (deps.dispatchPod ?? defaultDispatchPod)(runId, new Date(Date.parse(lastFailure.at) + 1).toISOString()); } catch { /* 읽기 실패는 근거가 아니다 */ }
+    if (lateChild || latePr || lateDispatch) {
+      const at = (deps.now ?? (() => new Date()))().toISOString();
+      const next = updateTaskCard(statePath, cardId, (current) => {
+        const failed = [...(current?.history ?? [])].reverse().find((item) => item.event === 'failed');
+        return current?.status === 'failed' && current.runId === runId && current.refSource !== 'manual'
+          && failed?.event === 'failed' && failed.detail === LATE_LAUNCH_FAILURE && failed.runId === runId && failed.at === lastFailure.at
+          ? { ...current, status: 'launched', history: [...current.history, { at, event: 'revived', detail: 'late launch evidence', runId }] } : undefined;
+      });
+      revived = next?.status === 'launched' && next.history.at(-1)?.event === 'revived' && next.history.at(-1)?.at === at;
+      if (revived) {
+        try { debug.log('task-agent', 'card-revived', { card: cardId, runId }); } catch { /* fail-soft */ }
+      }
+      card = next ?? card;
+    }
+  }
+  if (!card) return { card, evidence };
+  if (!revived && 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); }
+    try { exit = (deps.runExit ?? ((id) => readRunExits(effectiveInstanceRoot()).find((row) => row.runId === id)))(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');
@@ -234,13 +271,21 @@ export async function refreshCardRunBinding(cardId: string, statePath = taskAgen
     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); }
+    try { dispatched = (deps.dispatchPod ?? defaultDispatchPod)(runId, boundAt ?? card.createdAt); }
     catch { dispatchReadFailed = true; }
     let launchBound = false;
     let launchReadFailed = false;
-    try { launchBound = (deps.launchBound ?? ((id) => !!readLaunchBinding(id)))(card.runId); }
+    try { launchBound = (deps.launchBound ?? ((id) => !!readLaunchBinding(id)))(runId); }
     catch { launchReadFailed = true; }
-    const timedOut = !finished && !launched && !dispatched && !dispatchReadFailed && !exit && !exitReadFailed && !launchBound && !launchReadFailed && Number.isFinite(elapsed) && elapsed >= 600_000;
+    const missingLaunchTimedOut = !finished && !launched && !dispatched && !dispatchReadFailed && !exit && !exitReadFailed && !launchBound && !launchReadFailed && Number.isFinite(elapsed) && elapsed >= 600_000;
+    let remoteState: ReturnType<typeof remoteParentAlive> | undefined;
+    if (missingLaunchTimedOut && card.parentHost) {
+      remoteState = remoteParentAlive({ ...card.parentHost, runId }, deps.ssh);
+      if (remoteState !== 'dead') {
+        try { debug.log('task-agent', 'card-remote-parent-alive', { card: cardId, runId: card.runId, host: card.parentHost.host, pid: card.parentHost.pid, state: remoteState }); } catch { /* fail-soft */ }
+      }
+    }
+    const timedOut = missingLaunchTimedOut && (!card.parentHost || remoteState === 'dead');
     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'
@@ -251,14 +296,15 @@ export async function refreshCardRunBinding(cardId: string, statePath = taskAgen
     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: {
+    const terminalRun: TaskJudgeInput['terminalRun'] = podFailure ? {
       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/')) {
+    } : noLaunchExit ? { kind: STOP_CLASS_NO_LAUNCH, reason: `exit ${exit!.status} · ${exit!.reason}`, hasPr, hasHarvestBranch: false }
+      : timedOut ? { kind: STOP_CLASS_NO_LAUNCH, reason: 'card-run-bound 뒤 10분 동안 Pod 발사 근거 없음', hasPr: false, hasHarvestBranch: false } : undefined;
+    const failure = judgeNextMove({ terminalRun });
+    if (terminalRun && 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 }],

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

@@ -1,10 +1,10 @@
-import { readFileSync, statSync } from 'node:fs';
+import { readFileSync, realpathSync, statSync } from 'node:fs';
 import { extname, isAbsolute, relative, resolve, sep } from 'node:path';
 import type { Database } from 'bun:sqlite';
 import type { DecisionLedger } from '../decisions/decision-ledger.js';
 import { getLastStatus } from '../domains/schedule-registry.js';
 
-export type CompletionEvidenceKind = 'research-report' | 'artifact' | 'content' | 'ops-action' | 'watch-brief' | 'decision-support';
+export type CompletionEvidenceKind = 'research-report' | 'artifact' | 'content' | 'ops-action' | 'watch-brief' | 'decision-support' | 'deliverable';
 export interface CompletionEvidenceDeps {
   ledger?: Pick<DecisionLedger, 'list'>;
   schedulesDb?: Database;
@@ -13,7 +13,7 @@ export interface CompletionEvidenceDeps {
 /** A missing record is negative evidence; a failed read is explicitly unmeasured. No store is opened or mutated here. */
 export function checkCompletionEvidence(
   kind: CompletionEvidenceKind,
-  input: { dir: string; ref: string },
+  input: { dir: string; ref: string; receipt?: boolean },
   deps: CompletionEvidenceDeps = {},
 ): { ok: boolean; ref: string; missing: string[] } {
   const missing: string[] = [];
@@ -38,6 +38,34 @@ export function checkCompletionEvidence(
   };
 
   switch (kind) {
+    case 'deliverable': {
+      const ref = input.ref.trim();
+      if (/^https?:\/\//i.test(ref)) {
+        try {
+          const url = new URL(ref);
+          if (!url.hostname || !['http:', 'https:'].includes(url.protocol)) add('산출물 링크');
+        } catch { add('산출물 링크'); }
+      } else if (!ref || /^[a-z][a-z\d+.-]*:/i.test(ref)) {
+        add('산출물 경로 또는 링크');
+      } else {
+        const path = pathFor(ref);
+        if (!path) add('못 쟀다: 경로');
+        else {
+          try {
+            const root = realpathSync(input.dir);
+            const actual = realpathSync(path);
+            const rel = relative(root, actual);
+            if (rel === '..' || rel.startsWith(`..${sep}`)) add('못 쟀다: 경로');
+            else {
+              const stat = statSync(actual);
+              if (!stat.isFile() || stat.size === 0) add('산출물 파일');
+            }
+          } catch (error) { add((error as NodeJS.ErrnoException).code === 'ENOENT' ? '산출물 파일' : '못 쟀다: 산출물 파일 읽기'); }
+        }
+      }
+      if (input.receipt !== true) add('수신 확인');
+      break;
+    }
     case 'research-report': {
       const path = file();
       if (!path) break;

package/src/task-agent/cover.ts

@@ -0,0 +1,61 @@
+import type { NextActionKind } from './actions.js';
+
+type CoverVerb = 'land' | 'review' | 'retry' | 'green';
+export interface CoverRow {
+  verb: CoverVerb;
+  /** null means the TASK-AGENT action source could not be fully read. */
+  byTaskAgent: number | null;
+  /** Total work by all seats; null when no independent denominator is available. */
+  total: number | null;
+  /** TASK-AGENT events observed for this verb, including non-done outcomes; null if unreadable. */
+  observedActions: number | null;
+  ratio: number | null;
+  state: 'measured' | 'no-denominator' | 'unreadable';
+  /** Non-shadow action events, including failures; null if the action source is incomplete. */
+  liveActions: number | null;
+  /** Shadow action events; null if the action source is incomplete. */
+  shadowActions: number | null;
+  /** A transition is observable only with an independent denominator and a completed TA action. */
+  stewardTransition: 'observed' | 'not-observed' | 'unmeasured';
+}
+
+/** null means the source could not be read; [] means it was read and had no matching events. */
+export interface TaskAgentCoverInput {
+  taskAgentActions: readonly { kind: NextActionKind; result: string }[] | null;
+  allLands: readonly { step: string; ok: boolean }[] | null;
+  /** A source reached the query safety limit; its aggregate is not known to be complete. */
+  truncated?: { taskAgentActions: boolean; allLands: boolean };
+}
+
+/** Only land has an independent denominator. The other three verbs have no hand-work source yet. */
+export function measureTaskAgentCover(input: TaskAgentCoverInput): CoverRow[] {
+  const verbs: CoverVerb[] = ['land', 'review', 'retry', 'green'];
+  return verbs.map((verb) => {
+    const actions = input.taskAgentActions?.filter((action) => action.kind === verb);
+    const actionsUnreadable = actions === undefined || input.truncated?.taskAgentActions === true;
+    const byTaskAgent = actionsUnreadable ? null : actions.filter((action) => action.result === 'done').length;
+    const observedActions = actionsUnreadable ? null : actions.length;
+    const liveActions = actionsUnreadable ? null : actions.filter((action) => action.result !== 'shadow').length;
+    const shadowActions = actionsUnreadable ? null : actions.filter((action) => action.result === 'shadow').length;
+    const counts = { liveActions, shadowActions };
+    if (verb !== 'land') return {
+      verb, byTaskAgent, total: null, observedActions, ratio: null,
+      state: actionsUnreadable ? 'unreadable' : 'no-denominator',
+      ...counts, stewardTransition: 'unmeasured' as const,
+    };
+    const total = input.allLands === null || input.truncated?.allLands
+      ? null : input.allLands.filter((land) => land.step === 'merge' && land.ok === true).length;
+    const state = actionsUnreadable || total === null ? 'unreadable'
+      : total === 0 ? 'no-denominator' : 'measured';
+    const ratio = state === 'measured' && byTaskAgent !== null && total !== null ? byTaskAgent / total : null;
+    return { verb, byTaskAgent, total, observedActions, ratio, state, ...counts,
+      stewardTransition: ratio === null ? 'unmeasured' : byTaskAgent !== null && byTaskAgent > 0 ? 'observed' : 'not-observed',
+    };
+  });
+}
+
+/** A single human-readable line per verb; unknown numbers are never rendered as zero. */
+export function formatTaskAgentCover(row: CoverRow): string {
+  const value = (count: number | null): string => count === null ? '-' : String(count);
+  return `${row.verb}: TA ${value(row.byTaskAgent)}/${value(row.total)} (${row.ratio === null ? '-' : `${(row.ratio * 100).toFixed(1)}%`}) · live ${value(row.liveActions)} · shadow ${value(row.shadowActions)} · steward-transition ${row.stewardTransition}`;
+}

package/src/task-agent/judge.ts

@@ -76,9 +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}` };
+  if (input.terminalRun && !input.terminalRun.hasPr && !input.terminalRun.hasHarvestBranch && !input.pr) {
+    const disposition = input.terminalRun.kind === STOP_CLASS_POD_FAILURE ? 'needs-owner'
+      : input.terminalRun.kind === STOP_CLASS_NO_LAUNCH ? 'needs-relaunch' : undefined;
+    if (disposition) 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;