elanous 0.2.34 → 0.2.36

package/src/cli/release-cli.ts

@@ -8,7 +8,7 @@
 //   elanous release run     --version <x.y.z> [--prerelease rc] [--main-cut | --cut-commit <sha>] [--publish-at <iso>] [--gate-executor <pod|host> [--gate-host <ssh-host>]] [--dry-run] [--json] [--if-ready] [--force-new]
 //   elanous release resume  --run <runId> --from <node> [--waive <node> --reason <text>] [--accepted-regressions <json>] [--gate-executor <pod|host> [--gate-host <ssh-host>]] [--gate-pod-pool <pool>] [--json]
 //   elanous release auto-start [--window-minutes <n>] [--apply] [--json]
-//   elanous release rehearsal tick [--apply] [--checkout <dir>] [--shards <n>] [--remote <host>] [--json]
+//   elanous release rehearsal tick [--apply] [--checkout <dir>] [--shards <n>] [--remote <host>] [--recovery-run <id>] [--json]
 //   elanous release preflight --version <x.y.z> [--publish-at <iso>] [--json]   (컷 − 60분 main export 포함 사전 점검 · 읽기 전용 · ⛔ 있으면 exit 1)
 //   elanous release cut-branch --version <x.y.z> --base <sha> --pick <sha>... [--dry-run]
 //
@@ -17,7 +17,7 @@
 // ⛔ prepare 는 «네트워크에 아무것도 쓰지 않는다»(공개 저장소를 «읽기»로 clone 만 한다) — 쓰는 것은 publish 뿐이고 `--yes` 가 있어야 한다.
 //    공개는 되돌릴 수 없다(그 판은 영구히 공개 라이선스).
 // ⛔ 공개본은 «원본 매니페스트»(`release/public-export.yaml`)대로만 만든다 — 매매 실행 코드는 그 매니페스트가 이미 뺀다(🅢 #20529).
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -27,10 +27,10 @@ import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { envLiteral } from '../platform/env-literal.js';
-import { getUserConfig, userConfigPath } from '../user-config.js';
-import { addItem, cellsReferencingDoc, claimItem, decodeClaimHistoryEntry, devVersion, inspectChecklistTargetPaths, lintDocRefs, listChecklist, normalizeRefs, noteDispatchSkip, ownerMatches, parseOwner, parityGap, refRoots, removeItem, renderRefsStatus, seedFromRoadmap, setItem, summarizeChecklist, type ChecklistStatus, type ChecklistDisposition, type ChecklistKind, type ChecklistDispatchKind } from '../release-loop/checklist.js';
+import { getUserConfig } from '../user-config.js';
+import { addItem, cellsReferencingDoc, claimItem, decodeClaimHistoryEntry, inspectChecklistTargetPaths, lintDocRefs, listChecklist, normalizeRefs, noteDispatchSkip, ownerMatches, parseOwner, parityGap, refRoots, removeItem, renderRefsStatus, seedFromRoadmap, setItem, type ChecklistStatus, type ChecklistDisposition, type ChecklistKind, type ChecklistDispatchKind } from '../release-loop/checklist.js';
 import * as features from '../release-loop/feature-store.js';
-import { evidencePlan, landedButYellow, type MergedChecklistPr } from '../release-loop/landed-but-yellow.js';
+import { evidencePlan, fetchMergedChecklistPrs, landedButYellow, type MergedPrRunner } from '../release-loop/landed-but-yellow.js';
 import { formatSchedule, getSchedule, listSchedules, setSchedule } from '../release-loop/release-schedule.js';
 import { mergedPrsLast24h, placeCell, planPullForward, pullForwardPlacementConfig, rebalance, seatMove, type PlacementPriority } from '../release-loop/placement.js';
 import { readTrafficSignal } from '../seat-loop/traffic-signal.js';
@@ -43,12 +43,12 @@ import { isIsolatedLedgerWriteRoot } from '../hq/ledger-write-target.js';
 import { runUnattendedRelease, type UnattendedReleaseDeps } from '../../scripts/release-loop/unattended-release.js';
 import { publishAtError } from '../../scripts/release-loop/publish-at.js';
 import { cutReleaseBranch } from '../../scripts/release-loop/cut-branch.js';
-import { planResumeReleaseRun, resumeReleaseRun } from '../../scripts/release-loop/resume-release.js';
+import { planResumeReleaseRun, resumeReleaseRun, type ResumeReleaseDeps } from '../../scripts/release-loop/resume-release.js';
 import type { AcceptedRegression } from '../../scripts/release-loop/resume.js';
 import type { PrereleaseKind } from '../../scripts/release-loop/release-version.js';
 import { releaseReadiness } from '../../scripts/release-loop/release-readiness.js';
 import { runReleaseIfReady } from './release-run-if-ready.js';
-import { ReleaseRunClaimConflict, findActiveReleaseRun, readActiveForceReleaseRun, readReleaseRunLock, withDirectReleaseRunLock, withForceReleaseRunMarker } from './release-single-flight.js';
+import { ReleaseRunClaimConflict, findActiveReleaseRun, readActiveForceReleaseRun, isPidAlive, readReleaseRunLock, withDirectReleaseRunLock, withForceReleaseRunMarker } from './release-single-flight.js';
 import { formatPreflight, releasePreflight } from '../../scripts/release-loop/preflight.js';
 import { defaultReleaseGraphRunsRoot, formatPublishProposal, measurePublishWindow, proposePublishAt, publishWindowWarning } from '../../scripts/release-loop/publish-window.js';
 import { autoStartScheduledRelease, type AutoStartDeferral } from '../release-loop/auto-start.js';
@@ -57,9 +57,11 @@ import { landingFreezeMessage, LandingFrozenError, readLandingFreeze } from '../
 import { formatLightRc, runLightRc, type LightRcDeps } from '../release-loop/light-rc.js';
 import { applyWatchList, formatGateHistory, gateHistory, ghMergedPrs } from '../../scripts/release-loop/gate-history.js';
 import { registerRfcCommands } from './rfc-cli.js';
+import { checklistCodenames, checklistVersion, isReleaseVersion, readChecklistContext, registerChecklistReadCommands } from './release-checklist-read-cli.js';
+
+export { isReleaseVersion } from './release-checklist-read-cli.js';
 
 export const DEFAULT_PUBLIC_REPO = 'ElanvitalAI/elanous';
