elanous 0.2.25 → 0.2.28

package/src/task-agent/actions.ts

@@ -166,6 +166,7 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
     catch { return card('PR labels unavailable'); }
     if (!Array.isArray(labels) || !labels.every(label => label && typeof label === 'object' && typeof label.name === 'string')) return card('PR labels unavailable');
     if (labels.some(label => label.name === 'elanous:release-path')) return card('release-path');
+    if (labels.some(label => label.name === 'elanous:keep')) return card('elanous:keep');
     const day = new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
     if (deps.landingDay && deps.landingDay !== day) deps.landingsToday = 0;
     deps.landingDay = day;

package/src/task-agent/adopt-pr.ts

@@ -0,0 +1,140 @@
+/** Attach an existing open PR to a TA card without starting another implementation run. */
+import { randomBytes } from 'node:crypto';
+import { loadRunLedger, runLedgerDir, type RunLedgerEntry } from '../self-implement/run-ledger.js';
+import { remoteLedgerMirrorDir } from './parent-host.js';
+import { prodInstanceRoot } from '../instance/resolve.js';
+import { cardPrNumber, updateTaskCard, type TaskCard } from './task-hand.js';
+
+export interface AdoptPrView {
+  number: number; url: string; state: string; baseRefName: string; headRefOid: string;
+}
+export interface AdoptPrInput {
+  pr: AdoptPrView;
+  repo: string;
+  statePath: string;
+  cardId?: string;
+  version?: string;
+  checklist?: { version: string; id: string; title: string; status: string };
+  now?: Date;
+  terminalRunEvidence?: boolean;
+  unlinkedTerminal?: boolean;
+  observedRun?: { runId?: string; runChildId?: string; parentHost?: string; launchId?: string };
+  observedChecklist?: { id: string; version: string; status: string; cardVersion?: string };
+  checklistAtWrite?: () => { id: string; status: string } | undefined;
+}
+
+/** A bound implementation may still push to its PR. Require the child to have stopped on this exact PR first. */
+export function adoptedRunTerminal(card: TaskCard, pr: AdoptPrView,
+  load: (runId: string, dir: string) => RunLedgerEntry[] | null = loadRunLedger, allowUnlinked = false): boolean {
+  if (!card.runId) return false;
+  const dir = card.parentHost ? remoteLedgerMirrorDir(prodInstanceRoot(), card.parentHost.host) : runLedgerDir();
+  try {
+    const parent = load(card.runId, dir);
+    if (!parent) return false;
+    const childIds = parent.filter((entry) => entry.event === 'pod-child-run' && typeof entry.data?.childRunId === 'string')
+      .map((entry) => String(entry.data.childRunId));
+    const candidates = childIds.length ? childIds : [card.runId];
+    let allStopped = candidates.length > 0;
+    let noPrEvents = true;
+    let exactMatches = 0;
+    for (const childId of candidates) {
+      const child = childId === card.runId ? parent : load(childId, dir);
+      if (!child) { allStopped = false; continue; }
+      let prAt = -1;
+      let statusAt = -1;
+      for (let at = child.length - 1; at >= 0 && (prAt < 0 || statusAt < 0); at--) {
+        if (prAt < 0 && child[at]?.event === 'pr-opened') prAt = at;
+        if (statusAt < 0 && child[at]?.event === 'run-status') statusAt = at;
+      }
+      const opened = child[prAt];
+      const status = child[statusAt];
+      if (prAt >= 0) noPrEvents = false;
+      if (!status || !['completed', 'failed', 'cancelled'].includes(String(status.data?.runStatus))) allStopped = false;
+      if ((!card.runChildId || card.runChildId === childId) && opened?.data?.number === pr.number && opened.data?.url === pr.url && statusAt > prAt) exactMatches++;
+    }
+    if (!allStopped) return false;
+    if (exactMatches === 1) return true;
+    if (allowUnlinked && exactMatches === 0 && noPrEvents && (!card.runChildId || candidates.includes(card.runChildId))) return true;
+  } catch { /* unreadable is not terminal evidence */ }
+  return false;
+}
+
+/** The PR is read from the selected repository before this call; rejudge checks it again before every live move. */
+export function adoptExistingPr(input: AdoptPrInput): { card: TaskCard; created: boolean; changed: boolean } {
+  const { pr } = input;
+  const slug = pr.url.match(/^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/\d+\/?$/)?.[1];
+  if (!Number.isSafeInteger(pr.number) || pr.number < 1 || pr.state !== 'OPEN' || pr.baseRefName !== 'main'
+    || !slug || slug.toLowerCase() !== input.repo.toLowerCase()
+    || Number(pr.url.match(/\/pull\/(\d+)/)?.[1]) !== pr.number
+    || !/^[a-f0-9]{40}$/i.test(pr.headRefOid)) throw new Error('입양할 PR은 현재 저장소의 OPEN/main PR 번호·URL·head SHA40이어야 한다');
+  if ((input.cardId === undefined) === (input.checklist === undefined)) throw new Error('--card 또는 --checklist/--version 중 하나만 준다');
+  if (input.cardId && !input.version) throw new Error('기존 카드는 체크리스트 판을 확정해야 한다');
+  if (input.checklist && (!input.checklist.id || !input.checklist.title || !input.checklist.version
+    || ['green', 'done'].includes(input.checklist.status))) throw new Error('입양할 체크리스트 칸은 미완 판·id·제목이어야 한다');
+  const id = input.cardId ?? `ta-${(input.now ?? new Date()).toISOString().slice(0, 10).replaceAll('-', '')}-${randomBytes(3).toString('hex')}`;
+  const at = (input.now ?? new Date()).toISOString();
+  let created = false;
+  let changed = false;
+  const result = updateTaskCard(input.statePath, id, (current, tasks) => {
+    const duplicate = Object.values(tasks).find((card) => card.id !== id && cardPrNumber(card) === pr.number);
+    if (duplicate) throw new Error(`PR #${pr.number}는 이미 카드 ${duplicate.id}에 묶였다`);
+    const checklistId = current?.checklistId ?? input.checklist?.id;
+    const checklistVersion = input.version ?? input.checklist?.version;
+    const sameCell = Object.values(tasks).find((card) => card.id !== id && card.status === 'launched' && card.taLand === true
+      && cardPrNumber(card) !== undefined && card.checklistId === checklistId
+      && (!card.checklistVersion || !checklistVersion || card.checklistVersion === checklistVersion));
+    if (sameCell) throw new Error(`칸 ${checklistId}에 이미 TA 착지 후보 카드 ${sameCell.id}가 있다`);
+    if (!input.cardId) {
+      const owner = Object.values(tasks).find((card) => card.status === 'launched' && card.checklistId === checklistId
+        && (!card.checklistVersion || !checklistVersion || card.checklistVersion === checklistVersion));
+      if (owner) throw new Error(`칸 ${checklistId}에 기존 카드 ${owner.id}가 있다 — --card로 그 카드를 선택한다`);
+    }
+    if (input.cardId && (!input.observedRun || current?.runId !== input.observedRun.runId
+      || current?.runChildId !== input.observedRun.runChildId
+      || current?.parentHost?.host !== input.observedRun.parentHost
+      || current?.launchId !== input.observedRun.launchId))
+      throw new Error(`입양 중 카드 런 식별자가 바뀌었다: ${id}`);
+    if (input.cardId && (!input.observedChecklist || current?.checklistId !== input.observedChecklist.id
+      || current?.checklistVersion !== input.observedChecklist.cardVersion
+      || input.version !== input.observedChecklist.version
+      || ['green', 'done'].includes(input.observedChecklist.status)))
+      throw new Error(`입양 중 카드 칸·판이 바뀌었다: ${id}`);
+    const liveCell = input.checklistAtWrite?.();
+    if (input.checklistAtWrite && (!liveCell || liveCell.id !== checklistId || ['green', 'done'].includes(liveCell.status)))
+      throw new Error(`입양 중 체크리스트 칸이 바뀌거나 완료됐다: ${checklistId}`);
+    if (current?.adoptedPr?.pr === pr.number && cardPrNumber(current) === pr.number && current.taLand === true
+      && typeof current.pr === 'object' && current.pr.url === pr.url) {
+      if (current.status !== 'launched') throw new Error(`이미 닫힌 입양 카드다: ${id} (${current.status})`);
+      if (current.checklistVersion !== (input.version ?? input.checklist?.version)) throw new Error(`이미 입양한 카드의 판이 다르다: ${current.checklistVersion ?? '미기록'} ≠ ${input.version ?? input.checklist?.version}`);
+      return undefined;
+    }
+    if (input.cardId) {
+      const boundPr = current && cardPrNumber(current);
+      const sameBoundPr = boundPr === pr.number && typeof current?.pr === 'object' && current.pr.url === pr.url;
+      if (!current || current.status !== 'launched' || !current.checklistId
+        || (boundPr !== undefined && !sameBoundPr)
+        || (input.checklist && current.checklistId !== input.checklist.id)) throw new Error(`입양할 launched·미바인딩/동일 PR 바인딩 카드가 아니다: ${id}`);
+      if (boundPr !== undefined && input.unlinkedTerminal)
+        throw new Error(`이미 PR이 바인딩된 카드는 --unlinked-terminal로 입양할 수 없다: ${id}`);
+      if (input.terminalRunEvidence !== true) throw new Error(`구현 런 종결·PR 근거가 없다: ${current.runId ?? current.launchId ?? 'runId 없음'} — runId 없는 카드는 tasks close 후 --checklist 새 카드로 입양`);
+      if (input.version && current.checklistVersion && current.checklistVersion !== input.version)
+        throw new Error(`카드 판이 다르다: ${current.checklistVersion} ≠ ${input.version}`);
+    } else {
+      if (current) throw new Error(`새 카드 id 충돌: ${id}`);
+    }
+    const base: TaskCard = current ?? {
+      id, text: input.checklist!.title, checklistId: input.checklist!.id,
+      createdAt: at, status: 'launched', history: [],
+    };
+    created = !current;
+    changed = true;
+    return { ...base, ...(input.version || input.checklist ? { checklistVersion: input.version ?? input.checklist!.version } : {}),
+      taLand: true, pr: { number: pr.number, url: pr.url },
+      adoptedPr: { pr: pr.number, url: pr.url, head: pr.headRefOid, at },
+      history: [...base.history, { at, event: 'pr-adopted', pr: pr.number, head: pr.headRefOid,
+        detail: `기존 OPEN PR 입양 · ${pr.url} · 새 구현 발사 0${input.unlinkedTerminal ? ' · 명시적 비연결 종결 원장' : ''}` }],
+    };
+  });
+  if (!result) throw new Error(`카드 쓰기 실패: ${id}`);
+  return { card: result, created, changed };
+}

