elanous 0.2.22 → 0.2.24

package/src/storage/file-lock.ts

@@ -46,7 +46,7 @@ export interface LockOpts {
    * (a holder killed with -9 must not wedge waiters for `staleMs`).
    */
   breakDeadHolder?: boolean;
-  /** Sync lock only: called once, the first time the lock is found held by someone else. */
+  /** Called once, the first time the lock is found held by someone else. */
   onWait?: (holder: string) => void;
 }
 
@@ -137,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 {
@@ -187,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

@@ -1,7 +1,7 @@
 import { copyFileSync, lstatSync, mkdirSync, realpathSync } from 'node:fs';
 import { join, relative, resolve, sep } from 'node:path';
 import { debug } from '../debug/log.js';
-import { judgeNextMove } from './judge.js';
+import { judgeNextMove, retryMoveOf, SAME_MOVE_FAILURE_LIMIT } from './judge.js';
 import { checkCompletionEvidence } from './completion-evidence.js';
 
 export type DeliveryKind = 'research-report' | 'artifact' | 'content';
@@ -65,6 +65,48 @@ export interface ActionDeps {
   /** 실패 한 번을 잠금 안에서 디스크에 더한다(다른 프로세스의 실패를 덮지 않게) · 더한 뒤의 값을 돌려준다. */
   incrementFailure?(key: string): number;
   observe(event: 'task-agent.action', data: { taskId: string; kind: NextActionKind; result: string; reason: string }): void;
+  /** 사다리 R4 — 실제로 할 재발사 수의 허용 목록(`taskAgent.liveMoves` 어휘). 없으면 종전 그대로(재발사에 목록 검사 없음) · 목록에 없는 수는 shadow. */
+  liveMoves?: ReadonlySet<string>;
+  /** 한 판단 회차의 발사 칸 — 호출부가 회차마다 새로 준다. 없으면 회당 상한 없음(종전). 발사를 시도할 때마다 `count` 가 오른다. */
+  retryLaunches?: { count: number };
+  /** mbp 부하 관문(OP 신호 `loadMax`) — 지금 1분 부하가 `loadMax` 이상이거나 못 읽으면 발사하지 않고 shadow. 없으면 관문 없음(종전). */
+  loadGate?: { loadMax: number; load1(): number | null };
+}
+
+/** 재발사는 한 판단 회차에 한 건만 발사한다. */
+export const RETRY_LAUNCHES_PER_CYCLE = 1;
+
+/** live 인데도 shadow 로 내릴 사유 — 없으면 발사해도 된다(재발사 아닌 수는 늘 없다). 기다림(wait)은 발사가 아니라 부하·회당 상한을 보지 않는다. */
+function retryShadowReason(action: NextAction, deps: ActionDeps): string | undefined {
+  if (action.kind !== 'retry') return undefined;
+  const move = retryMoveOf(action.variant);
+  if (deps.liveMoves && !deps.liveMoves.has(move)) return `${move} not in live allow-list`;
+  if (action.variant === 'wait') return undefined;
+  if (deps.loadGate) {
+    const load = deps.loadGate.load1();
+    if (load === null || !Number.isFinite(load)) return `load gate: load unreadable (loadMax ${deps.loadGate.loadMax})`;
+    if (load >= deps.loadGate.loadMax) return `load gate: load ${load} >= loadMax ${deps.loadGate.loadMax}`;
+  }
+  if (deps.retryLaunches && deps.retryLaunches.count >= RETRY_LAUNCHES_PER_CYCLE) return `one relaunch per cycle already used (${move})`;
+  return undefined;
+}
+
+/** 결정 카드가 «근거»로 쓰는 세 칸 — 막힌 과제의 서명 · 막힌 화면 · 리뷰 must-fix. */
+export interface DecisionCardEvidence { signature?: string; screen?: string; mustFix?: readonly string[] }
+
+/** 비지 않은 근거 칸 이름들 — 비어 있으면 카드를 올리지 않는다(근거 없는 카드 0). */
+export function decisionCardGrounds(evidence: DecisionCardEvidence | undefined): Array<'signature' | 'screen' | 'must-fix'> {
+  const grounds: Array<'signature' | 'screen' | 'must-fix'> = [];
+  if (evidence?.signature?.trim()) grounds.push('signature');
+  if (evidence?.screen?.trim()) grounds.push('screen');
+  if (evidence?.mustFix?.some(fix => typeof fix === 'string' && fix.trim())) grounds.push('must-fix');
+  return grounds;
+}
+
+/** `decisions raise` 인자 — 종전 실행부(`executeNextAction`)와 live 수(`executeLiveDecisionCard`)가 같은 카드 모양을 쓴다. */
+export function decisionRaiseArgs(input: { taskId: string; reason: string; risk?: NextAction['risk']; evidence: string }): string[] {
+  const category = input.risk === 'money' ? 'money' : input.risk === 'security' ? 'security' : input.risk === 'irreversible-publication' ? 'publish' : 'other';
+  return ['decisions', 'raise', '--title', `${input.taskId}: ${input.reason}`, '--category', category, '--s', `Task ${input.taskId} needs a decision.`, '--c', input.reason, '--ref', input.evidence, '--q', 'Which action should be taken?', '--option', 'h=Keep on hold:no automatic execution', '--option', 'p=Approve action:execute after approval', '--skip-recommend', 'requires human decision', '--no-xcheck', 'automated escalation'];
 }
 
 /** 실패 셈 키. 갈래가 있으면 갈래별로 센다(G2 — «다른 수»의 실패가 같은 칸에 쌓이지 않게). 없으면 종전 키 그대로. */
@@ -72,6 +114,19 @@ export function failureKey(action: Pick<NextAction, 'taskId' | 'kind' | 'variant
   return JSON.stringify(action.variant ? [action.taskId, action.kind, action.variant] : [action.taskId, action.kind]);
 }
 
+/**
+ * 같은 «수»의 실패 수 — 상한 판정용. 셈 키(`failureKey`)는 종전 그대로 두되, 갈래 없는 재발사와 `narrow` 갈래는
+ * 같은 수(`narrow-relaunch` · `retryMoveOf`)라 두 키를 합쳐 본다(TA-LIVE-RETRY: 같은 과제·같은 수 3회 반복 0).
+ */
+export function sameMoveFailures(action: Pick<NextAction, 'taskId' | 'kind' | 'variant'>, deps: Pick<ActionDeps, 'failureCounts' | 'failures'>): number {
+  if (!deps.failureCounts) return deps.failures ?? 0;
+  if (action.kind !== 'retry' || retryMoveOf(action.variant) !== 'narrow-relaunch') return deps.failureCounts[failureKey(action)] ?? deps.failures ?? 0;
+  const bare = deps.failureCounts[failureKey({ taskId: action.taskId, kind: 'retry' })];
+  const narrow = deps.failureCounts[failureKey({ taskId: action.taskId, kind: 'retry', variant: 'narrow' })];
+  if (bare === undefined && narrow === undefined) return deps.failures ?? 0;
+  return (bare ?? 0) + (narrow ?? 0);
+}
+
 const RETRY_HINT: Record<Exclude<RetryVariant, 'wait'>, (action: NextAction) => string> = {
   narrow: action => `Narrow relaunch: previous run ${action.runId} made no progress. Halve the scope; keep the same acceptance line.`,
   salvage: action => `Salvage relaunch: continue from the salvage branch ${action.salvageBranch ?? `of run ${action.runId}`} — take its diff, do not restart from scratch.`,
@@ -89,18 +144,19 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
     deps.observe('task-agent.action', { taskId: action.taskId, kind: action.kind, result, reason });
     return result;
   };
-  if (deps.mode !== 'live') {
+  const shadowReason = deps.mode === 'live' ? retryShadowReason(action, deps) : undefined;
+  if (deps.mode !== 'live' || shadowReason) {
     const destination = action.delivery && action.kind === 'deliver'
       ? ` → ${join(action.delivery.projectTarget, 'elanous-out', action.taskId)}/${action.delivery.files.join(', ')}` : '';
-    return record('shadow', `would ${action.kind}${action.variant ? `:${action.variant}` : ''}: ${action.rationale}${destination}`);
+    return record('shadow', `would ${action.kind}${action.variant ? `:${action.variant}` : ''}: ${action.rationale}${destination}${shadowReason ? ` · shadow: ${shadowReason}` : ''}`);
   }
   const card = async (reason: string) => {
     const evidence = JSON.stringify({ runId: action.runId, pr: action.pr, mustFix: action.mustFix ?? [], history: action.history ?? [], selected: action.kind, reason });
-    const result = await deps.command(['decisions', 'raise', '--title', `${action.taskId}: ${reason}`, '--category', action.risk === 'money' ? 'money' : action.risk === 'security' ? 'security' : action.risk === 'irreversible-publication' ? 'publish' : 'other', '--s', `Task ${action.taskId} needs a decision.`, '--c', reason, '--ref', evidence, '--q', 'Which action should be taken?', '--option', 'h=Keep on hold:no automatic execution', '--option', 'p=Approve action:execute after approval', '--skip-recommend', 'requires human decision', '--no-xcheck', 'automated escalation']);
+    const result = await deps.command(decisionRaiseArgs({ taskId: action.taskId, reason, ...(action.risk ? { risk: action.risk } : {}), evidence }));
     return record(result.status === 0 ? 'decision' : 'failed', reason);
   };
   if (action.risk) return card(`risk: ${action.risk}`);
-  if ((deps.failureCounts?.[failureKey(action)] ?? deps.failures ?? 0) >= 2) return card('same task/action failed twice');
+  if (sameMoveFailures(action, deps) >= SAME_MOVE_FAILURE_LIMIT) return card('same task/action failed twice');
   if (action.kind === 'land') {
     if (!action.cwd) return card('landing worktree unknown');
     const view = await deps.command(['gh', 'pr', 'view', String(action.pr), '--json', 'labels']);
@@ -164,6 +220,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');
@@ -171,6 +231,7 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
   // 여기 닿는 종류는 land · retry 둘뿐이다(green·decision·review 는 위에서 끝난다).
   const args = action.kind === 'land' ? ['pr', 'land', '--cwd', action.cwd!] : ['harness', 'say', retryText(action)];
   const day = deps.landingDay ?? new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
+  if (action.kind === 'retry' && deps.retryLaunches) deps.retryLaunches.count++;
   const outcome = await deps.command(args);
   if (outcome.status !== 0) {
     if (action.kind === 'land') deps.releaseLanding?.(day);

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

@@ -5,6 +5,11 @@ 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' | 'deliverable';
+/** Card evidence stays a string in the existing ledger; retain both the checked output reference and the confirmed receipt. */
+export function deliverableReceiptEvidence(ref: string): string {
+  return JSON.stringify({ ref, receipt: true });
+}
+
 export interface CompletionEvidenceDeps {
   ledger?: Pick<DecisionLedger, 'list'>;
   schedulesDb?: Database;

package/src/task-agent/cover.ts

@@ -1,3 +1,4 @@
+import { debug } from '../debug/log.js';
 import type { NextActionKind } from './actions.js';
 
 type CoverVerb = 'land' | 'review' | 'retry' | 'green';
@@ -21,16 +22,91 @@ export interface CoverRow {
 
 /** 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;
+  taskAgentActions: readonly { kind: NextActionKind; result: string; reason?: string; taskId?: string }[] | null;
   allLands: readonly { step: string; ok: boolean }[] | null;
+  /** Card-ledger denominator for review·retry·green. undefined = not requested; null = ledger unreadable; [] = no cards. */
+  taskCards?: readonly { id: string }[] | null;
+  /** Daily launch and PR counts come from their independent event sources; null means unreadable. */
+  launched?: number | null;
+  cardPrs?: number | null;
+  /** null means the pending-landing age source could not be read; [] means no pending landings. */
+  pendingLandingAgeSeconds?: readonly number[] | 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 type LandingFailureReason = 'load' | 'oom' | 'time-limit' | 'conflict' | 'review' | 'other';
+export interface LandingThroughput {
+  launched: number | null;
+  cardPrs: number | null;
+  taskAgentLandings: number | null;
+  launchToPrRatio: number | null;
+  prToLandingRatio: number | null;
+  failureReasons: Record<LandingFailureReason, number> | null;
+  pendingLandings: number | null;
+  oldestPendingAgeSeconds: number | null;
+}
+
+const FAILURE_REASONS: readonly LandingFailureReason[] = ['load', 'oom', 'time-limit', 'conflict', 'review', 'other'];
+
+function landingFailureReason(action: { kind: NextActionKind; reason?: string }): LandingFailureReason {
+  const reason = action.reason ?? '';
+  if (/\boom\b|out[- ]of[- ]memory|oomkilled|메모리.{0,12}(초과|부족|킬)/i.test(reason)) return 'oom';
+  if (/timeout|timed out|time[- ]limit|deadline|시간.{0,12}(초과|한도)/i.test(reason)) return 'time-limit';
+  if (/conflict|merge conflict|충돌/i.test(reason)) return 'conflict';
+  if (action.kind === 'review' || /review|리뷰/i.test(reason)) return 'review';
+  if (/load|resource.{0,12}(pressure|exhaust|limit)|cpu.{0,8}load|부하|포화/i.test(reason)) return 'load';
+  return 'other';
+}
+
+/** Daily funnel, failure-reason distribution, and oldest pending-landing age. */
+export function measureLandingThroughput(input: TaskAgentCoverInput): LandingThroughput {
+  const actionsReadable = input.taskAgentActions !== null && input.truncated?.taskAgentActions !== true;
+  const taskAgentLandings = actionsReadable
+    ? input.taskAgentActions!.filter((action) => action.kind === 'land' && action.result === 'done').length
+    : null;
+  const failureReasons = actionsReadable
+    ? Object.fromEntries(FAILURE_REASONS.map((reason) => [reason, 0])) as Record<LandingFailureReason, number>
+    : null;
+  if (failureReasons && input.taskAgentActions) {
+    for (const action of input.taskAgentActions) {
+      if (action.result !== 'failed') continue;
+      const reason = landingFailureReason(action);
+      failureReasons[reason]++;
+    }
+  }
+  const launched = input.launched ?? null;
+  const cardPrs = input.cardPrs ?? null;
+  const pendingAges = input.pendingLandingAgeSeconds ?? null;
+  const launchToPrRatio = launched !== null && launched > 0 && cardPrs !== null ? cardPrs / launched : null;
+  const prToLandingRatio = cardPrs !== null && cardPrs > 0 && taskAgentLandings !== null ? taskAgentLandings / cardPrs : null;
+  return {
+    launched, cardPrs, taskAgentLandings, launchToPrRatio, prToLandingRatio, failureReasons,
+    pendingLandings: pendingAges === null ? null : pendingAges.length,
+    oldestPendingAgeSeconds: pendingAges === null || pendingAges.length === 0 ? null : Math.max(...pendingAges),
+  };
+}
+
+/** Unknown values stay unknown; empty pending queues are reported distinctly from unreadable ages. */
+export function formatLandingThroughput(row: LandingThroughput, period = '1d'): string {
+  const count = (value: number | null): string => value === null ? '-' : String(value);
+  const ratio = (value: number | null): string => value === null ? '-' : `${(value * 100).toFixed(1)}%`;
+  const failures = row.failureReasons === null ? '못 잼' :
+    `부하 ${row.failureReasons.load} · OOM ${row.failureReasons.oom} · 시간 한도 ${row.failureReasons['time-limit']} · 충돌 ${row.failureReasons.conflict} · 리뷰 ${row.failureReasons.review} · 기타 ${row.failureReasons.other}`;
+  const pendingAge = row.pendingLandings === null ? '못 잼'
+    : row.pendingLandings === 0 ? '없음'
+      : row.oldestPendingAgeSeconds === null ? '못 잼'
+        : row.oldestPendingAgeSeconds < 3600
+          ? `${Math.floor(row.oldestPendingAgeSeconds / 60)}분`
+          : `${(row.oldestPendingAgeSeconds / 3600).toFixed(1)}h`;
+  return `처리량(${period}) 발사 ${count(row.launched)} → 카드 PR ${count(row.cardPrs)} → TA 착지 ${count(row.taskAgentLandings)} (발사→PR ${ratio(row.launchToPrRatio)} · PR→착지 ${ratio(row.prToLandingRatio)}) · 착지 실패 ${failures} · 착지 대기 ${count(row.pendingLandings)}건, 최장 ${pendingAge}`;
+}
+
+/** Land uses the merge-step denominator; review·retry·green use the card ledger only when `taskCards` is given. */
 export function measureTaskAgentCover(input: TaskAgentCoverInput): CoverRow[] {
   const verbs: CoverVerb[] = ['land', 'review', 'retry', 'green'];
-  return verbs.map((verb) => {
+  const cardIds = input.taskCards ? new Set(input.taskCards.map((card) => card.id)) : null;
+  const rows = verbs.map((verb): CoverRow => {
     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;
@@ -38,6 +114,19 @@ export function measureTaskAgentCover(input: TaskAgentCoverInput): CoverRow[] {
     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' && input.taskCards !== undefined) {
+      if (actionsUnreadable || cardIds === null) return {
+        verb, byTaskAgent: null, total: null, observedActions, ratio: null, state: 'unreadable' as const,
+        ...counts, stewardTransition: 'unmeasured' as const,
+      };
+      const doneCards = new Set(actions.filter((action) => action.result === 'done' && action.taskId !== undefined && cardIds.has(action.taskId)).map((action) => action.taskId));
+      const total = cardIds.size;
+      const ratio = total === 0 ? null : doneCards.size / total;
+      return {
+        verb, byTaskAgent: doneCards.size, total, observedActions, ratio, state: total === 0 ? 'no-denominator' as const : 'measured' as const,
+        ...counts, stewardTransition: ratio === null ? 'unmeasured' as const : doneCards.size > 0 ? 'observed' as const : 'not-observed' as const,
+      };
+    }
     if (verb !== 'land') return {
       verb, byTaskAgent, total: null, observedActions, ratio: null,
       state: actionsUnreadable ? 'unreadable' : 'no-denominator',
@@ -52,6 +141,15 @@ export function measureTaskAgentCover(input: TaskAgentCoverInput): CoverRow[] {
       stewardTransition: ratio === null ? 'unmeasured' : byTaskAgent !== null && byTaskAgent > 0 ? 'observed' : 'not-observed',
     };
   });
+  if (input.taskCards !== undefined) {
+    try {
+      debug.log('task-agent.cover', 'by-card', {
+        cards: input.taskCards === null ? null : cardIds?.size,
+        verbs: rows.filter((row) => row.verb !== 'land').map(({ verb, byTaskAgent, total, state }) => ({ verb, byTaskAgent, total, state })),
+      });
+    } catch { /* fail-soft */ }
+  }
+  return rows;
 }
 
 /** A single human-readable line per verb; unknown numbers are never rendered as zero. */

package/src/task-agent/judge.ts

@@ -72,13 +72,30 @@ const EXECUTOR_VARIANT: Partial<Record<TaskMove, RetryVariant>> = {
   alternative: 'alternative',
 };
 
+/** 사다리 R4 — 실행부 허용 목록에 올릴 수 있는 재발사 계열 수(설정 `taskAgent.liveMoves` 어휘 그대로). */
+export const LIVE_RETRY_MOVES = ['narrow-relaunch', 'wait-retry', 'salvage-relaunch', 'alternative'] as const satisfies readonly TaskMove[];
+export type LiveRetryMove = typeof LIVE_RETRY_MOVES[number];
+
+const RETRY_MOVE_OF_VARIANT: Record<RetryVariant, LiveRetryMove> = {
+  narrow: 'narrow-relaunch',
+  wait: 'wait-retry',
+  salvage: 'salvage-relaunch',
+  alternative: 'alternative',
+};
+
+/** 실행부 `retry` 가 어느 수인가 — 갈래 없는 재발사(리뷰 fail 의 must-fix 재발사)는 «좁혀 재발사»다. */
+export function retryMoveOf(variant?: RetryVariant): LiveRetryMove {
+  return RETRY_MOVE_OF_VARIANT[variant ?? 'narrow'];
+}
+
 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;

package/src/task-agent/land-order-ledger.ts

@@ -0,0 +1,95 @@
+/**
+ * TA-LAND-ORDER-LEDGER — 겹침 쌍·착지 순서 원장(첫 조각 · MK 0.2.24 칸 LAND-ORDER-LEDGER).
+ *
+ * - 왜: 재판정 틱이 같은 PR 의 여러 머리를 겹쳐 재게이트·land 하면서 «무엇이 먼저 착지했고 그때 리뷰·게이트가
+ *   무엇을 말했나»가 카드 이력 흐름에만 남는다. 착지 순서를 정하는 다음 소비자(L8 머지 큐 · OVERLAP-METRIC 집계 —
+ *   다음 조각)는 한 줄씩인 «원장» 모양이 필요하다 — 이 모듈은 그 행을 만들고 붙인다(순서 결정은 여기서 하지 않는다).
+ * - 행 = {pr, head, cardId, gateBase, reviewVerdict, mustFix, landOk, landClass, at} — `joinLandOrderRow` 가 순수하게
+ *   만들고(파일을 읽지 않는다) `appendLandOrderRow` 가 카드 상태 파일 옆 `land-order-ledger.jsonl`(JSONL) 에 붙인다.
+ * - reviewVerdict: review-results 파일(`review-result-capture.ts` 의 reviewResultPath 꼴)을 못 읽으면 'missing' —
+ *   0 으로 쓰지 않는다. mustFix 도 읽었을 때만 수로, 모르면 null(0 이 아니다).
+ * - 같은 pr+head 는 한 줄만 — 두 번 불러도 첫 줄이 그대로다(덮어쓰지 않는다).
+ * - 호출자: `rejudge-on-head.ts` ③ land 단계 — executeLiveLand 직후 한 번. 쓰기 실패는 호출자가 삼킨다(land 결과 무변).
+ * - 관측: `task-agent.land-order` · 'appended' | 'append-failed' {pr, head} — 호출자가 남긴다.
+ */
+import { appendFileSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import type { LiveMoveResult } from './live-moves.js';
+import type { ParsedReviewResult } from './review-result-capture.js';
+
+/** 원장 행 — 같은 pr+head 는 한 줄만. */
+export interface LandOrderRow {
+  pr: number;
+  head: string;
+  cardId: string;
+  /** 재게이트 base — 겹침 증거(#26023 꼴)의 `gate.baseCommit`. */
+  gateBase: string;
+  /** review-results 파일을 못 읽으면 'missing' — 0 으로 쓰지 않는다. */
+  reviewVerdict: string;
+  /** must-fix 수 — 읽었을 때만. 모르면 null(0 이 아니다). */
+  mustFix: number | null;
+  landOk: boolean;
+  /** 실패 갈래(infra|judgement|base-stale) — 갈래가 없으면(성공) null. */
+  landClass: string | null;
+  at: string;
+}
+
+/**
+ * 겹침 증거(#26023 꼴 `{pr, head, gate:{head, baseCommit, passed}, reviewResult}`) ⊕ 카드 식별.
+ * `cardId` 는 증거 «파일»에는 없는 칸이라 호출자가 메모리에서 싣는다(파일 형식은 무변).
+ */
+export interface LandOrderOverlapEvidence {
+  pr: number;
+  head: string;
+  cardId: string;
+  gate: { head: string; baseCommit: string; passed: boolean };
+  reviewResult?: string;
+}
+
+/** 원장 파일 — 카드 상태 파일 옆(reviewResultPath 와 같은 «옆» 규칙). */
+export function landOrderLedgerPath(statePath: string): string {
+  return join(dirname(statePath), 'land-order-ledger.jsonl');
+}
+
+/** 순수 함수 — 겹침 증거 ⊕ 회수한 리뷰 결과 ⊕ land 결과를 원장 한 행으로 합친다(파일을 읽지 않는다). */
+export function joinLandOrderRow(input: {
+  overlapEvidence: LandOrderOverlapEvidence;
+  /** review-results 파일을 읽어 해석한 결과 — 못 읽으면 null(→ reviewVerdict 'missing'). */
+  reviewResult: ParsedReviewResult | null;
+  landed: Pick<LiveMoveResult, 'ok' | 'landAttempt'>;
+  at: string;
+}): LandOrderRow {
+  return {
+    pr: input.overlapEvidence.pr,
+    head: input.overlapEvidence.head,
+    cardId: input.overlapEvidence.cardId,
+    gateBase: input.overlapEvidence.gate.baseCommit,
+    reviewVerdict: input.reviewResult?.verdict ?? 'missing',
+    mustFix: input.reviewResult?.mustFix ?? null,
+    landOk: input.landed.ok === true,
+    landClass: input.landed.landAttempt?.class ?? null,
+    at: input.at,
+  };
+}
+
+/** 원장에 한 줄 붙인다 — 같은 pr+head 가 이미 있으면 그대로(두 번 불러도 1행). 못 붙이면 던진다(호출자가 삼킨다). */
+export function appendLandOrderRow(statePath: string, row: LandOrderRow): void {
+  const ledgerPath = landOrderLedgerPath(statePath);
+  let existing: string;
+  try {
+    existing = readFileSync(ledgerPath, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code !== 'ENOENT') throw error;
+    existing = '';
+  }
+  const samePair = (value: unknown): boolean => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+    const entry = value as Partial<LandOrderRow>;
+    return entry.pr === row.pr && typeof entry.head === 'string' && entry.head.toLowerCase() === row.head.toLowerCase();
+  };
+  const seen = existing.split('\n').filter(Boolean).some((line) => {
+    try { return samePair(JSON.parse(line)); } catch { return false; }
+  });
+  if (seen) return;
+  appendFileSync(ledgerPath, `${JSON.stringify(row)}\n`);
+}