-const SEMVER = /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/;
 
 export interface RunResult { status: number | null; stdout: string; stderr: string }
 export type Runner = (command: string, args: readonly string[], cwd: string, opts?: { env?: NodeJS.ProcessEnv; input?: string }) => RunResult;
@@ -69,7 +71,6 @@ export const defaultRunner: Runner = (command, args, cwd, opts = {}) => {
   return { status: r.status, stdout: r.stdout ?? '', stderr: r.error ? String(r.error) : (r.stderr ?? '') };
 };
 
-export function isReleaseVersion(version: string): boolean { return SEMVER.test(version); }
 export function isPrerelease(version: string): boolean { return version.includes('-'); }
 
 export interface ReleaseManifest {
@@ -535,45 +536,12 @@ function warnChecklistTargetPaths(input: { title: string; evidence?: string; ref
   }
 }
 
-function checklistCodenames(): Record<string, string> {
-  const path = getElanousConfigDirOverride() ? join(effectiveInstanceRoot(), 'config.json') : userConfigPath();
-  if (!existsSync(path)) return {};
-  const raw = JSON.parse(readFileSync(path, 'utf8')) as { release?: { codenames?: Record<string, string> } };
-  return raw.release?.codenames ?? {};
-}
-
-function checklistVersion(input: string | undefined, codenames: Record<string, string>): string {
-  const v = input ?? devVersion().replace(/-dev\.\d+$/, '');
-  const resolved = isReleaseVersion(v) ? v : Object.entries(codenames).find(([, name]) => name === v)?.[0] ?? v;
-  if (!isReleaseVersion(resolved)) throw new CliUserError(`체크리스트 판 또는 별칭이 아니다: ${v}`);
-  return resolved;
-}
-
-async function checklistOutput(v: string, codenames: Record<string, string>, mode: 'list' | 'status', json?: boolean, owner?: string): Promise<void> {
-  if (owner !== undefined) parseOwner(owner);
-  const snapshot = listChecklist(v);
-  const data = owner === undefined ? snapshot : { ...snapshot, items: snapshot.items.filter((item) => ownerMatches(item.owner, owner)) };
-  const summary = summarizeChecklist(data);
-  const parity = data.items.flatMap((item) => {
-    const why = item.kind === 'screen' ? parityGap(item.evidence) : null;
-    return why ? [{ id: item.id, why }] : [];
-  });
-  const result = { ...data, codename: codenames[v] ?? '', ...summary, parity };
-  for (const { id, why } of parity) debug.log('release.checklist', 'parity-warning', { version: v, id, why });
-  if (json) { await writeStdoutJson(`${JSON.stringify(result)}\n`); return; }
-  console.log(`⚠ 짝 경고 ${parity.length}: ${parity.map(({ id }) => id).join(', ') || '없음'}`);
-  console.log(`${v}${result.codename ? ` (${result.codename})` : ''} · 공개 ${data.released || '없음'} · 개발 ${data.dev}`);
-  if (mode === 'list') {
-    for (const item of data.items) console.log(`${({ green: '🟢', yellow: '🟡', red: '🔴', done: '✅' } as const)[item.status]} ${item.id} ${item.title}${item.owner ? ` · ${item.owner}` : ''}${item.ceoMinutes !== undefined ? ` · 대표 손 ${item.ceoMinutes}분${item.ceoDate ? ` (${item.ceoDate})` : ''}` : ''}`);
-  } else {
-    console.log(`🟢 ${summary.green} · 🟡 ${summary.yellow} · 🔴 ${summary.red} · ✅ ${summary.done}`);
-    console.log(`🔴 칸: ${summary.blocked.join(', ') || '없음'}`);
-    console.log(`담당별: ${Object.entries(summary.byOwner).map(([owner, count]) => `${owner} ${count}`).join(' · ') || '없음'}`);
-  }
-}
-
 export interface LandedButYellowDeps {
   run?: Runner;
+  /** Async gh for the merged-PR windows; wins over `run` (tests inject delay). */
+  runAsync?: MergedPrRunner;
+  /** logs.db sink for the stage timings; the default registers only on the real (uninjected) gh path. */
+  registerLogSink?: () => Promise<unknown>;
   checklist?: typeof listChecklist;
   now?: () => Date;
   evidenceAdd?: typeof features.evidenceAdd;
@@ -581,45 +549,18 @@ export interface LandedButYellowDeps {
   released?: typeof features.releasedVersion;
 }
 
-const MERGED_PR_LIMIT = 400;
-
-function mergedChecklistPrs(since: string, now: Date, run: Runner): { prs: MergedChecklistPr[]; truncated: boolean } {
-  const cwd = process.cwd();
-  const fetch = (lower: string, upper?: string, limit = MERGED_PR_LIMIT): MergedChecklistPr[] => {
-    const search = `merged:>=${lower}${upper ? ` merged:<${upper}` : ''}`;
-    const raw = must(run('gh', ['pr', 'list', '--state', 'merged', '--search', search, '--limit', String(limit), '--json', 'number,title,body,mergedAt'], cwd), '병합 PR 조회(gh)');
-    const page = JSON.parse(raw) as MergedChecklistPr[];
-    if (!Array.isArray(page)) throw new Error('병합 PR 조회(gh): 배열이 아니다');
-    return page;
-  };
-  const unique = new Map<number, MergedChecklistPr>();
-  let truncated = false;
-  const collect = (page: MergedChecklistPr[]) => {
-    for (const pr of page) if (!unique.has(pr.number)) unique.set(pr.number, pr);
-  };
-  const first = fetch(since);
-  if (first.length < MERGED_PR_LIMIT) return { prs: first, truncated: false };
-  const lower = Date.parse(`${since}T00:00:00Z`);
-  const upper = Math.max(lower + 1000, Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1));
-  const visit = (start: number, end: number): void => {
-    const from = new Date(start).toISOString();
-    const to = new Date(end).toISOString();
-    const page = fetch(from, to);
-    if (page.length < MERGED_PR_LIMIT) { collect(page); return; }
-    if (end - start <= 1000) {
-      // The second-precision search cannot be subdivided; probe one extra row to distinguish exactly 400 from a real truncation.
-      const probe = fetch(from, to, MERGED_PR_LIMIT + 1);
-      collect(probe.slice(0, MERGED_PR_LIMIT));
-      if (probe.length > MERGED_PR_LIMIT) truncated = true;
-      return;
-    }
-    const middle = start + Math.floor((end - start) / 2000) * 1000;
-    visit(start, middle);
-    visit(middle, end);
-  };
-  visit(lower, upper);
-  return { prs: [...unique.values()], truncated };
-}
+/** A spawn failure (gh missing from PATH) resolves `status: null` with the error text — the shape the sync runner gave. */
+const defaultMergedPrRunner: MergedPrRunner = (command, args, cwd) => new Promise((resolve) => {
+  const out: Buffer[] = [], err: Buffer[] = [];
+  const failed = (error: unknown) => resolve({ status: null, stdout: Buffer.concat(out).toString('utf8'), stderr: String(error) });
+  let child: ReturnType<typeof spawn>;
+  try { child = spawn(command, [...args], { cwd, env: process.env, stdio: ['ignore', 'pipe', 'pipe'] }); }
+  catch (error) { failed(error); return; }
+  child.stdout?.on('data', (chunk: Buffer) => out.push(chunk));
+  child.stderr?.on('data', (chunk: Buffer) => err.push(chunk));
+  child.on('error', failed);
+  child.on('close', (code) => resolve({ status: code, stdout: Buffer.concat(out).toString('utf8'), stderr: Buffer.concat(err).toString('utf8') }));
+});
 
 function printLandedRows(rows: ReturnType<typeof landedButYellow>, items: ReturnType<typeof listChecklist>['items']): void {
   const updatedAtById = new Map(items.map((item) => [item.id, item.updatedAt]));
@@ -647,7 +588,7 @@ function compareReleaseVersions(a: string, b: string): number {
   return 0;
 }
 
-export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}, landedDeps: LandedButYellowDeps = {}, hqDeps: HqDeps = {}, lightRcDeps: LightRcDeps = {}, rehearsalDeps: RehearsalDeps = {}): void {
+export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}, landedDeps: LandedButYellowDeps = {}, hqDeps: HqDeps = {}, lightRcDeps: LightRcDeps = {}, rehearsalDeps: RehearsalDeps = {}, resumeDeps: ResumeReleaseDeps = {}): void {
   registerRfcCommands(program);
   const release = program.command('release').description('공개 배포 한 판 — prepare(로컬) → publish(--yes) → verify (docs/manual/MANUAL-versioning-and-release-2026-09-25.md)');
   const schedule = release.command('schedule').description('판별 컷·착지 마감 조회·갱신');
@@ -789,11 +730,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .option('--json', '결과 JSON')
     .option('--hq-override', '본부 임대 거부를 관측하며 수동 우회');
   const mayWrite = (cmd: Command) => mayWriteLedger(`release checklist ${cmd.name()}`, Boolean(cmd.optsWithGlobals().hqOverride), releaseLedgerRoot());
-  const context = (cmd: Command) => {
-    const opts = { ...(cmd.parent?.parent?.opts() as { version?: string; json?: boolean }), ...(cmd.parent?.opts() as { version?: string; json?: boolean }), ...(cmd.opts() as { version?: string; json?: boolean }) };
-    const codenames = checklistCodenames();
-    return { version: checklistVersion(opts.version, codenames), codenames, json: opts.json };
-  };
+  const context = readChecklistContext;
   const withContext = (cmd: Command) => cmd.option('--version <v>', '판 또는 별칭').option('--json', '결과 JSON').option('--hq-override', '본부 임대 거부를 관측하며 수동 우회');
   const actor = () => process.env.ELANOUS_TRACK || 'cli';
   withContext(checklist.command('rubric').description('루브릭 채점(읽기 전용)'))
@@ -843,20 +780,30 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
       console.log(renderRefsStatus(rows));
       console.log(`칸 ${rows.length} · 🟢 ${byStatus.green} · 🟡 ${byStatus.yellow} · 🔴 ${byStatus.red} · ✅ ${byStatus.done}`);
     });