package/src/task-agent/board.ts

@@ -12,7 +12,7 @@ import { releaseLedgerRoot } from '../instance/resolve.js';
 import { listChecklist, type ChecklistStatus } from '../release-loop/checklist.js';
 import { buildRunProgressRows, queryRunningRuns, type RunningRunsResult, type RunProgressRow } from '../self-implement/running-runs.js';
 import {
-  cardPrNumber, CLOSED_BY_HAND_EVENT, HAND_MOVE_HISTORY_EVENT, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, readTaskAgentState,
+  boundPrTerminal, cardPrNumber, CLOSED_BY_HAND_EVENT, HAND_MOVE_HISTORY_EVENT, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, readTaskAgentState,
   type CompletionKind, type TaskCard,
 } from './task-hand.js';
 
@@ -29,6 +29,10 @@ export interface BoardTaskLedger {
   lastEvent: { at: string; event: string; detail: string | null } | null;
   /** 카드가 failed · launch-failed 일 때 마지막 줄의 사유(예: `failed/needs-owner — exit 1 · pod-failure`). 그 밖에는 null. */
   exitReason: string | null;
+  /** Terminal PR observation, only when it still matches this card's binding. */
+  prTerminal?: NonNullable<TaskCard['prTerminal']>;
+  /** Checklist judgement after merge; partial means this slice ended while the cell remains open. */
+  postLand?: NonNullable<TaskCard['postLand']>;
 }
 
 /** `GET /api/task-agent/board` 응답 — progress 는 진전 관측(`queryRunningRuns`)을 싣는다; 관측을 못 얻으면 null(0을 «없다»로 쓰지 않는다). */
