elanous 0.2.35 → 0.2.36

package/src/cli/pr-land-overlap-evidence.ts

@@ -189,6 +189,7 @@ function lastReviewRecord(text: string): Record<string, unknown> | undefined {
 function hasResolvedPriorDeclaration(review: Record<string, unknown> | undefined): boolean {
   if (!review) return false;
   const value = review.resolvedPrior;
+  if (value === true) return true;
   if (Array.isArray(value) && value.length > 0) return true;
   if (value && typeof value === 'object' && Object.keys(value).length > 0) return true;
   return [review.intent, review.intentBlock, review.reviewIntent, review.reviewIntentBlock]
@@ -199,8 +200,21 @@ function normalizedFinding(value: string): string {
   return value.trim().replace(/\s+/g, ' ').toLowerCase();
 }
 
+// `status open` / `status pending` in prose counts the same as `status: pending` in a field.
+const UNRESOLVED_STATUS = /^(?:open|unresolved|pending|in[- ]progress)$/i;
+
 function containsUnresolvedClaim(value: string): boolean {
-  return /\b(?:unresolved|not(?:\s+yet)?[\s-]+resolved|not(?:\s+yet)?[\s-]+fixed|not(?:\s+yet)?[\s-]+addressed|still[\s-]+open|remains?[\s-]+open|still[\s-]+present|status\s*[:=]\s*(?:open|unresolved|pending|in[- ]progress))\b/i.test(value);
+  return /\b(?:unresolved|not(?:\s+yet)?[\s-]+resolved|not(?:\s+yet)?[\s-]+fixed|not(?:\s+yet)?[\s-]+addressed|still[\s-]+open|remains?[\s-]+open|still[\s-]+present|status\s*(?:[:=]\s*|\s+)(?:open|unresolved|pending|in[- ]progress))\b/i.test(value);
+}
+
+/** A record cannot claim resolution while carrying its own OPEN/PENDING status — refuse both fields. */
+function unresolvedStatusDeclared(record: Record<string, unknown>): boolean {
+  if (record.resolved === false) return true;
+  return ['status', 'resolutionStatus', 'resolution']
+    .some((key) => {
+      const value = record[key];
+      return typeof value === 'string' && UNRESOLVED_STATUS.test(value.trim());
+    });
 }
 
 function containsUnresolvedDeclaration(value: unknown): boolean {
@@ -208,7 +222,7 @@ function containsUnresolvedDeclaration(value: unknown): boolean {
   if (Array.isArray(value)) return value.some(containsUnresolvedDeclaration);
   if (!value || typeof value !== 'object') return false;
   const record = value as Record<string, unknown>;
-  if (record.resolved === false || (typeof record.status === 'string' && /^(?:open|unresolved|pending|in[- ]progress)$/i.test(record.status))) return true;
+  if (unresolvedStatusDeclared(record)) return true;
   return Object.values(record).some(containsUnresolvedDeclaration);
 }
 
@@ -233,11 +247,16 @@ function reviewAttemptExplicitlyResolved(input: VerifyOverlapEvidenceInput, sele
   if (findings.length === 0) return false;
 
   const declared = selected.resolvedPrior;
-  if (declared !== undefined && containsUnresolvedDeclaration(declared)) return false;
+  if (declared !== undefined && declared !== false && containsUnresolvedDeclaration(declared)) return false;
   const intentBlocks = [selected.intent, selected.intentBlock, selected.reviewIntent, selected.reviewIntentBlock]
     .filter((value): value is string => typeof value === 'string');
   // A resolution in one field cannot override an OPEN/PENDING declaration in another.
   if (intentBlocks.some(containsUnresolvedClaim)) return false;
+  // Contradiction axis 1 (structured): the record declares the prior attempt resolved while a
+  // separate lifecycle field still says open/pending — neither claim can be trusted, so refuse.
+  const declaresResolution = (declared !== undefined && declared !== false)
+    || intentBlocks.some((intent) => /^resolved prior review findings:\s*$/im.test(intent));
+  if (declaresResolution && unresolvedStatusDeclared(selected)) return false;
 
   let resolved: string[] = [];
   if (Array.isArray(declared)) {
@@ -261,7 +280,7 @@ function reviewAttemptExplicitlyResolved(input: VerifyOverlapEvidenceInput, sele
       if (ref !== undefined && !referencesReview(ref, failedPath)) continue;
       if (item.head !== undefined && (typeof item.head !== 'string' || item.head.toLowerCase() !== head)) continue;
       if (item.headCommit !== undefined && (typeof item.headCommit !== 'string' || item.headCommit.toLowerCase() !== head)) continue;
-      if (item.resolved === false || item.status === 'unresolved'
+      if (unresolvedStatusDeclared(item)
         || Object.values(item).some((value) => typeof value === 'string' && containsUnresolvedClaim(value))) continue;
       const listed = findingList(item.mustFix ?? item.resolvedMustFix ?? item.findings ?? item.axes ?? item.finding ?? item.axis);
       if (listed.some(containsUnresolvedClaim)) continue;

package/src/cli/pr-land-recovery.ts

@@ -1,5 +1,10 @@
 import { classifyPrLandRefusal } from './pr-land-refusal.js';
-import { readJourneyEdge } from '../self-dev/graph-journey-route.js';
+import { readJourneyEdge, recordJourneyEdge } from '../self-dev/graph-journey-route.js';
+import { GRAPH_SPECS } from '../self-implement/graph-templates.js';
+import { debug } from '../debug/log.js';
+
+/** The task card that launched this `pr land` (TA `defaultLand` sets it). Observation only. */
+export const PR_LAND_CARD_ID_ENV = 'ELANOUS_PR_LAND_CARD_ID';
 
 /** A recover unit selects a next action. The train or TA still owns every effect. */
 export interface PrLandRecoveryContext {
@@ -62,3 +67,114 @@ export function planPrLandRecoveryForEntry(context: PrLandRecoveryContext, entry
     evidence: plan.evidence,
   };
 }
+
+/** LAND-REFUSAL-EDGES — bind one observed landing refusal to the declared recover@1 edge.
+ *  The row carries the raw refusal, card, PR, head and the read-only plan. It never retries,
+ *  merges or requests anything: `execution: 'none'` and `mergeSha: null` are part of the row. */
+export function bindPrLandRefusalToRecover(context: PrLandRecoveryContext & { cardId?: string }): PrLandRecoveryPlan {
+  const plan = planPrLandRecovery(context);
+  try {
+    if (!plan.result.pr || !plan.result.head) return plan;
+    const route = readJourneyEdge('merge', 'land-refused');
+    const node = route.to ? GRAPH_SPECS['self-implement']?.nodes.find((n) => n.nodeId === route.to) : undefined;
+    const call = node?.kind === 'subgraph' ? node.call ?? null : null;
+    const cardId = typeof context.cardId === 'string' && context.cardId.trim() ? context.cardId.trim() : null;
+    const reason = 'pr-land-refused; recover@1 bound; recovery-execution=none';
+    // Only a declared recover@1 subgraph is a binding. A fallback edge (e.g. merge → cleanup) is not.
+    if (route.source !== 'graph' || route.on !== 'recovery' || call !== 'recover@1') {
+      debug.log('self-implement', 'graph-edge-unresolved', { from: 'merge', label: 'land-refused', to: route.to, call, reason });
+      return plan;
+    }
+    recordJourneyEdge(route, route.to!, reason, {
+      call, execution: 'none', mergeSha: null,
+      evidence: { cardId, pr: plan.result.pr, head: plan.result.head, refusal: plan.evidence.refusal,
+        refusalLabel: plan.evidence.label, refusalRoute: plan.evidence.route },
+      recover: { outcome: plan.outcome, action: plan.result.action, reason: plan.result.reason, delayMs: plan.result.delayMs ?? null },
+    });
+  } catch { /* Observation must never replace the landing refusal. */ }
+  return plan;
+}
+
+type RecoverRun = { runId?: string; status?: string; path?: readonly string[]; nodes?: ReadonlyArray<{ nodeId?: string; output?: unknown }> };
+export interface PrLandRecoveryExecution {
+  /** The plan the caller may act on. An untrusted or failed run is replaced by a needs-human plan. */
+  plan: PrLandRecoveryPlan;
+  /** True only when the declared recover@1 binding existed and the unit was run. */
+  executed: boolean;
+}
+
+/** LAND-REFUSAL-EXEC — bind one refusal (row `execution: 'none'`), then run the existing recover@1 unit
+ *  (graphs/units/recover.yaml · read-only `cmd:recover-plan`) for one step to the terminal the unit selects,
+ *  and record that run on the same edge keys with `execution: 'graph-run'`. A run that does not reproduce the
+ *  pinned plan fails closed to `needs-human`. It still never retries, requests, merges or enqueues. */
+/** recover@1 한 단계 실행의 시간 한도 — 운영 TA 착지 틱이 매달린 유닛에 붙잡히지 않게(넘으면 fail-closed needs-human). */
+export const PR_LAND_RECOVER_TIMEOUT_MS = 60_000;
+
+export async function executeBoundPrLandRecover(
+  context: PrLandRecoveryContext & { cardId?: string },
+  deps: { root?: string; timeoutMs?: number; runGraph?: (path: string, options: { input: unknown; quiet?: boolean; pinChildUniverse?: boolean; deps?: { root?: string } }) => Promise<RecoverRun> } = {},
+): Promise<PrLandRecoveryExecution> {
+  const plan = bindPrLandRefusalToRecover(context);
+  let route: ReturnType<typeof readJourneyEdge>;
+  let call: string | null;
+  try {
+    route = readJourneyEdge('merge', 'land-refused');
+    const node = route.to ? GRAPH_SPECS['self-implement']?.nodes.find((n) => n.nodeId === route.to) : undefined;
+    call = node?.kind === 'subgraph' ? node.call ?? null : null;
+  } catch { return { plan, executed: false }; }
+  // Same admission as the binding: pinned identity and a declared recover@1 subgraph edge.
+  if (!plan.result.pr || !plan.result.head || route.source !== 'graph' || route.on !== 'recovery' || call !== 'recover@1') return { plan, executed: false };
+  const cardId = typeof context.cardId === 'string' && context.cardId.trim() ? context.cardId.trim() : null;
+  const unitContext = { refusal: context.refusal, pr: plan.result.pr, head: plan.result.head, ...(context.isDraft === undefined ? {} : { isDraft: context.isDraft }) };
+  let run: RecoverRun | undefined;
+  let error: string | undefined;
+  try {
+    const runGraph = deps.runGraph ?? (await import('../graph-runner/runner.js')).runGraph;
+    const { fileURLToPath } = await import('node:url');
+    const limitMs = deps.timeoutMs ?? PR_LAND_RECOVER_TIMEOUT_MS;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeout = new Promise<never>((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`recover@1 timeout after ${limitMs}ms`)), limitMs);
+      (timer as { unref?: () => void }).unref?.();
+    });
+    try {
+      run = await Promise.race([runGraph(fileURLToPath(new URL('../../graphs/units/recover.yaml', import.meta.url)), {
+        input: { ask: `pr land refusal for PR #${plan.result.pr}`, context: unitContext, prior: null },
+        quiet: true, pinChildUniverse: true, ...(deps.root ? { deps: { root: deps.root } } : {}),
+      }), timeout]);
+    } finally { if (timer) clearTimeout(timer); }
+  } catch (cause) { error = String(cause).slice(0, 300); run = undefined; }
+  const exit = run?.path?.at(-1) ?? null;
+  let output: Partial<PrLandRecoveryPlan> | undefined;
+  try {
+    const raw = run?.nodes?.find((n) => n.nodeId === 'plan')?.output;
+    const lines = typeof raw === 'string' ? raw.split('\n').map((l) => l.trim()).filter(Boolean) : [];
+    output = lines.length ? JSON.parse(lines.at(-1)!) as Partial<PrLandRecoveryPlan> : undefined;
+  } catch { output = undefined; }
+  // Trust only a run that reproduces the pinned plan and ends in the terminal the plan names.
+  const trusted = !error && !!output && output.outcome === plan.outcome && exit === plan.outcome
+    && output.result?.action === plan.result.action && output.result?.pr === plan.result.pr
+    && output.result?.head === plan.result.head && (output.result?.delayMs ?? null) === (plan.result.delayMs ?? null)
+    && output.evidence?.refusal === plan.evidence.refusal;
+  const executed: PrLandRecoveryPlan = trusted ? plan : {
+    outcome: 'needs-human',
+    result: { action: 'needs-human', pr: plan.result.pr, head: plan.result.head,
+      reason: `recover@1 execution untrusted (${error ?? `status ${run?.status ?? 'none'} exit ${exit ?? 'none'}`}); hand to a human` },
+    evidence: plan.evidence,
+  };
+  try {
+    recordJourneyEdge(route, route.to!, 'pr-land-refused; recover@1 executed; recovery-execution=graph-run', {
+      call, execution: 'graph-run', mergeSha: null,
+      evidence: { cardId, pr: plan.result.pr, head: plan.result.head, refusal: plan.evidence.refusal,
+        refusalLabel: plan.evidence.label, refusalRoute: plan.evidence.route },
+      recover: { outcome: executed.outcome, action: executed.result.action, reason: executed.result.reason, delayMs: executed.result.delayMs ?? null },
+      run: { runId: run?.runId ?? null, status: run?.status ?? null, path: run?.path ?? [], exit, trusted, ...(error ? { error } : {}) },
+    });
+    // A human owns every needs-human/failed exit — say so at warn level, with the same join keys.
+    if (executed.outcome !== 'rework') debug.log('pr.land', 'recover-needs-human', {
+      cardId, pr: plan.result.pr, head: plan.result.head, outcome: executed.outcome, reason: executed.result.reason, runId: run?.runId ?? null,
+    }, { level: 'warn' });
+  } catch { /* Observation must never replace the landing refusal. */ }
+  // «실행했다» 는 유닛이 실제로 돌아 런을 냈을 때만 — 예외·시간 초과는 결속만 남고 실행 0.
+  return { plan: executed, executed: run !== undefined };
+}

package/src/cli/pty-takeover-cli.ts

@@ -16,7 +16,7 @@ import { formatPtyWebAddress, ptyWebAddress, type PtyWebAddress } from './pty-we
 import { getHarnessRunId, normalizeRunIdSource, type RunIdSource } from '../harness/harness-space.js';
 import { inspectControlInbox, type ControlInboxSnapshot } from '../harness/control-inbox.js';
 import { requestRemotePtyControl, type PtyControlAction, type PtyControlPayload, type PtyControlRequestOptions, type PtyControlResult } from '../pty-shell/pty-control-ipc.js';
-import { resolvePtySpecialKey } from '../pty-shell/pty-special-keys.js';
+import { resolvePtySpecialKey, type PtyKeyEncoding } from '../pty-shell/pty-special-keys.js';
 import { encodeSgrMouse, mouseModeOffReason, type PtyMouseInput } from '../pty-shell/pty-mouse.js';
 import { resizePtyWithOutcome, writePtyWithOutcome, writePtyWithOutcomeDetail } from '../pty-shell/pty-write-outcome.js';
 import type { PtyControlTarget, PtyHandle } from '../pty-shell/registry.js';
@@ -2217,9 +2217,9 @@ export async function runPtyTextWhenIdle(ref: string, text: string, appendEnter:
   const typed = await runPtyText(ref, text, appendEnter, deps, actor);
   return { ...typed, message: `${waited.message}\n${typed.message}` };
 }
-export function runPtyKey(ref: string, key: string, repeat = 1, deps: PtyTakeoverCommandDeps = liveDeps, actor: PtyWriteActor = 'human'): Promise<PtyTakeoverCommandResult> {
+export function runPtyKey(ref: string, key: string, repeat = 1, deps: PtyTakeoverCommandDeps = liveDeps, actor: PtyWriteActor = 'human', encoding: PtyKeyEncoding = 'xterm'): Promise<PtyTakeoverCommandResult> {
   if (!Number.isInteger(repeat) || repeat < 1) return Promise.resolve({ exitCode: 1, message: 'pty key: repeat must be a positive integer' });
-  try { const normalized = key.trim().toLowerCase(); return inject(ref, 'input-key', resolvePtySpecialKey(normalized).repeat(repeat), { key: normalized, repeat }, deps, actor); } catch (error) { return Promise.resolve({ exitCode: 1, message: `pty key: ${(error as Error).message}` }); }
+  try { const normalized = key.trim().toLowerCase(); return inject(ref, 'input-key', resolvePtySpecialKey(normalized, { encoding }).repeat(repeat), { key: normalized, repeat, encoding }, deps, actor); } catch (error) { return Promise.resolve({ exitCode: 1, message: `pty key: ${(error as Error).message}` }); }
 }
 export async function runPtyMouse(ref: string, input: PtyMouseInput, deps: PtyTakeoverCommandDeps = liveDeps, actor: PtyWriteActor = 'human'): Promise<PtyTakeoverCommandResult> {
   let chars: string;
@@ -2369,14 +2369,15 @@ export function registerPtyTakeoverCommands(program: Command, deps: PtyTakeoverC
           : runPtyText(id, text, Boolean(opts.enter), deps, actor))
         : runPtyRemoteControl('text', id, remote, { action: 'input-text', chars: text + (opts.enter === true ? '\r' : '') }, deps));
     }));
-  pty.command('key <ref> <key>').option('-n, --repeat <count>', 'repetitions', '1').option('-r', 'inject a key on the default remote bookmark (does not take a value)').option('--remote <name>', 'inject a key on a named remote bookmark').option(...ACTOR_FLAG)
-    .description("Inject a named special key (enter/esc/tab/up/… · see 'pty list' for <ref>)").action((id: string, key: string, opts: { repeat: string; actor?: string; r?: boolean; remote?: string }) => run(() => {
+  pty.command('key <ref> <key>').option('-n, --repeat <count>', 'repetitions', '1').option('--kitty', 'send modifier combos (shift+enter …) as kitty CSI-u instead of xterm modifyOtherKeys').option('-r', 'inject a key on the default remote bookmark (does not take a value)').option('--remote <name>', 'inject a key on a named remote bookmark').option(...ACTOR_FLAG)
+    .description("Inject a named special key (enter/esc/tab/up/… · shift+enter / alt+enter / ctrl+enter combos · see 'pty list' for <ref>)").action((id: string, key: string, opts: { repeat: string; actor?: string; r?: boolean; remote?: string; kitty?: boolean }) => run(() => {
       const remote = opts.remote ?? (opts.r === true ? true : undefined);
+      const encoding: PtyKeyEncoding = opts.kitty === true ? 'kitty' : 'xterm';
       return withActor(opts, (actor) => {
-        if (remote === undefined) return runPtyKey(id, key, Number(opts.repeat), deps, actor);
+        if (remote === undefined) return runPtyKey(id, key, Number(opts.repeat), deps, actor, encoding);
         const repeat = Number(opts.repeat);
         if (!Number.isInteger(repeat) || repeat < 1) return Promise.resolve({ exitCode: 1, message: 'pty key: repeat must be a positive integer' });
-        try { return runPtyRemoteControl('key', id, remote, { action: 'input-key', chars: resolvePtySpecialKey(key.trim().toLowerCase()).repeat(repeat) }, deps); }
+        try { return runPtyRemoteControl('key', id, remote, { action: 'input-key', chars: resolvePtySpecialKey(key.trim().toLowerCase(), { encoding }).repeat(repeat) }, deps); }
         catch (error) { return Promise.resolve({ exitCode: 1, message: `pty key: ${(error as Error).message}` }); }
       });
     }));

package/src/cli/release-cli.ts

@@ -48,7 +48,7 @@ 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';
@@ -1278,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 });
@@ -1368,7 +1368,11 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
             log(`· 리허설 ${stamp.version} ${stamp.step} · ${stamp.summary} · stage claim 해제 · 다음 tick 재시도`);
         }
         return result;
-      }, (result) => result.status !== 'failed' && !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 실행')
@@ -1377,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/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('수확 가지: 못 읽음(원장 읽기 실패)');
+  }
+}