-  withContext(checklist.command('list').description('모든 칸')).option('--owner <owner>', '자리 또는 하위 자리로 거르기').action(async (opts: { owner?: string }, cmd: Command) => {
-    const { version, codenames, json } = context(cmd);
-    await checklistOutput(version, codenames, 'list', json, opts.owner);
-  });
-  withContext(checklist.command('status').description('상태 요약')).option('--owner <owner>', '자리 또는 하위 자리로 거르기').action(async (opts: { owner?: string }, cmd: Command) => {
-    const { version, codenames, json } = context(cmd);
-    await checklistOutput(version, codenames, 'status', json, opts.owner);
-  });
+  registerChecklistReadCommands(checklist);
   withContext(checklist.command('landed-but-yellow').description('병합 PR 이 있지만 노랑·빨강인 칸(기본 읽기 전용)'))
     .option('--owner <owner>', '자리 또는 하위 자리로 거르기')
     .option('--open', '미발행 일정 판 중 칸이 있는 판 전부')
     .option('--apply-evidence', '확실한 PR 짝의 근거를 붙인다(상태는 그대로)')
     .option('--dry-run', '근거 추가 없이 계획만 출력')
     .action(async (opts: { owner?: string; open?: boolean; applyEvidence?: boolean; dryRun?: boolean }, cmd: Command) => {
+      // Stage timings (LANDED-YELLOW-FAST): which step ate the time — `elanous logs --category release.landed-yellow`.
+      let stageAt = performance.now();
+      const stage = (name: string, data: Record<string, unknown>) => {
+        const at = performance.now();
+        debug.log('release.landed-yellow', 'stage', { stage: name, ms: Math.round(at - stageAt), ...data });
+        stageAt = at;
+      };
+      // A standalone CLI's debug.log reaches logs.db only through a registered sink (pr land #6701 lesson). Fail-open, 1s cap.
+      const registerLogSink = landedDeps.registerLogSink ?? (landedDeps.run || landedDeps.runAsync ? undefined
+        : async () => (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('release-landed-yellow'));
+      if (registerLogSink) {
+        let sinkTimer: ReturnType<typeof setTimeout> | undefined;
+        try {
+          await Promise.race([registerLogSink(), new Promise<void>((resolve) => { sinkTimer = setTimeout(resolve, 1000); })]);
+        } catch { /* observability is fail-open */ } finally { clearTimeout(sinkTimer); }
+      }
+      stageAt = performance.now();
       try {
         const inherited = cmd.parent?.opts() as { version?: string; json?: boolean } | undefined;
         const local = cmd.opts() as { version?: string; json?: boolean };
@@ -873,6 +820,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
           .filter(({ version }) => isReleaseVersion(version) && (!released || compareReleaseVersions(version, released) > 0))
           .sort((a, b) => compareReleaseVersions(a.version, b.version))
           .map(({ version }) => (landedDeps.checklist ?? listChecklist)(version)).filter((snapshot) => snapshot.items.length > 0);
+        stage('snapshots', { n: openSnapshots.length, schedules: schedules.length });
         if (opts.open && !openSnapshots.length) {
           if (json) await writeStdoutJson('[]\n'); else console.log('열린 판 없음');
           return;
@@ -887,7 +835,10 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
           .map((item) => Date.parse(item.updatedAt)).filter((at) => Number.isFinite(at)));
         const since = updated.length ? new Date(updated.reduce((earliest, at) => Math.min(earliest, at))).toISOString().slice(0, 10)
           : new Date(now.getTime() - 7 * 86_400_000).toISOString().slice(0, 10);
-        const { prs, truncated } = mergedChecklistPrs(since, now, landedDeps.run ?? defaultRunner);
+        const syncRun = landedDeps.run;
+        const runAsync: MergedPrRunner = landedDeps.runAsync ?? (syncRun ? async (command, args, cwd) => syncRun(command, args, cwd) : defaultMergedPrRunner);
+        const { prs, truncated, calls } = await fetchMergedChecklistPrs(since, now, runAsync, process.cwd());
+        stage('merged-prs', { n: prs.length, calls, since, truncated });
         const results: Array<{ version: string; rows?: ReturnType<typeof landedButYellow>; plan?: ReturnType<typeof evidencePlan> }> = [];
         let totalAdded = 0, totalSkipped = 0;
         for (const snapshot of snapshots) {
@@ -914,6 +865,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
             results.push({ version, rows });
           }
         }
+        stage('match', { n: results.reduce((sum, result) => sum + (result.rows?.length ?? result.plan?.length ?? 0), 0), versions: snapshots.length, prs: prs.length });
         if (opts.open) {
           if (opts.applyEvidence && !opts.dryRun) debug.log('release.checklist', 'evidence-synced', { versions: snapshots.map(({ version }) => version), added: totalAdded, skippedMention: totalSkipped });
           if (!json) console.log(`판 ${snapshots.length} · 붙임 합 ${totalAdded} · 건너뜀(언급만) 합 ${totalSkipped}`);
@@ -1326,7 +1278,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
           const gate = plan.gatePlan.mode === 'not-run' ? 'gate 실행 없음'
             : plan.gatePlan.mode === 'partial' ? `부분 gate 계획 ${plan.partial.requested && plan.partial.applied ? `${plan.partial.files}파일` : '미상'}`
               : `전체 gate${plan.gatePlan.reason ? ` (${plan.gatePlan.reason})` : ''}`;
-          log(`· 재개 preflight 통과 · ${plan.version} · ${plan.fromNode}부터 · tip ${plan.tip.to.slice(0, 12)}${plan.tip.changed ? ` (기록 tip ${plan.tip.from.slice(0, 12)}에서 이동)` : ''} · ${gate} · 시도 ${plan.nextAttempt}/${plan.attemptLimit} · 실행·원장 변경 없음`);
+          log(`· 재개 preflight 통과 · ${plan.version} · ${plan.fromNode}부터 · tip ${plan.tip.to.slice(0, 12)}${plan.tip.changed ? ` (기록 tip ${plan.tip.from.slice(0, 12)}에서 이동)` : ''} · ${gate} · ${plan.priorCountKnown ? `시도 ${plan.nextAttempt}` : `새 원장 기록 ${plan.nextAttempt} (이전 횟수 미측정)`} · 실행·원장 변경 없음`);
           return plan;
         }
         const result = await resumeReleaseRun(resumeOptions, { onSource: log });
@@ -1389,16 +1341,38 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .option('--checkout <dir>', '깨끗한 git 체크아웃(기본 ELANOUS_REHEARSAL_GIT_CWD)')
     .option('--shards <n>', '시험 분할 수')
     .option('--remote <host>', '게이트 호스트')
+    .option('--recovery-run <id>', '기존 실패 release-loop 런을 gate에서 명시적으로 재개(기본 예약 틱과 분리)')
     .option('--json', '결과 한 줄 JSON(stdout)')
-    .action(async (o: { apply?: boolean; checkout?: string; shards?: string; remote?: string; json?: boolean }) => {
+    .action(async (o: { apply?: boolean; checkout?: string; shards?: string; remote?: string; recoveryRun?: string; json?: boolean }) => {
       await jsonAction(o.json, async (log) => {
         const ledgerRoot = scheduleLedgerRoot();
+        if (o.recoveryRun !== undefined) {
+          if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(o.recoveryRun)) throw new Error('release rehearsal recovery: invalid run id');
+          if (o.shards !== undefined || o.remote !== undefined) throw new Error('release rehearsal recovery: --shards and --remote are unsupported; use the saved gate settings');
+          const resumeOptions = { runId: o.recoveryRun, from: 'gate', commandRoot: o.checkout ?? process.cwd() };
+          if (!o.apply) {
+            const plan = await planResumeReleaseRun(resumeOptions, resumeDeps);
+            log(`· 리허설 복구 사전점검 ${plan.preflight} · run ${plan.runId} · ${plan.version} · from ${plan.fromNode} · gate ${plan.gatePlan.mode}`);
+            return { recovery: 'planned', ...plan };
+          }
+          if (!mayWriteLedger('release rehearsal recovery', false, ledgerRoot)) throw new Error('release rehearsal recovery: ledger write denied');
+          const result = await resumeReleaseRun(resumeOptions, resumeDeps);
+          log(`· 리허설 복구 완료 · run ${o.recoveryRun} · ${result.state.status} · gate에서 재개`);
+          return { recovery: 'resumed', runId: o.recoveryRun, status: result.state.status, ...result };
+        }
         if (o.apply && !mayWriteLedger('release rehearsal tick', false, ledgerRoot)) throw new Error('release rehearsal tick: ledger write denied');
-        // The tick reports a preflight shard shortage as an unmeasured attempt; its released stage can be claimed on the next CLI tick.
         const result = await runRehearsalTick({ apply: o.apply, checkout: o.checkout, shards: o.shards === undefined ? undefined : Number(o.shards), remote: o.remote, ledgerRoot }, rehearsalDeps);
         log(`· 리허설 ${result.status}${'version' in result ? ` ${result.version}` : ''}${result.status === 'due' ? ` · 실행 ${result.run ?? '-'} · 건너뜀 ${result.supersede.join(', ') || '-'}` : ''}`);
+        for (const stamp of result.stamps ?? []) {
+          if (stamp.outcome === 'unmeasured' && !stamp.result && stamp.shardPlan && (stamp.shardPlan.testFiles === 0 || stamp.shardPlan.gatePlanShards === null))
+            log(`· 리허설 ${stamp.version} ${stamp.step} · ${stamp.summary} · stage claim 해제 · 다음 tick 재시도`);
+        }
         return result;
-      }, (result) => !result.notificationFailures && !result.stamps?.some((stamp) => !['ok', 'superseded'].includes(stamp.outcome)));
+      // Recovery results carry no tick fields; the widened view keeps the same runtime verdict (main's tsc touch-clean).
+      }, (raw) => {
+        const result = raw as { status?: string; notificationFailures?: number; stamps?: readonly { outcome: string }[] };
+        return result.status !== 'failed' && !result.notificationFailures && !result.stamps?.some((stamp) => !['ok', 'superseded'].includes(stamp.outcome));
+      });
     });
   release.command('auto-start')
     .description('판 일정의 컷 창에서 릴리스 시작을 미리 본다 · --apply 로 release run --if-ready 실행')
@@ -1407,20 +1381,32 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .option('--json', '결과 한 줄 JSON(stdout)')
     .action(async (o: { windowMinutes: string; apply?: boolean; json?: boolean }) => {
       await jsonAction(o.json, async (log) => {
+        // Same authority as `release run`'s refusal: graph-run ledger, then a live force marker, then a run.lock whose
+        // pid is alive — the same liveness releaseReadiness refuses on, so the reason line can name the lock's startedAt.
+        const activeRun = (version: string, ledgerRoot: string) => {
+          const live = findActiveReleaseRun(version, ledgerRoot) ?? readActiveForceReleaseRun(version, ledgerRoot);
+          if (live) return live;
+          const lock = readReleaseRunLock(version, ledgerRoot);
+          return lock?.pid !== undefined && Number.isSafeInteger(lock.pid) && lock.pid > 0 && isPidAlive(lock.pid)
+            ? { runId: 'pending', pid: lock.pid, startedAt: lock.startedAt ?? 'unknown' } : undefined;
+        };
         const result = await autoStartScheduledRelease({
-          windowMinutes: Number(o.windowMinutes), apply: o.apply, ledgerRoot: scheduleLedgerRoot(),
+          windowMinutes: Number(o.windowMinutes), apply: o.apply, ledgerRoot: scheduleLedgerRoot(), activeRun,
           readiness: (version, ledgerRoot, now) => releaseReadiness(version, { ledgerRoot, now: () => now, checklist: releaseRunDeps.checklist }),
           launch: async (version, launchOptions) => {
             const ran = await runAction({ version, ifReady: true, publishAt: launchOptions?.publishAt, json: false }, log);
             if (ran && typeof ran === 'object' && ran.deferred) return ran;
+            // A run that appeared between readiness and launch is the same refusal, with its identity.
+            if (ran === false && activeRun(version, scheduleLedgerRoot())) return { deferred: true, reason: 'already-running' };
             if (ran !== true) throw new Error(`release run 미시작 또는 실패: ${version}`);
           },
         });
         if (result.status === 'planned') log(`· 미리 보기 ${result.version} · 컷 ${result.cutAt} · 실행하려면 --apply`);
         else if (result.status === 'started') log(`▶ 릴리스 시작 ${result.version} · 컷 ${result.cutAt}${result.publishAt ? ` · 발행 ${result.publishAt}` : ''}`);
         else if (result.status === 'skipped') log(`· 릴리스 연기 ${result.version} · ${result.reason}`);
+        else if (result.status === 'already-running') console.error(`⛔ 릴리스 이미 실행 중 ${result.version} · runId=${result.runId} pid=${result.pid} startedAt=${result.startedAt} · auto-start 거부`);
         else log('· 선택할 컷 없음');
         return result;
-      }, () => true);
+      }, (result) => result.status !== 'already-running');
     });
 }