@@ -87,11 +91,14 @@ function aggregate(node: BoardNode): void {
 }
 
 function cardStatus(card: TaskCard): BoardStatus {
+  const terminal = boundPrTerminal(card);
+  if (terminal) return terminal.state === 'MERGED' ? 'done' : 'blocked';
   if (card.status === 'launch-failed' || card.status === 'failed') return 'blocked';
   return card.greenProposal ? 'done' : 'open';
 }
 
 function cardLedger(card: TaskCard): BoardTaskLedger {
+  const terminal = boundPrTerminal(card);
   const last = (card.history ?? [])
     .filter((item) => item.event !== LIVE_MOVE_HISTORY_EVENT && item.event !== LIVE_MOVE_RESULT_EVENT && item.event !== HAND_MOVE_HISTORY_EVENT)
     .at(-1);
@@ -105,6 +112,9 @@ function cardLedger(card: TaskCard): BoardTaskLedger {
     lastStatus: card.status,
     lastEvent: last ? { at: last.at, event: last.event, detail: last.detail ?? null } : null,
     exitReason: ended ? reason ?? null : null,
+    ...(terminal ? { prTerminal: terminal } : {}),
+    ...(terminal && terminal.state === 'MERGED' && card.postLand?.pr === terminal.pr && card.postLand.head === terminal.head
+      ? { postLand: card.postLand } : {}),
   };
 }
 

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

