elanous 0.2.27 → 0.2.28

package/src/steward/release-day.ts

@@ -0,0 +1,158 @@
+/** Release-day shadow: observe the scheduled phase without performing its action. */
+import { chmodSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Database } from 'bun:sqlite';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { listSchedules, type ReleaseSchedule } from '../release-loop/release-schedule.js';
+
+export type ReleaseDayPhase = 'gate-mode' | 'carry-p0' | 'cut-run' | 'green-back' | 'none' | 'unmeasured';
+export interface ReleaseDayDecision {
+  version: string;
+  phase: ReleaseDayPhase;
+  dueAt: string | null;
+  scheduleUpdatedAt: string;
+  reason?: string;
+}
+
+/** The release record, rather than publishAt (a planned time), opens green-back. */
+export function decideReleaseDayPhase(schedule: ReleaseSchedule, now: Date, publishedAt: string | null): ReleaseDayDecision {
+  const cut = Date.parse(schedule.cutAt);
+  const land = schedule.landBy ? Date.parse(schedule.landBy) : cut;
+  const gate = cut - 30 * 60_000;
+  const time = now.getTime();
+  let phase: ReleaseDayPhase = 'none';
+  let dueAt: string | null = null;
+  if (publishedAt && time >= Date.parse(publishedAt)) {
+    phase = 'green-back'; dueAt = publishedAt;
+  } else if (time >= cut) {
+    phase = 'cut-run'; dueAt = schedule.cutAt;
+  } else if (time >= land) {
+    phase = 'carry-p0'; dueAt = schedule.landBy;
+  } else if (time >= gate) {
+    phase = 'gate-mode'; dueAt = new Date(gate).toISOString();
+  }
+  return { version: schedule.version, phase, dueAt, scheduleUpdatedAt: schedule.updatedAt };
+}
+
+export type PublicationProbe = { kind: 'published'; at: string } | { kind: 'unpublished' } | { kind: 'unmeasured'; reason: string };
+
+function actualPublicationProbe(version: string, root: string): PublicationProbe {
+  const path = join(root, 'release', version, 'release.json');
+  let raw: string;
+  try { raw = readFileSync(path, 'utf8'); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { kind: 'unpublished' };
+    return { kind: 'unmeasured', reason: 'release-record-read-failed' };
+  }
+  try {
+    const record = JSON.parse(raw) as { version?: unknown; publishedAt?: unknown };
+    if (record.version !== version) return { kind: 'unmeasured', reason: 'release-record-version-mismatch' };
+    if (record.publishedAt == null) return { kind: 'unmeasured', reason: 'release-record-published-at-missing' };
+    if (typeof record.publishedAt !== 'string' || !Number.isFinite(Date.parse(record.publishedAt)))
+      return { kind: 'unmeasured', reason: 'release-record-published-at-invalid' };
+    return { kind: 'published', at: record.publishedAt };
+  } catch { return { kind: 'unmeasured', reason: 'release-record-json-failed' }; }
+}
+
+export interface ReleaseDayScheduleState { publication: PublicationProbe; greenObserved: boolean }
+
+/** A late release and the next gate can both be due; return both instead of starving either. */
+export function selectReleaseDaySchedules(
+  schedules: ReleaseSchedule[], now: Date, state: (version: string) => ReleaseDayScheduleState,
+): ReleaseSchedule[] {
+  const ordered = schedules.filter(s => Number.isFinite(Date.parse(s.cutAt))).sort((a, b) => Date.parse(a.cutAt) - Date.parse(b.cutAt));
+  const time = now.getTime();
+  const dueFuture = ordered.filter(s => {
+    const cut = Date.parse(s.cutAt);
+    const firstDue = Math.min(cut - 30 * 60_000, s.landBy ? Date.parse(s.landBy) : cut);
+    return time < cut && time >= firstDue;
+  });
+  const past = ordered.filter(s => Date.parse(s.cutAt) <= time);
+  const unpublished = past.filter(s => state(s.version).publication.kind === 'unpublished');
+  const unmeasured = past.filter(s => state(s.version).publication.kind === 'unmeasured');
+  const pendingGreen = past.filter(s => {
+    const status = state(s.version);
+    return status.publication.kind === 'published' && !status.greenObserved;
+  });
+  const due = [...dueFuture, ...unpublished, ...unmeasured, ...pendingGreen];
+  if (due.length) return [...new Map(due.map(s => [s.version, s])).values()];
+  const upcoming = ordered.find(s => Date.parse(s.cutAt) > time);
+  return upcoming && Date.parse(upcoming.cutAt) - time <= 24 * 60 * 60_000 ? [upcoming] : [];
+}
+
+export interface ReleaseDayShadowDeps {
+  now?: () => Date;
+  releaseRoot?: string;
+  stateRoot?: string;
+  schedules?: () => ReleaseSchedule[];
+  publishedAt?: (version: string, root: string) => string | null;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+export interface ReleaseDayShadowResult extends ReleaseDayDecision { recorded: boolean }
+
+export function runReleaseDayShadow(deps: ReleaseDayShadowDeps = {}): ReleaseDayShadowResult[] {
+  const now = (deps.now ?? (() => new Date()))();
+  // The graph child's stamped universe also owns its release schedule under --test.
+  const releaseRoot = deps.releaseRoot ?? effectiveInstanceRoot();
+  const schedules = (deps.schedules ?? (() => listSchedules(releaseRoot)))();
+  const log = deps.log ?? ((event: string, data: Record<string, unknown>) => debug.log('steward.release-day', event, data));
+  if (!schedules.length) { log('decision', { phase: 'none', reason: 'no-release-schedule', at: now.toISOString(), recorded: false, mode: 'shadow' }); return []; }
+  const dir = join(deps.stateRoot ?? effectiveInstanceRoot(), 'steward');
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, 'release-day-shadow.sqlite');
+  const db = new Database(path, { create: true, strict: true });
+  try {
+    chmodSync(path, 0o600);
+    db.exec('PRAGMA busy_timeout = 10000');
+    db.exec('CREATE TABLE IF NOT EXISTS phase_observations (version TEXT NOT NULL, phase TEXT NOT NULL, due_at TEXT NOT NULL, observed_at TEXT NOT NULL, schedule_updated_at TEXT NOT NULL, PRIMARY KEY (version, phase))');
+    const states = new Map<string, ReleaseDayScheduleState>();
+    for (const schedule of schedules) {
+      const observed = db.query('SELECT phase FROM phase_observations WHERE version = ?').all(schedule.version) as Array<{ phase: string }>;
+      const injected = deps.publishedAt?.(schedule.version, releaseRoot);
+      states.set(schedule.version, {
+        publication: deps.publishedAt
+          ? injected == null ? { kind: 'unpublished' }
+            : Number.isFinite(Date.parse(injected)) ? { kind: 'published', at: injected }
+              : { kind: 'unmeasured', reason: 'injected-published-at-invalid' }
+          : actualPublicationProbe(schedule.version, releaseRoot),
+        greenObserved: observed.some(row => row.phase === 'green-back'),
+      });
+    }
+    const selected = selectReleaseDaySchedules(schedules, now, version => states.get(version)!);
+    if (!selected.length) { log('decision', { phase: 'none', reason: 'outside-release-window', at: now.toISOString(), recorded: false, mode: 'shadow' }); return []; }
+    const results: ReleaseDayShadowResult[] = [];
+    for (const schedule of selected) {
+      const publication = states.get(schedule.version)!.publication;
+      if (publication.kind === 'unmeasured') {
+        const result: ReleaseDayShadowResult = { version: schedule.version, phase: 'unmeasured', dueAt: null,
+          scheduleUpdatedAt: schedule.updatedAt, reason: publication.reason, recorded: false };
+        log('unmeasured', { ...result, at: now.toISOString(), mode: 'shadow' });
+        results.push(result);
+        continue;
+      }
+      const publishedAt = publication.kind === 'published' ? publication.at : null;
+      const decision = decideReleaseDayPhase(schedule, now, publishedAt);
+      let recorded = false;
+      if (decision.phase !== 'none') {
+      const row = db.query('INSERT OR IGNORE INTO phase_observations (version, phase, due_at, observed_at, schedule_updated_at) VALUES (?, ?, ?, ?, ?)')
+        .run(decision.version, decision.phase, decision.dueAt!, now.toISOString(), decision.scheduleUpdatedAt);
+      recorded = row.changes === 1;
+      }
+      log('decision', { ...decision, at: now.toISOString(), recorded, mode: 'shadow', publishedAt });
+      results.push({ ...decision, recorded });
+    }
+    return results;
+  } finally { db.close(); }
+}
+
+if (import.meta.main) {
+  try {
+    const sinkReady = await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('steward');
+    if (!sinkReady) throw new Error('durable log sink unavailable');
+    const results = runReleaseDayShadow();
+    console.log(`steward release-day shadow: ${results.map(result => `${result.version}:${result.phase}${result.recorded ? ' · recorded' : ''}`).join(', ') || 'none'}`);
+  }
+  catch (error) { console.error(`steward release-day shadow failed: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+}

package/src/steward/resync-tick.ts

@@ -0,0 +1,123 @@
+/** Resync labeled PRs before the steward's TA rejudge node sees their heads. */
+import { debug } from '../debug/log.js';
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { resolveHqLaunchSeat } from '../hq/seats.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { runResyncShadow, type ResyncShadowSummary } from '../loops/orchestrator/resync-shadow.js';
+import { listSchedules, type ReleaseSchedule } from '../release-loop/release-schedule.js';
+
+type ReleaseRunState = 'active' | 'idle' | 'unknown';
+type ReleaseWindowState = 'inside' | 'outside' | 'unknown';
+type ResyncTickResult = { decision: 'ran' | 'failed' | 'skipped-release' | 'skipped-release-window'; summary?: ResyncShadowSummary; reason?: string };
+
+export function resyncPendingPath(): string { return join(effectiveInstanceRoot(), 'steward', 'resync-pending.json'); }
+
+/** The same registered, detached OP checkout used by steward launch; the installed package is not a git repository. */
+export function stewardResyncRepoRoot(
+  resolveSeat: typeof resolveHqLaunchSeat = resolveHqLaunchSeat,
+  configDir: () => string = getElanousConfigDir,
+): string { return resolveSeat('OP', configDir()); }
+
+/** A release may detach the OP checkout. Unknown process state also skips remote branch writes. */
+export function probeReleaseRun(
+  list: () => { status: number | null; stdout?: string; error?: Error } = () => spawnSync('pgrep', ['-f', 'release[[:space:]]+(run|resume)'], { encoding: 'utf8', timeout: 5_000 }),
+  command: (pid: string) => string | null = pid => {
+    const result = spawnSync('ps', ['-p', pid, '-o', 'command='], { encoding: 'utf8', timeout: 5_000 });
+    return result.status === 0 ? result.stdout.trim() : null;
+  },
+): ReleaseRunState {
+  try {
+    const result = list();
+    if (result.error || result.status === null) return 'unknown';
+    if (result.status === 1) return 'idle';
+    if (result.status !== 0) return 'unknown';
+    const pids = (result.stdout ?? '').trim().split(/\s+/).filter(pid => /^\d+$/.test(pid));
+    if (!pids.length) return 'unknown';
+    for (const pid of pids) {
+      const argv = command(pid);
+      if (argv === null) continue;
+      const executable = argv.trim().split(/\s+/)[0]?.split('/').at(-1);
+      if (['bun', 'node', 'eln', 'elanous'].includes(executable ?? '') && /(?:^|\s)release\s+(?:run|resume)(?:\s|$)/.test(argv)) return 'active';
+      // pgrep saw a release-shaped command, but a shell/wrapper cannot prove whether it will launch the CLI.
+    }
+    return 'unknown';
+  } catch { return 'unknown'; }
+}
+
+/** A release cut may start after the process probe; the scheduled cut/publication window is a fixed safety boundary. */
+export function releaseWindowState(
+  nowMs = Date.now(),
+  read: () => ReleaseSchedule[] = listSchedules,
+): ReleaseWindowState {
+  try {
+    const schedules = read();
+    if (!schedules.length) return 'unknown';
+    const rows = schedules.map(row => ({ cut: Date.parse(row.cutAt), publish: Date.parse(row.publishAt ?? '') }));
+    if (rows.some(row => !Number.isFinite(row.cut))) return 'unknown';
+    const latestPast = rows.filter(row => row.cut <= nowMs).sort((a, b) => b.cut - a.cut)[0];
+    if (latestPast && !Number.isFinite(latestPast.publish)) return 'unknown';
+    if (latestPast && nowMs <= latestPast.publish + 60 * 60_000) return 'inside';
+    const next = rows.filter(row => row.cut > nowMs).sort((a, b) => a.cut - b.cut)[0];
+    if (!next || !Number.isFinite(next.publish) || next.publish < next.cut) return 'unknown';
+    return nowMs >= next.cut - 40 * 60_000 ? 'inside' : 'outside';
+  } catch { return 'unknown'; }
+}
+
+export function defaultResyncRun(
+  repoRoot = stewardResyncRepoRoot(),
+  execute: typeof runResyncShadow = runResyncShadow,
+): Promise<ResyncShadowSummary> { return execute(3, { repoRoot }, 'live'); }
+
+export async function resyncTick(
+  run: () => Promise<ResyncShadowSummary> = () => defaultResyncRun(),
+  log: (event: string, data: Record<string, unknown>) => void = (event, data) => debug.log('loop.steward', event, data),
+  pendingPath: string = resyncPendingPath(),
+): Promise<ResyncTickResult> { return resyncTickWithReleaseProbe(run, log, pendingPath, probeReleaseRun); }
+
+export async function resyncTickWithReleaseProbe(
+  run: () => Promise<ResyncShadowSummary>,
+  log: (event: string, data: Record<string, unknown>) => void,
+  pendingPath: string,
+  releaseProbe: () => ReleaseRunState,
+  windowProbe: () => ReleaseWindowState = releaseWindowState,
+): Promise<ResyncTickResult> {
+  let result: ResyncTickResult;
+  try {
+    const release = releaseProbe();
+    if (release !== 'idle') {
+      result = { decision: 'skipped-release', reason: release === 'active' ? 'release run active' : 'release process probe unavailable' };
+    } else {
+      const window = windowProbe();
+      if (window !== 'outside') {
+        result = { decision: 'skipped-release-window', reason: window === 'inside' ? 'scheduled release window' : 'release schedule unavailable' };
+      } else {
+        const summary = await run();
+        if (summary.saved > 0) {
+          mkdirSync(dirname(pendingPath), { recursive: true });
+          writeFileSync(pendingPath, JSON.stringify({ savedAt: new Date().toISOString() }));
+        }
+        result = { decision: 'ran', summary };
+      }
+    }
+  }
+  catch (error) { result = { decision: 'failed', reason: (error instanceof Error ? error.message : String(error)).slice(-300) }; }
+  try { log('resync-tick', { ...result }); }
+  catch (error) {
+    result = { decision: 'failed', reason: `log failed: ${error instanceof Error ? error.message : String(error)}`.slice(-300) };
+    console.error(`steward resync: ${result.reason}`);
+  }
+  return result;
+}
+
+if (import.meta.main) {
+  let sinkReady = false;
+  try { sinkReady = await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('steward'); }
+  catch (error) { console.error(`steward resync: log sink registration failed — ${error instanceof Error ? error.message : String(error)}`); }
+  // A missing durable sink must not precede a remote branch update.
+  const result = sinkReady ? await resyncTick() : { decision: 'failed' as const, reason: 'log sink unavailable' };
+  console.log(`steward resync: ${result.decision}${result.reason ? ` — ${result.reason}` : ''}`);
+  process.exitCode = 0;
+}

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