package/src/cli/release-single-flight.ts

@@ -16,7 +16,7 @@ export class ReleaseRunClaimConflict extends Error {
   constructor() { super('release run claim already exists'); }
 }
 
-function isPidAlive(pid: number): boolean {
+export function isPidAlive(pid: number): boolean {
   try { process.kill(pid, 0); return true; }
   catch (error) {
     if ((error as NodeJS.ErrnoException).code === 'ESRCH') return false;

package/src/cli/remote-resolve.ts

@@ -203,7 +203,7 @@ function hasFlag(args: readonly string[], name: string): boolean {
  *  읽어 `<값>` 을 받는 것이 전부 여기 있는지 확인한다(`root value-taking flags are enumerated`).
  *  ⇒ 루트에 값 받는 플래그를 더하면 그 시험이 «먼저» 깨진다. */
 // ⭐ `--name <name>` = 대시보드 TUI 별명(dashboard-name-flag.ts) — 값이 다음 토큰이라 `elanous --name op -r` 의 `-r` 이 루트로 남게 센다.
-export const ROOT_FLAGS_TAKING_VALUE = new Set(['--remote', '--config-dir', '--name']);
+export const ROOT_FLAGS_TAKING_VALUE = new Set(['--remote', '--config-dir', '--name', '--tui']);
 
 /** 이 토큰이 루트 «선행 플래그 구간» 안에 있나 — 즉 전역 선처리가 소유하나.
  *  ⛔ 없으면 다른 명령의 `-r` 을 «탈취»한다(`autopilot link … -r friend`).

package/src/cli/root-tui-entry.ts

@@ -0,0 +1,48 @@
+export interface RootTuiEntry {
+  readonly args: string[];
+  readonly entry: 'classic' | 'next';
+  readonly explicit: boolean;
+  readonly error?: string;
+}
+
+/** A configured remote still needs the dashboard transport until next supports it. */
+export function effectiveRootTuiEntry(root: RootTuiEntry, hasRemote: boolean): 'classic' | 'next' {
+  return hasRemote && !root.explicit ? 'classic' : root.entry;
+}
+
+/** Extract a root TUI flag only from the launch-option prefix. */
+export function extractRootTuiEntry(rawArgs: readonly string[]): RootTuiEntry {
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i]!;
+    if (arg === '--') break;
+    if (arg === '--legacy') {
+      const args = [...rawArgs.slice(0, i), ...rawArgs.slice(i + 1)];
+      const other = extractRootTuiEntry(args);
+      return other.explicit
+        ? { args, entry: 'classic', explicit: true, error: 'elanous: choose only one of --legacy or --tui' }
+        : { args, entry: 'classic', explicit: true };
+    }
+    if (arg === '--tui' || arg.startsWith('--tui=')) {
+      const inline = arg.startsWith('--tui=');
+      const value = inline ? arg.slice('--tui='.length) : rawArgs[i + 1];
+      if (value !== 'classic' && value !== 'next') {
+        return { args: [...rawArgs], entry: 'classic', explicit: true, error: 'elanous: --tui expects classic or next' };
+      }
+      const args = [...rawArgs.slice(0, i), ...rawArgs.slice(i + (inline ? 1 : 2))];
+      const other = extractRootTuiEntry(args);
+      return other.explicit
+        ? { args, entry: value, explicit: true, error: 'elanous: choose only one of --legacy or --tui' }
+        : { args, entry: value, explicit: true };
+    }
+    // These are the value-taking root launch flags still present here:
+    // --config-dir/--test are removed during module initialization, while
+    // --local, --continue and dashboard layout flags have no value.
+    if (arg === '--resume' || arg === '--name' || arg === '--remote') {
+      if (rawArgs[i + 1] && !rawArgs[i + 1]!.startsWith('-')) i++;
+      continue;
+    }
+    if (!arg.startsWith('-')) break;
+  }
+  // Bare launch opens the classic dashboard; the next TUI is opt-in via `--tui next`.
+  return { args: [...rawArgs], entry: 'classic', explicit: false };
+}

package/src/cli/sim-cli.ts

@@ -15,4 +15,26 @@ export function registerSimCommands(program: Command): void {
         process.exitCode = 2;
       }
     });