@@ -17,6 +17,7 @@ import { appendRunLedgerEntry, type RunLedgerEntry } from '../self-implement/run
 import { cardPrNumber, taskAgentStatePath, updateTaskCard, readTaskCard, type TaskCard } from './task-hand.js';
 import { judgeNextMove, type TaskJudgeInput } from './judge.js';
 import { remoteParentAlive, type SshRunner } from './parent-host.js';
+import { notifyRemoteFailure, remoteFailureReason } from './failure-notify.js';
 
 const GOAL_ID = /^[a-f0-9]{16}$/;
 const PR_URL = /^https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/(\d+)$/;
@@ -134,6 +135,8 @@ export interface CardRunEvidenceDeps {
   dispatchPod?: (runId: string, sinceIso: string) => boolean;
   runExit?: (runId: string) => RunExit | undefined;
   ssh?: SshRunner;
+  /** Isolated tests can put incident messages in their own mailbox; production uses the resolved default store. */
+  incidentStorePath?: string;
 }
 
 async function defaultLoadLedger(): Promise<(runId: string) => RunLedgerEntry[] | null> {
@@ -145,8 +148,7 @@ async function defaultLoadLedger(): Promise<(runId: string) => RunLedgerEntry[]
   // HARNESS-PARENT-ON-MSB1: 원격 부모 런의 원장 거울(`tasks show` 가 ssh 로 당긴다) — 이 우주 ⊕ 연합 «뒤»에만 붙는다.
   try {
     const { remoteLedgerMirrorDirs } = await import('./parent-host.js');
-    const { prodInstanceRoot } = await import('../instance/resolve.js');
-    dirs = [...new Set([...dirs, ...remoteLedgerMirrorDirs(prodInstanceRoot())])];
+    dirs = [...new Set([...dirs, ...remoteLedgerMirrorDirs(effectiveInstanceRoot())])];
   } catch { /* 거울이 없으면 종전 그대로 */ }
   return ledgerLoader(dirs, (runId, dir) => loadRunLedger(runId, dir), federationFailure);
 }
@@ -216,16 +218,46 @@ 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 }> {
   let card = readTaskCard(cardId, statePath);
-  // 수동 근거(refSource manual)는 덮지 않는다 · 둘 다 차 있으면 다시 읽지 않는다(한 번만) —
-  // 단 «10분 발사 근거 없음»으로 failed 된 카드는 PR·골이 먼저 묶였어도 되살림 판정을 계속 받는다.
+  // 수동 근거(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 };
+  if (!card?.runId || (card.pr !== undefined && card.goalId !== undefined && !awaitingRevival)) return { card };
   const runId = card.runId;
+  // A stale HQ mirror cannot prove a terminal remote failure. Refresh it here as well as in `tasks show`,
+  // since mission advance and direct callers also reach this function.
+  if (card.parentHost && !deps.loadLedger) {
+    try {
+      const { mirrorRemoteRunLedgers } = await import('./parent-host.js');
+      mirrorRemoteRunLedgers(card.parentHost, runId, effectiveInstanceRoot(), deps.ssh);
+    } catch (error) {
+      try { debug.log('task-agent', 'card-bind-failed', { card: cardId, runId, reason: `remote ledger refresh failed: ${error instanceof Error ? error.message : String(error)}` }); } catch { /* fail-soft */ }
+      return { card };
+    }
+  }
   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);