+  // SIM-EVENT-MONKEY — 사건 주입(L0). ⛔ 모듈은 액션 안에서만 불러온다(다른 명령 기동 경로에 안 올라오게).
+  sim.command('emit <kind>')
+    .allowExcessArguments(false)
+    .description('격리 test 우주 원장·logs.db 에 주입 사건을 쓴다(L0) — 종류는 `sim kinds`')
+    .option('--run <id>', '기존 런 원장에 덧붙인다(없으면 새 run-<uuid>)')
+    .option('--variant <variant>', 'same-cell 전용: allowed | refused')
+    .option('--json', '구조화 출력')
+    .action(async (kind: string, opts: { run?: string; variant?: string; json?: boolean }) => {
+      const { runEventMonkeyCli } = await import('../ux-sim/event-monkey.js');
+      const out = runEventMonkeyCli({ kindName: kind, json: opts.json === true,
+        ...(opts.run ? { runId: opts.run } : {}), ...(opts.variant ? { variant: opts.variant } : {}) });
+      for (const line of out.stdout) console.log(line);
+      for (const line of out.stderr) console.error(line);
+      process.exitCode = out.code;
+    });
+  sim.command('kinds')
+    .description('주입할 수 있는 사건 종류 · 별칭 · 읽어야 할 소비자')
+    .option('--json', '구조화 출력')
+    .action(async (opts: { json?: boolean }) => {
+      const { renderEventMonkeyKinds } = await import('../ux-sim/event-monkey.js');
+      console.log(renderEventMonkeyKinds(opts.json === true).join('\n'));
+    });
 }

package/src/cli/tasks-card-show.ts

@@ -0,0 +1,162 @@
+import { debug } from '../debug/log.js';
+import { cardPrNumber, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, nextMoveFor, readTaskAgentState, readTaskCard, shellQuote, taskAgentStatePath as taskStatePathDefault, taskCardLabelContext, type TaskCard } from '../task-agent/task-hand.js';
+import { RUN_TAG_KEYS, runIdentityFieldText, runPriorityClass } from '../task-agent/run-identity.js';
+import { readCardSalvageBranch, refreshCardRunBinding } from '../task-agent/card-evidence.js';
+import { captureReviewResults } from '../task-agent/review-result-capture.js';
+import type { TasksCliDeps } from './tasks-cli.js';
+import { registerTaskAgentSink } from './tasks-read-cli.js';
+
+/**
+ * CLI-ENTRY-LAZY — `tasks show ta-…`(TASK-AGENT 과제 카드) 상세. `tasks-read-cli.ts` 가 카드 id 일 때만 싣는다.
+ */
+
+/** HARNESS-PARENT-ON-MSB1 — 카드가 원격 부모면 그 런 원장(⊕ Pod 자식)을 HQ 거울로 당긴다. 실패는 관측만(«없음»으로 읽히지 않게). */
+export async function mirrorRemoteCardLedger(cardId: string, deps: TasksCliDeps): Promise<void> {
+  let card: TaskCard | undefined;
+  try { card = readTaskCard(cardId, deps.taskStatePath); } catch { return; }
+  if (!card?.parentHost || !card.runId) return;
+  try {
+    if (deps.remoteLedgerMirror) { deps.remoteLedgerMirror(card); return; }
+    const { mirrorRemoteRunLedgers } = await import('../task-agent/parent-host.js');
+    const { effectiveInstanceRoot } = await import('../instance/resolve.js');
+    mirrorRemoteRunLedgers(card.parentHost, card.runId, effectiveInstanceRoot(), deps.cardRunEvidence?.ssh);
+  } catch (error) {
+    try { debug.log('task-agent', 'remote-ledger-mirror-failed', { card: cardId, host: card.parentHost.host, runId: card.runId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+  }
+}
+
+function moveLine(card: TaskCard): string {
+  const move = nextMoveFor(card);
+  return `${move.kind}${move.command ? ` — elanous ${move.command.map(shellQuote).join(' ')}` : ''} (${move.reason})`;
+}
+
+export function headLine(text: string): string {
+  const first = text.split('\n')[0]!.trim();
+  return first.length > 100 ? `${first.slice(0, 100)}…` : first;
+}
+
+/** 런 연결 한 줄 — 런 id 가 없으면 없다(옛 카드 · shadow). */
+function runLinkLine(card: TaskCard): string[] {
+  if (!card.runId) return [];
+  const number = cardPrNumber(card);
+  const url = typeof card.pr === 'object' ? card.pr.url : undefined;
+  const pr = number !== undefined ? `#${number}${url ? ` ${url}` : ''}` : '-';
+  return [`런: ${card.runId} · 골: ${card.goalId ?? '-'} · PR: ${pr}${card.runChildId ? ` · 자식 런: ${card.runChildId}` : ''}`];
+}
+
+/** RUN-IDENTITY-TAGS — 신분 한 줄 + Pod 라벨 한 줄(원장 정본 2줄 렌더 · 신분 없는 카드는 «미기록»으로 적고 기본값 정책을 밝힌다). */
+export function cardIdentityLines(card: TaskCard): string[] {
+  const identity = card.identity;
+  const { labels } = taskCardLabelContext({ id: card.id });
+  // 경계: Pod 에 실제로 붙는 라벨은 카드 id 하나뿐이다 — 신분 값은 Pod 라벨에 아직 안 실린다(RUN-IDENTITY-ADMIT 몫). 화면도 그렇게 말한다.
+  const podLine = `Pod 라벨 ${Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(' ')} (신분 값은 Pod 라벨 미탑재 — RUN-IDENTITY-ADMIT)`;
+  if (!identity) return [`신분 미기록 — 원장에 identity 없음 · 승인·선점은 기본 class=${runPriorityClass(identity)} 로 읽는다`, podLine];
+  // ⛔ 모르는 칸을 기본값으로 보이지 않는다 — 원장에 없는 칸은 «미기록»으로 적는다(확인된 칸만 값으로).
+  const identityText = RUN_TAG_KEYS.map((key) => `${key}=${runIdentityFieldText(identity, key)}`).join(' · ');
+  const originParts = [identity.origin?.checklistId, identity.origin?.version, identity.origin?.seat, identity.origin?.launcher].filter((part) => part !== undefined);
+  return [
+    `신분 ${identityText}${originParts.length > 0 ? ` — 출생 ${originParts.join(' · ')}` : ''}`,
+    podLine,
+  ];
+}
+
+function taskCardLines(card: TaskCard): string[] {
+  return [
+    [card.id, card.status, card.seat ?? '-', card.checklistId ?? '-', card.createdAt, card.text].join('\t'),
+    ...cardIdentityLines(card),
+    ...(card.targetPaths !== undefined ? [`대상 경로: ${card.targetPaths.length ? card.targetPaths.join(' · ') : '(유효한 경로 없음)'}`] : []),
+    ...(card.mission ? [`미션: ${card.mission} · after: ${card.after?.length ? card.after.join(', ') : '-'}`] : []),
+    ...runLinkLine(card),
+    ...liveMoveLines(card),
+    `다음 수: ${moveLine(card)}`,
+  ];
+}
+
+/** TA-LIVE-MOVE-CARD-HISTORY — 카드 history 의 live-move 줄(실행·그림자)을 한 줄씩. 없으면 없다(옛 카드 그대로). */
+function liveMoveLines(card: TaskCard): string[] {
+  return (card.history ?? []).filter((item) => item.event === LIVE_MOVE_HISTORY_EVENT || item.event === LIVE_MOVE_RESULT_EVENT).map((item) => item.event === LIVE_MOVE_RESULT_EVENT ? [
+    // TA-REVIEW-RESULT-CAPTURE — 회수한 리뷰 결과(또는 «결과 없음») 줄.
+    `결과: ${item.at}`, `${item.kind ?? '?'}`, `PR ${item.pr !== undefined ? `#${item.pr}` : '-'}${item.head ? ` head ${item.head.slice(0, 12)}` : ''}`,
+    `verdict=${item.verdict ?? '—'} reviewed=${item.reviewed ?? '—'} must-fix=${item.mustFix ?? '—'} route=${item.reviewRoute ?? '—'}`,
+    `효과: ${item.effect ?? 'unknown'}`, (item.detail ?? '').replace(/\r\n|\r|\n/g, (match) => (match === '\r' ? '\\r' : '\\n')),
+  ].join(' · ') : [
+    `수: ${item.at}`, `${item.kind ?? '?'} ${item.executorResult ?? '?'}`, `executed=${item.executed === true} ok=${item.ok === undefined ? '—' : item.ok}`,
+    `PR ${item.pr !== undefined ? `#${item.pr}` : '-'}${item.head ? ` head ${item.head.slice(0, 12)}` : ''}`,
+    `효과: ${item.effect ?? 'unknown'}`, (item.detail ?? '').replace(/\r\n|\r|\n/g, (match) => (match === '\r' ? '\\r' : '\\n')),
+  ].join(' · '));
+}
+
+/** 미션 카드 — 머리 한 줄 ⊕ 조각 한 줄씩(상태·다음 수·선행) ⊕ 간선 한 줄씩. */
+function missionLines(mission: TaskCard, pieces: TaskCard[]): string[] {
+  const edges = pieces.flatMap((piece) => (piece.after ?? []).map((before) => `간선: ${before} -> ${piece.id}`));
+  return [
+    [mission.id, 'mission', mission.seat ?? '-', mission.checklistId ?? '-', mission.createdAt, `조각 ${pieces.length} · 간선 ${edges.length} · 출처 ${mission.splitSource ?? '-'}`, headLine(mission.text)].join('\t'),
+    ...pieces.map((piece) => [`조각: ${piece.id}`, piece.status, nextMoveFor(piece).kind, `after: ${piece.after?.length ? piece.after.join(',') : '-'}`, headLine(piece.text),
+      ...(piece.runId ? [`런: ${piece.runId}${cardPrNumber(piece) !== undefined ? ` · PR #${cardPrNumber(piece)}` : ''}`] : [])].join('\t')),
+    ...edges,
+    ...(mission.greenProposal ? [`green 제안: ${mission.greenProposal.at} · 칸 ${mission.greenProposal.checklistId ?? '-'} · 근거 ${Object.entries(mission.greenProposal.evidence).map(([id, ref]) => `${id}=${ref}`).join(', ')}`] : []),
+  ];
+}
+
+/** `tasks show <ta-…>` — 카드 ⊕ 런 근거 묶기 ⊕ 다음 수. 출력·종료 코드는 `out`·`process.exitCode` 로만 낸다. */
+export async function showTaskCard(id: string, opts: { json?: boolean }, deps: TasksCliDeps, out: (line: string) => void): Promise<void> {
+  await registerTaskAgentSink(deps.registerSink);
+  let card: TaskCard | undefined;
+  try {
+    card = readTaskCard(id, deps.taskStatePath);
+    // 런 id 가 있으면 원장에서 골 id · PR 을 묶는다(찾았을 때만 적는다 · 실패는 그대로 보인다).
+    const bindable = card?.pieces ? card.pieces : card ? [card.id] : [];
+    for (const cardId of bindable) {
+      // HARNESS-PARENT-ON-MSB1: 원격 부모 런은 원장이 그 호스트에 있다 — HQ 거울로 먼저 당긴다(읽기 전용).
+      await mirrorRemoteCardLedger(cardId, deps);
+      // shadow 는 묶을 카드가 있을 때만 싣는다 — 없는 카드·TOX 상세 조회는 이 클러스터를 안 싣는다(CLI-ENTRY-LAZY).
+      const { replayRemoteCardMoves } = await import('../task-agent/shadow.js');
+      try { await replayRemoteCardMoves(cardId, deps.taskStatePath ?? taskStatePathDefault(), deps.cardRunEvidence ?? {}); } catch (error) {
+        try { debug.log('task-agent', 'card-binding-replay-failed', { card: cardId, reason: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+      }
+      try { await refreshCardRunBinding(cardId, deps.taskStatePath ?? taskStatePathDefault(), deps.cardRunEvidence ?? {}); } catch (error) {
+        // 근거 없음으로 보인다 — 원장 부재와 갈리게 실패는 남긴다.
+        try { debug.log('task-agent', 'card-bind-failed', { card: cardId, via: 'show', error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+      }
+      // TA-REVIEW-RESULT-CAPTURE — 떼어 띄운 live review 의 결과 파일을 이 카드 history 로 회수한다(대기 중인 요청이 있을 때만 쓴다 · 던지지 않는다).
+      captureReviewResults(deps.taskStatePath ?? taskStatePathDefault(), { cardIds: [cardId], ...(deps.reviewResultNow ? { now: deps.reviewResultNow } : {}) });
+    }
+    if (card) card = readTaskCard(id, deps.taskStatePath);
+  } catch (error) {
+    out(error instanceof Error ? error.message : '과제 카드 읽기 실패');
+    process.exitCode = 1;
+    return;
+  }
+  if (!card) { out(`과제 카드 없음: ${id}`); process.exitCode = 1; return; }
+  if (card.pieces) {
+    let all: Record<string, TaskCard>;
+    try { all = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(deps.taskStatePath ?? taskStatePathDefault()).tasks ?? {}; } catch (error) {
+      out(error instanceof Error ? error.message : '과제 카드 읽기 실패');
+      process.exitCode = 1;
+      return;
+    }
+    const pieces = card.pieces.map((pieceId) => all[pieceId]).filter((piece): piece is TaskCard => piece !== undefined);
+    const missingPieces = card.pieces.filter((pieceId) => !all[pieceId]);
+    if (opts.json) {
+      out(JSON.stringify({ card, nextMove: nextMoveFor(card), pieces: pieces.map((piece) => ({ card: piece, nextMove: nextMoveFor(piece) })), missingPieces }));
+      if (missingPieces.length) process.exitCode = 1;
+    }
+    else {
+      for (const line of missionLines(card, pieces)) out(line);
+      for (const missing of missingPieces) { out(`조각 카드 없음: ${missing} — 선후 기록이 불완전하다`); process.exitCode = 1; }
+    }
+    return;
+  }
+  // DRAFT-NOT-ARCHIVE: 멈춘 런이 draft PR 대신 남긴 수확 가지(원장 `salvaged`). 못 읽었으면 «못 읽음»(⛔ 없음 아님).
+  let salvage: Awaited<ReturnType<typeof readCardSalvageBranch>> = { salvageBranch: null };
+  try { salvage = await readCardSalvageBranch(card, deps.cardRunEvidence ?? {}); }
+  catch (error) { salvage = { salvageBranch: null, readErrors: [error instanceof Error ? error.message : String(error)] }; }
+  const salvageUnread = !salvage.salvageBranch && !!salvage.readErrors?.length;
+  if (opts.json) out(JSON.stringify({ card, nextMove: nextMoveFor(card), salvageBranch: salvage.salvageBranch, ...(salvageUnread ? { salvageBranchUnread: true } : {}) }));
+  else {
+    for (const line of taskCardLines(card)) out(line);
+    if (card.parentHost) out(`부모 호스트: ${card.parentHost.host}${card.parentHost.pid ? ` (pid ${card.parentHost.pid})` : ''} · PR 까지만 — 병합은 HQ${card.parentHost.log ? ` · 로그 ${card.parentHost.host}:${card.parentHost.log}` : ''}`);
+    if (salvage.salvageBranch) out(`수확 가지: ${salvage.salvageBranch} (draft PR 대신)`);
+    else if (salvageUnread) out('수확 가지: 못 읽음(원장 읽기 실패)');
+  }
+}