+  const remoteReason = remoteFailureReason(card, snapshot, evidence, deps.ssh);
+  if (remoteReason && (card.status === 'launched' || card.status === 'failed')) {
+    if (card.status === 'launched') {
+      const at = (deps.now ?? (() => new Date()))().toISOString();
+      card = updateTaskCard(statePath, cardId, (current) => current?.status === 'launched' && current.runId === runId && !current.pr
+        ? { ...current, status: 'failed', history: [...current.history, { at, event: 'failed', detail: `failed/needs-owner — ${remoteReason}`, runId }] }
+        : undefined) ?? card;
+    }
+    // An older generic Pod/no-launch failure may have closed this same run before its supervisor tail arrived.
+    // The terminal evidence still warrants an incident; message provenance keeps retries at one row.
+    const lastFailure = [...card.history].reverse().find((row) => row.event === 'failed');
+    if (card.status === 'failed' && lastFailure?.runId === runId && !card.history.some((row) => row.event === 'closed-by-hand')) {
+      try { notifyRemoteFailure(card, remoteReason, deps.incidentStorePath); }
+      catch (error) { try { debug.log('task-agent', 'failure-notify-failed', { card: cardId, runId, reason: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ } }
+      return { card, evidence };
+    }
+  }
   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

package/src/task-agent/cover.ts

@@ -8,7 +8,7 @@ export interface CoverRow {
   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. */
+  /** TASK-AGENT action events observed for this verb; null if unreadable. */
   observedActions: number | null;
   ratio: number | null;
   state: 'measured' | 'no-denominator' | 'unreadable';
@@ -23,6 +23,8 @@ 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; reason?: string; taskId?: string }[] | null;
+  /** Actual land executor outcomes; omitted or null means the source was not read. */
+  liveLandMoves?: readonly { card: string; executed: boolean; ok: boolean }[] | 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;
@@ -32,7 +34,26 @@ export interface TaskAgentCoverInput {
   /** 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 };
+  truncated?: { taskAgentActions: boolean; allLands: boolean; liveLandMoves?: boolean; goalAsks?: boolean; goalRuns?: boolean; implementCardRuns?: boolean; implementRunMerges?: boolean };
+  /** Completed authoring provenance and terminal goal records. undefined = not wired; null = unreadable. */
+  goalAsks?: readonly { authorRunId: string; goalId: string }[] | null;
+  goalRuns?: readonly { goalId: string; outcome: string; stage?: string }[] | null;
+  /** 구현 출처 — TA 카드의 런 결합. undefined = 이 동사의 출처 배선이 없다(no-source); null = 카드 원장을 못 읽었다; [] = 읽고 카드 없음. */
+  implementCardRuns?: readonly ImplementCardRunBinding[] | null;
+  /** 구현 출처 — 런 원장의 merged 사건. undefined = 배선 없음; null = 런 원장을 못 읽음. */
+  implementRunMerges?: ReadonlyMap<string, ImplementRunMergeEvent> | null;
+}
+
+/** 구현 동사의 카드 결합 — runId·runChildId 는 그 카드가 발사한 런이다. */
+export interface ImplementCardRunBinding {
+  cardId: string;
+  runId?: string | null;
+  runChildId?: string | null;
+}
+
+/** 구현 동사의 원장 merged 사건 — merged=true 만 완료 구현으로 센다. */
+export interface ImplementRunMergeEvent {
+  merged: boolean;
 }
 
 export type LandingFailureReason = 'load' | 'oom' | 'time-limit' | 'conflict' | 'review' | 'other';
@@ -49,6 +70,24 @@ export interface LandingThroughput {
 
 const FAILURE_REASONS: readonly LandingFailureReason[] = ['load', 'oom', 'time-limit', 'conflict', 'review', 'other'];
 
+function successfulLandCount(input: TaskAgentCoverInput): number | null {
+  if (input.taskAgentActions === null || input.truncated?.taskAgentActions
+    || input.liveLandMoves == null || input.truncated?.liveLandMoves) return null;
+  const cards = new Set<string>();
+  for (const action of input.taskAgentActions) {
+    if (action.kind !== 'land' || action.result !== 'done') continue;
+    // Without a card identity an action may duplicate a live-move; its count is unknown.
+    if (!action.taskId) return null;
+    cards.add(action.taskId);
+  }
+  for (const move of input.liveLandMoves) {
+    if (!move.executed || !move.ok) continue;
+    if (!move.card) return null;
+    cards.add(move.card);
+  }
+  return cards.size;
+}
+
 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';
@@ -62,9 +101,7 @@ function landingFailureReason(action: { kind: NextActionKind; reason?: string })
 /** 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 taskAgentLandings = actionsReadable ? successfulLandCount(input) : null;
   const failureReasons = actionsReadable
     ? Object.fromEntries(FAILURE_REASONS.map((reason) => [reason, 0])) as Record<LandingFailureReason, number>
     : null;
@@ -109,7 +146,8 @@ export function measureTaskAgentCover(input: TaskAgentCoverInput): CoverRow[] {
   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;
+    const byTaskAgent = verb === 'land' ? successfulLandCount(input)
+      : 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;
@@ -134,7 +172,7 @@ export function measureTaskAgentCover(input: TaskAgentCoverInput): CoverRow[] {
     };
     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'
+    const state = byTaskAgent === null || 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,
@@ -161,23 +199,23 @@ export function formatTaskAgentCover(row: CoverRow): string {
 /** 7동사의 이름 — 리뷰·착지·수리·검증·저작·구현·정리 (decision·deliver 는 7동사 밖이라 세지 않는다). */
 export type SevenVerbName = '리뷰' | '착지' | '수리' | '검증' | '저작' | '구현' | '정리';
 
-/** no-source 는 출처 배선이 아직 없는 동사 · unreadable 은 TASK-AGENT 행동 원장을 못 읽은 것이다. */
+/** no-source 는 출처 배선이 없는 동사 · unreadable 은 해당 동사의 원천을 완전히 못 읽은 것이다. */
 export type SevenVerbState = 'live' | 'shadow-only' | 'none' | 'no-source' | 'unreadable';
 
-/** 7동사 출처 표의 한 칸 — source 는 그 동사를 관측하는 TASK-AGENT action kind, null 이면 출처가 아직 없다. */
+/** 7동사 출처 표의 한 칸 — source 는 그 동사를 관측하는 원천, null 이면 출처가 아직 없다. */
 export interface SevenVerbSource {
   verb: SevenVerbName;
-  source: Exclude<NextActionKind, 'decision' | 'deliver'> | null;
+  source: Exclude<NextActionKind, 'decision' | 'deliver'> | 'goal-ask+goal-run' | 'card-run+merged' | null;
 }
 
-/** TA-THEME-VERBS-LIVE — 7동사와 출처 표(코드로 고정). 저작·구현·정리의 출처 배선은 다음 조각. */
+/** TA-THEME-VERBS-LIVE — 저작은 완료 골 조인; 구현은 카드 런 결합 ⊕ 원장 merged 조인; 정리는 아직 출처가 없다. */
 export const SEVEN_VERB_SOURCES: readonly SevenVerbSource[] = [
   { verb: '리뷰', source: 'review' },
   { verb: '착지', source: 'land' },
   { verb: '수리', source: 'retry' },
   { verb: '검증', source: 'green' },
-  { verb: '저작', source: null },
-  { verb: '구현', source: null },
+  { verb: '저작', source: 'goal-ask+goal-run' },
+  { verb: '구현', source: 'card-run+merged' },
   { verb: '정리', source: null },
 ];
 
@@ -197,28 +235,76 @@ export interface SevenVerbLive {
   measuredVerbs: number;
 }
 
-/** live = 창 안에 result done 인 non-shadow 사건 ≥1. 원장이 null 이거나 절단되었으면 전부 unreadable. */
+/** 행동 동사는 창 안의 done, 저작은 완료한 저작 원장과 착지 골의 조인, 구현은 카드 런 결합과 원장 merged 사건의 조인. 각 출처의 null·절단은 해당 동사만 unreadable. */
 export function measureSevenVerbLive(input: TaskAgentCoverInput): SevenVerbLive {
   const unreadable = input.taskAgentActions === null || input.truncated?.taskAgentActions === true;
   const verbs = SEVEN_VERB_SOURCES.map(({ verb, source }): SevenVerbLiveRow => {
-    if (unreadable) return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+    if (source === 'card-run+merged') {
+      // ⛔ 배선이 없으면 출처가 «있는» 동사로 거짓 측정을 하지 않는다 — no-source 로 그대로 둔다.
+      if (input.implementCardRuns === undefined && input.implementRunMerges === undefined) {
+        return { verb, source: null, liveDone: null, shadow: null, state: 'no-source' };
+      }
+      if (input.implementCardRuns == null || input.implementRunMerges == null
+        || input.truncated?.implementCardRuns === true || input.truncated?.implementRunMerges === true) {
+        return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+      }
+      const merges = input.implementRunMerges;
+      const cards = new Set<string>();
+      for (const binding of input.implementCardRuns) {
+        // 카드 신원 없이는 중복 없는 분자를 낼 수 없다 — 그 원장은 못 읽은 것으로 한다.
+        if (!binding.cardId) return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+        const bound = [binding.runId, binding.runChildId];
+        if (bound.some((runId) => typeof runId === 'string' && runId && merges.get(runId)?.merged === true)) {
+          cards.add(binding.cardId);
+        }
+      }
+      const liveDone = cards.size;
+      return { verb, source, liveDone, shadow: 0, state: liveDone >= 1 ? 'live' : 'none' };
+    }
     if (source === null) return { verb, source: null, liveDone: null, shadow: null, state: 'no-source' };
+    if (source !== 'goal-ask+goal-run' && (unreadable || (source === 'land'
+      && (input.liveLandMoves == null || input.truncated?.liveLandMoves)))) {
+      return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+    }
+    if (source === 'goal-ask+goal-run') {
+      if (input.goalAsks == null || input.goalRuns == null || input.truncated?.goalAsks || input.truncated?.goalRuns) {
+        return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+      }
+      const landed = new Set(input.goalRuns.filter((run) =>
+        run.stage === 'merged' && (run.outcome === 'completed' || run.outcome === 'merged')).map((run) => run.goalId));
+      const liveDone = new Set(input.goalAsks.filter((ask) => ask.authorRunId && landed.has(ask.goalId)).map((ask) => ask.goalId)).size;
+      return { verb, source, liveDone, shadow: 0, state: liveDone > 0 ? 'live' : 'none' };
+    }
     const actions = input.taskAgentActions!.filter((action) => action.kind === source);
-    const liveDone = actions.filter((action) => action.result === 'done').length;
+    const liveDone = source === 'land' ? successfulLandCount(input) : actions.filter((action) => action.result === 'done').length;
+    if (liveDone === null) return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
     const shadow = actions.filter((action) => action.result === 'shadow').length;
     return { verb, source, liveDone, shadow, state: liveDone >= 1 ? 'live' : shadow >= 1 ? 'shadow-only' : 'none' };
   });
   return {
     verbs,
-    liveVerbs: unreadable ? null : verbs.filter((row) => row.state === 'live').length,
-    measuredVerbs: SEVEN_VERB_SOURCES.filter((row) => row.source !== null).length,
+    liveVerbs: verbs.some((row) => row.state === 'unreadable' && row.source !== null) ? null : verbs.filter((row) => row.state === 'live').length,
+    measuredVerbs: verbs.filter((row) => row.source !== null).length,
   };
 }
 
 /** 한 줄 요약 — 못 읽었으면 n 자리를 `-` 로 적는다(0 으로 읽히지 않게). */
 export function formatSevenVerbLive(measurement: SevenVerbLive): string {
   const total = SEVEN_VERB_SOURCES.length;
-  if (measurement.liveVerbs === null) return `${total}동사 live -/${total} · 못 잼(행동 원장 null·절단)`;
+  if (measurement.liveVerbs === null) {
+    const actionUnreadable = measurement.verbs.some((row) => row.source === 'review' && row.state === 'unreadable');
+    const landUnreadable = measurement.verbs.some((row) => row.source === 'land' && row.state === 'unreadable');
+    const authorUnreadable = measurement.verbs.some((row) => row.source === 'goal-ask+goal-run' && row.state === 'unreadable');
+    const implementUnreadable = measurement.verbs.some((row) => row.source === 'card-run+merged' && row.state === 'unreadable');
+    const failures = [
+      actionUnreadable ? '행동' : landUnreadable ? '착지' : null,
+      authorUnreadable ? '저작·골' : null,
+      implementUnreadable ? '구현 카드·런' : null,
+    ].filter((part): part is string => part !== null);
+    const reason = `${failures.join('·') || '저작·골'} 원장 null·절단`;
+    const noSource = measurement.verbs.filter((row) => row.state === 'no-source').map((row) => row.verb).join('·');
+    return `${total}동사 live -/${total} · 못 잼(${reason})${noSource ? ` · 출처 없음 ${noSource}` : ''}`;
+  }
   const noSource = measurement.verbs.filter((row) => row.state === 'no-source').map((row) => row.verb).join('·');
   return `${total}동사 live ${measurement.liveVerbs}/${total}${noSource ? ` · 출처 없음 ${noSource}` : ''}`;
 }

package/src/task-agent/failure-notify.ts

@@ -0,0 +1,61 @@
+import { defaultMsgStorePath, openMsgStore } from '../msg/msg-store.js';
+import type { RunLedgerEntry } from '../self-implement/run-ledger.js';
+import type { CardRunSnapshot, CardRunEvidence } from './card-evidence.js';
+import { remoteParentAlive, type SshRunner } from './parent-host.js';
+import type { TaskCard } from './task-hand.js';
+
+const STOP_LINE = /\[supervisor\] 정지\((needs-human|no-progress)\)\s*[—-]\s*(.*)/u;
+
+/** A remote parent's terminal stop is usable only after every referenced child ledger was read. */
+export function remoteFailureReason(card: TaskCard, snapshot: CardRunSnapshot, evidence: CardRunEvidence, ssh?: SshRunner): string | undefined {
+  if (!card.parentHost || !card.runId || !snapshot.host || snapshot.readErrors?.length || card.pr || evidence.pr) return undefined;
+  const launchRows = snapshot.host.filter((row) => row.event === 'pod-child-run');
+  const childRefs = launchRows.map((row) => row.data?.childRunId);
+  // An unreadable or malformed child reference is unknown evidence, never "no children".
+  if (childRefs.some((id) => typeof id !== 'string' || !/^run-[A-Za-z0-9_-]{4,64}$/.test(id) || id === card.runId)) return undefined;
+  const children = childRefs as string[];
+  if (children.some((id) => !snapshot.children[id])) return undefined;
+  // The parent can stop while a child still runs. That child may publish a PR or salvage
+  // branch later, so every launched child must have a terminal last status first.
+  if (children.some((id) => {
+    const lastStatus = [...(snapshot.children[id] ?? [])].reverse().find((row) => row.event === 'run-status');
+    return !lastStatus || !['completed', 'failed', 'cancelled'].includes(String(lastStatus.data?.runStatus));
+  })) return undefined;
+  const rows: RunLedgerEntry[] = [...snapshot.host, ...children.flatMap((id) => snapshot.children[id] ?? [])];
+  if (rows.some((row) => row.event === 'pr-opened' || row.event === 'salvaged'
+    || (typeof row.data.harvestBranch === 'string' && row.data.harvestBranch.trim())
+    || (typeof row.data.salvageBranch === 'string' && row.data.salvageBranch.trim()))) return undefined;
+  const parentRows = snapshot.host.filter((row) => row.runId === card.runId);
+  const stopIndex = parentRows.map((row) => row.event).lastIndexOf('stop');
+  const stop = parentRows[stopIndex];
+  if (!stop) return undefined;
+  // A running status before stop is superseded by the supervisor's terminal stop.
+  // A fresh execution event after stop makes that stop stale for the current parent.
+  if (parentRows.slice(stopIndex + 1).some((row) => row.event === 'start' || row.event === 'pod-child-run'
+    || (row.event === 'run-status' && !['completed', 'failed', 'cancelled'].includes(String(row.data?.runStatus))))) return undefined;
+  const tail = Array.isArray(stop?.data.tail) ? stop.data.tail : [];
+  const lines = tail.filter((line): line is string => typeof line === 'string');
+  // A parent or terminal child stop can carry a PR or salvage branch only in raw text.
+  // Any nonempty branch token is harvest evidence, regardless of its naming prefix.
+  const stopText = rows.filter((row) => row.event === 'stop')
+    .flatMap((row) => [row.data.cause, ...(Array.isArray(row.data.tail) ? row.data.tail : [])])
+    .filter((value): value is string => typeof value === 'string').join('\n');
+  if (/https:\/\/github\.com\/[^\s]+\/pull\/\d+|ELANOUS_POD_SALVAGE(?:\s*=\s*|\s+)\S+|수확할 브랜치:\s*\S+/.test(stopText)) return undefined;
+  const matched = [...lines].reverse().map((line) => STOP_LINE.exec(line.replace(/\x1b\[[0-9;]*m/g, ''))).find((match) => match !== null);
+  if (!matched || remoteParentAlive({ ...card.parentHost, runId: card.runId }, ssh) !== 'dead') return undefined;
+  const raw = matched[2]?.replace(/[\r\n]+/g, ' ').trim();
+  if (!raw) return undefined;
+  return `${matched[1]} — ${raw}`;
+}
+
+/** SQLite provenance makes repeated refreshes insert precisely one message for this card/run/seat. */
+export function notifyRemoteFailure(card: TaskCard, reason: string, messageStorePath = defaultMsgStorePath()): void {
+  if (!card.seat || !card.runId || !card.parentHost) return;
+  const log = card.parentHost.log ?? `${card.parentHost.configDir ?? '$HOME/.elanous'}/remote-parents/${card.runId}.log`;
+  const store = openMsgStore(messageStorePath);
+  try {
+    store.appendWithProvenance({ from: 'TC', to: card.seat, kind: 'incident',
+      body: `TA 카드 ${card.id} · 원격 부모 ${card.parentHost.host} 종결 · 사유: ${reason}\n원격 로그: ${log}` },
+    `ta-failure:${card.id}-${card.runId}:${card.seat}`);
+  } finally { store.close(); }
+}