elanous 0.2.37 → 0.2.40

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

@@ -4,8 +4,8 @@ import { readFileSync, realpathSync, statSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { runGitCommand } from '../git-fs/runner.js';
 import { debug } from '../debug/log.js';
-import { getPty, listPty, renamePty, requestPtyTakeover } from '../pty-shell/registry.js';
-import { describePtyRunState, describeTurnCell, formatTurnCell, ptyTurnViewOfRow, readCheckoutHead, readCurrentInstallRecord, shortSha, UNKNOWN_TURN_CELL, type InstalledRecord, type PtyRunStateView, type PtyTurnCell } from '../pty-shell/tui-run-state.js';
+import { getPty, listPty, renamePty, requestPtyTakeover, startPty, type StartOpts } from '../pty-shell/registry.js';
+import { describePtyRunState, describeTurnCell, formatTurnCell, judgeTurnProgress, ptyTurnViewOfRow, readCheckoutHead, readCurrentInstallRecord, shortSha, UNKNOWN_TURN_CELL, type InstalledRecord, type PtyRunStateView, type PtyTurnCell, type TurnProgressJudgment } from '../pty-shell/tui-run-state.js';
 import { getPtyManifest, isProcessAlive, listPtyManifest, listPtyManifestRows, listPtyManifestRowsAt, ptyManifestDbPath, readPtyManifestFrame, reapDeadPtyManifest, reapDeadPtyManifestAt, reapStalePtyManifest, removePtyManifest, PTY_MANIFEST_CLOSED_TTL_MS, PTY_MANIFEST_STALE_MS, type PtyManifestExternalReapResult, type PtyManifestRow } from '../pty-shell/pty-manifest.js';
 import { readPtyEventsAfter, readPtyEventsAfterAt, type PtyEventLogReadResult, type PtyEventRow } from '../pty-shell/pty-event-log.js';
 import { resolvePtyRef, type PtyRefItem } from '../pty-shell/pty-ref.js';
@@ -13,7 +13,7 @@ import { parsePtyWriteActor, resolveRemoteControlActor, resolveTakeover, type Pt
 import { registerPtyAttachDriveCommand } from './pty-drive-cli.js';
 import { resolveNexusPwa, type NexusPwaResolution } from './nexus-show.js';
 import { formatPtyWebAddress, ptyWebAddress, type PtyWebAddress } from './pty-web-address.js';
-import { getHarnessRunId, normalizeRunIdSource, type RunIdSource } from '../harness/harness-space.js';
+import { ensureRunId, 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, type PtyKeyEncoding } from '../pty-shell/pty-special-keys.js';
@@ -131,6 +131,10 @@ interface PtyLineageRow {
   readonly nestDepth?: number;
   readonly originRoot?: string;
   readonly controller?: string;
+  /** Copied from spawned/exited ledger payloads; omitted when the old event never recorded a seat. */
+  readonly seat?: string;
+  /** Cumulative bytes from the lifecycle payload; omitted when the old event never recorded a total. */
+  readonly outputBytesTotal?: number;
 }
 
 interface PtyLineageGroup {
@@ -164,6 +168,7 @@ function ptyLineageResult(groups: readonly PtyLineageGroup[], unreadablePayloads
 type PtyLifecyclePayload = {
   event?: unknown; ptyId?: unknown; kind?: unknown; instance?: unknown; runId?: unknown; runIdSource?: unknown; workdir?: unknown; codeSha?: unknown;
   parentPtyId?: unknown; parentPid?: unknown; parentKind?: unknown; startedAt?: unknown; closedAt?: unknown;
+  seat?: unknown; outputBytesTotal?: unknown;
 };
 
 function stringField(value: unknown): string { return typeof value === 'string' ? value : ''; }
@@ -182,6 +187,10 @@ function lineageRowFromManifest(row: PtyManifestRow & { readonly sourceRoot?: st
     ...(row.nestDepth !== undefined ? { nestDepth: row.nestDepth } : {}),
     ...(row.originRoot !== undefined ? { originRoot: row.originRoot } : {}),
     ...(row.controller !== undefined ? { controller: row.controller } : {}),
+    ...(row.seat ? { seat: row.seat } : {}),
+    ...(typeof row.outputBytesTotal === 'number' && Number.isFinite(row.outputBytesTotal) && row.outputBytesTotal > 0
+      ? { outputBytesTotal: row.outputBytesTotal }
+      : {}),
   };
 }
 
@@ -200,16 +209,17 @@ function lifecyclePatchFromEvent(row: PtyEventRow, payload: PtyLifecyclePayload)
   const assignRunIdSource = (): void => {
     if (typeof payload.runIdSource === 'string') patch.runIdSource = normalizeRunIdSource(payload.runIdSource);
   };
-  const assignNumber = <K extends 'startedAt' | 'closedAt' | 'parentPid'>(key: K): void => {
+  const assignNumber = <K extends 'startedAt' | 'closedAt' | 'parentPid' | 'outputBytesTotal'>(key: K): void => {
     if (typeof payload[key] === 'number' && Number.isFinite(payload[key])) patch[key] = payload[key] as PtyLineageRow[K];
   };
   for (const key of ['kind', 'parentPtyId', 'parentKind', 'runId', 'workdir', 'codeSha'] as const) assignString(key);
+  if (typeof payload.seat === 'string' && payload.seat) patch.seat = payload.seat;
   assignRunIdSource();
   if (typeof payload.instance === 'string') patch.instance = payload.instance;
   else if (event === 'spawned') patch.instance = row.instance;
   const sourceRoot = (row as PtyEventRow & { readonly sourceRoot?: string }).sourceRoot;
   if (sourceRoot) patch.sourceRoot = sourceRoot;
-  for (const key of ['startedAt', 'parentPid'] as const) assignNumber(key);
+  for (const key of ['startedAt', 'parentPid', 'outputBytesTotal'] as const) assignNumber(key);
   if (event === 'spawned' || event === 'seen-alive') {
     patch.alive = true;
     if (event === 'spawned') patch.closedAt = 0;
@@ -230,6 +240,10 @@ function mergeLifecyclePatch(previous: PtyLineageRow | undefined, patch: PtyLife
     ...patch,
     startedAt: base.startedAt || patch.startedAt || 0,
     ...(patch.workdir === undefined ? (base.workdir ? { workdir: base.workdir } : {}) : patch.workdir ? { workdir: patch.workdir } : {}),
+    ...(patch.seat === undefined ? (base.seat ? { seat: base.seat } : {}) : { seat: patch.seat }),
+    ...(patch.outputBytesTotal === undefined
+      ? (base.outputBytesTotal === undefined ? {} : { outputBytesTotal: base.outputBytesTotal })
+      : { outputBytesTotal: patch.outputBytesTotal }),
   };
 }
 
@@ -272,7 +286,15 @@ export function joinPtyLineage(
   for (const row of manifestRows) {
     if (manifestIds.has(row.id)) continue;
     manifestIds.add(row.id);
-    rows.set(row.id, lineageRowFromManifest(row));
+    const previous = rows.get(row.id);
+    const fromManifest = lineageRowFromManifest(row);
+    rows.set(row.id, {
+      ...fromManifest,
+      ...(fromManifest.seat === undefined && previous?.seat ? { seat: previous.seat } : {}),
+      ...(fromManifest.outputBytesTotal === undefined && previous?.outputBytesTotal !== undefined
+        ? { outputBytesTotal: previous.outputBytesTotal }
+        : {}),
+    });
   }
   const allRows = [...rows.values()];
   const byId = allRows.filter((row) => row.ptyId === query);
@@ -380,6 +402,8 @@ export function joinPtyLineage(
 
 export interface PtyTakeoverCommandDeps {
   getPty(id: string): PtyControlTarget | undefined;
+  /** Spawn a locally-owned PTY; default = registry startPty. */
+  startPty?(opts: StartOpts): PtyHandle;
   requestPtyTakeover(id: string, actor: 'human'): boolean;
   requestRemote(id: string, action: PtyControlAction, payload?: PtyControlPayload, options?: PtyControlRequestOptions): Promise<PtyControlResult>;
   /** Local (same-process) rename; default = registry renamePty. */
@@ -1443,6 +1467,10 @@ interface PtyListJsonRow extends PtyWebAddress {
   readonly ageMs?: number;
   /** ⭐ H10 — TUI 가 스스로 적은 턴(화면 추정 아님) ⊕ 그 상태 경과 초. 턴 기록 없는 행·원격 행은 `state:'unknown'`. */
   readonly turn: PtyTurnCell;
+  /** ⭐ SURVIVAL-PROGRESS-CLOCK — 마지막 진전 시각(epoch ms). 기록 없는 행·옛 판은 칸을 비운다. */
+  readonly progressAt?: number;
+  /** ⭐ SURVIVAL-PROGRESS-CLOCK — 진전 판정(progressing·slow·stalled·abort-ignored·unknown). */
+  readonly progress: TurnProgressJudgment;
   /** ⭐ H10 — 기동 판(실행판 sha) ⊕ 낡음. 판 기록 없는 행·판독 실패는 null. */
   readonly build: { readonly version: string; readonly sha: string; readonly source: string; readonly stale: boolean | null; readonly staleReason: string } | null;
 }
@@ -1492,7 +1520,9 @@ function ptyListJsonRow(row: PtyManifestRow, instance: string, sourceRoot: PtyMa
     ...provenanceFields(provenance),
     ownerProcessAlive: proof.liveness.alive,
     updatedAgeMs: proof.inactivity.ageMs,
-    outputBytesTotal: row.outputBytesTotal ?? 0,
+    // ⛔⭐ «미상 ≠ 0»: `outputBytesTotal` 가 optional 가 된 뒤로, 옛 스키마/NULL 행을 `0` 으로
+    //   채우면 «0바이트»라는 사실처럼 나온다. 미상은 'unknown' 으로 «보존»한다.
+    outputBytesTotal: row.outputBytesTotal ?? 'unknown',
     ...(row.lastControlAt === undefined ? {} : { lastControlAt: row.lastControlAt }),
     ...ptyAgeField(row.startedAt, observedAt),
     runTerminated,
@@ -1508,10 +1538,15 @@ function ptyListJsonRow(row: PtyManifestRow, instance: string, sourceRoot: PtyMa
 
 /** `pty list --json` 의 턴·판 칸 — ⛔ 키는 «언제나» 싣는다(값으로만 갈린다 · 모르면 unknown/null).
  *  ⭐ 턴은 행의 자기보고 값만 읽는다 — 판 판독(설치본·git)이 실패해도 기록된 턴은 버리지 않는다. */
-function ptyListRunFields(row: PtyManifestRow, deps: PtyTakeoverCommandDeps, observedAt: number, installed: () => InstalledRecord): Pick<PtyListJsonRow, 'turn' | 'build'> {
+function ptyListRunFields(row: PtyManifestRow, deps: PtyTakeoverCommandDeps, observedAt: number, installed: () => InstalledRecord): Pick<PtyListJsonRow, 'turn' | 'progressAt' | 'progress' | 'build'> {
   const turn = describeTurnCell(ptyTurnViewOfRow(row), observedAt);
+  // SURVIVAL-PROGRESS-CLOCK — 진전 판정을 같은 관측 시각으로 잡고 전환을 관측한다.
+  const progress = judgeTurnProgress({
+    turn: turn.state, turnAt: turn.at ?? undefined, progressAt: row.progressAt, abortRequestedAt: row.abortRequestedAt, now: observedAt,
+  });
+  noteTurnProgressSurvival(row.id, progress, { turnAt: turn.at ?? undefined, progressAt: row.progressAt, now: observedAt });
   try {
-    if (!row.build) return { turn, build: null };
+    if (!row.build) return { turn, ...(row.progressAt !== undefined ? { progressAt: row.progressAt } : {}), progress, build: null };
     // 판독 예외 계약: 판 sha 는 기록값이라 그대로 두고 낡음만 «모른다»(stale=null · unknown) ⊕ `list-build-read-failed` 관측.
     //   그 밖의 뜻밖 예외는 판을 null 로(아래 catch) — 어느 쪽이든 기록된 턴은 버리지 않는다.
     const run = describePtyRunState(row, {
@@ -1523,10 +1558,11 @@ function ptyListRunFields(row: PtyManifestRow, deps: PtyTakeoverCommandDeps, obs
         }
       },
     });
-    return { turn, build: run.build ? { version: run.build.version, sha: run.build.sha, source: run.build.source, stale: run.stale, staleReason: run.staleReason } : null };
+    const progressFields = { ...(row.progressAt !== undefined ? { progressAt: row.progressAt } : {}), progress };
+    return { turn, ...progressFields, build: run.build ? { version: run.build.version, sha: run.build.sha, source: run.build.source, stale: run.stale, staleReason: run.staleReason } : null };
   } catch (error) {
     deps.log('list-build-read-failed', { ptyId: row.id, source: 'describe', error: error instanceof Error ? error.message : String(error) });
-    return { turn, build: null };
+    return { turn, ...(row.progressAt !== undefined ? { progressAt: row.progressAt } : {}), progress, build: null };
   }
 }
 
@@ -1822,8 +1858,9 @@ function remotePtyListJsonRow(row: RemoteTerminalListItem): PtyListJsonRow {
     runTerminationSource: 'unknown',
     runStoreIo: 'not-checked',
     ownerRunUsage: 'unknown',
-    // 원격 응답은 턴·판을 안 싣는다 — «모른다»로(로컬과 같은 키).
+    // 원격 응답은 턴·판·진전을 안 싣는다 — «모른다»로(로컬과 같은 키).
     turn: UNKNOWN_TURN_CELL,
+    progress: 'unknown',
     build: null,
   };
 }
@@ -2141,12 +2178,16 @@ export async function runPtyState(ref: string, deps: PtyTakeoverCommandDeps = li
 function formatPtyStateResult(id: string, screen: { state: FrameState; label?: string | null }, run: PtyRunStateView, at: number, json: boolean, deps: PtyTakeoverCommandDeps, screenUnavailable?: string): PtyTakeoverCommandResult {
   const reconciled = reconcileFrameStateWithTurn(screen.state, run.turn);
   if (reconciled.overridden) deps.log('state-reconciled', { ptyId: id, turn: run.turn, screenState: reconciled.screenState, label: screen.label ?? null, state: reconciled.state });
+  // SURVIVAL-PROGRESS-CLOCK — 진전·정체·Esc 무시 판정을 turnAt 옆에 싣고 전환을 관측한다.
+  const progress = judgeTurnProgress({ turn: run.turn, turnAt: run.turnAt, progressAt: run.progressAt, abortRequestedAt: run.abortRequestedAt, now: at });
+  noteTurnProgressSurvival(id, progress, { turnAt: run.turnAt, progressAt: run.progressAt, now: at });
   const guess = reconciled.screenState !== reconciled.state && !screenUnavailable ? ` guess=${reconciled.screenState}` : '';
   return { exitCode: 0, message: json
     ? JSON.stringify({
       id, state: reconciled.state, stateSource: reconciled.source, screenState: reconciled.screenState, label: screen.label, at,
       ...(screenUnavailable ? { screenUnavailable } : {}),
       turn: run.turn, ...(run.turnAt !== undefined ? { turnAt: run.turnAt } : {}),
+      ...(run.progressAt !== undefined ? { progressAt: run.progressAt } : {}), progress,
       build: run.build ? { version: run.build.version, sha: run.build.sha, source: run.build.source } : null,
       installed: run.installed, stale: run.stale, staleReason: run.staleReason,
     })
@@ -2167,6 +2208,29 @@ function formatRunBuild(run: PtyRunStateView): string {
   return run.build ? `${run.build.version}@${shortSha(run.build.sha)}(${run.build.source})` : 'unknown';
 }
 
+// ── SURVIVAL-PROGRESS-CLOCK — «마지막 진전 시각» 판정을 state/list 에 싣고 전환을 한 번만 관측한다 ──
+const SURVIVAL_EVENT_OF: Record<'stalled' | 'abort-ignored' | 'slow', 'stall-detected' | 'abort-ignored' | 'slow-turn'> = {
+  stalled: 'stall-detected',
+  'abort-ignored': 'abort-ignored',
+  slow: 'slow-turn',
+};
+const lastSurvivalJudgmentByPtyId = new Map<string, TurnProgressJudgment>();
+
+/** 판정이 stalled·abort-ignored·slow 로 «바뀔 때» `tui.survival` 관측을 전환마다 한 번만 남긴다(같은 값이면 조용히). */
+function noteTurnProgressSurvival(ptyId: string, judgment: TurnProgressJudgment, fields: { turnAt?: number; progressAt?: number; now: number }): void {
+  if (lastSurvivalJudgmentByPtyId.get(ptyId) === judgment) return;
+  lastSurvivalJudgmentByPtyId.set(ptyId, judgment);
+  const event = SURVIVAL_EVENT_OF[judgment as keyof typeof SURVIVAL_EVENT_OF];
+  if (!event) return;
+  const since = fields.progressAt ?? fields.turnAt;
+  debug.log('tui.survival', event, {
+    ptyId,
+    turnAt: fields.turnAt ?? null,
+    progressAt: fields.progressAt ?? null,
+    elapsedMs: since !== undefined ? Math.max(0, fields.now - since) : null,
+  });
+}
+
 /** `pty list` 한 칸 — 판을 적는 행(TUI)만. `run=<sha>` · 낡았으면 `,stale` · 옛 행 추정은 `run=?,stale`. */
 function formatListRunColumn(row: PtyManifestRow | undefined, deps: PtyTakeoverCommandDeps, installed: () => InstalledRecord): string {
   // 설치본 판독기가 없는 구성(시험 deps)은 이 칸을 안 낸다 — 기계마다 다른 값이 목록에 새지 않게.
@@ -2268,6 +2332,20 @@ export async function runPtyRename(ref: string, name: string, deps: PtyTakeoverC
   const renamed = (deps.renameLocal ?? renamePty)(id, nickname);
   return mapResult('rename', id, renamed ? { status: 'success' } : { status: 'unknown-pty' }, deps, observed);
 }
+/** `pty stop-turn` cancels the TUI's active turn through its owner; it never terminates the PTY process. */
+export async function runPtyStopTurn(ref: string, actor: PtyWriteActor, actorIdentity: string, reason: string, deps: PtyTakeoverCommandDeps = liveDeps): Promise<PtyTakeoverCommandResult> {
+  const identity = actorIdentity.trim();
+  const why = reason.trim();
+  if (!identity) return { exitCode: 2, message: 'pty stop-turn: --actor-id must not be empty' };
+  if (!why) return { exitCode: 2, message: 'pty stop-turn: --reason must not be empty' };
+  const refResult = resolveId(ref, 'stop-turn', deps); if (typeof refResult !== 'string') return refResult;
+  const id = refResult;
+  // A standalone CLI may not inherit a TUI run id. Mint one for this caller; inherited identity is retained so the
+  // owner still rejects a request from the same run as the target turn.
+  ensureRunId();
+  const request = { force: true as const, actorIdentity: identity, reason: why };
+  return mapResult('stop-turn', id, await deps.requestRemote(id, 'stop-turn', request, { actor }), deps, { ...request, actor });
+}
 export function registerPtyTakeoverCommands(program: Command, deps: PtyTakeoverCommandDeps = liveDeps, toolInstallDeps: ToolInstallDeps = {}): void {
   const pty = program.command('pty').description(
     // ⭐ `<ref>` = id · nickname · unique prefix — **ref 를 받는 하위명령**이 resolvePtyRef 로 해석한다(`list` 는 인자 없음).
@@ -2280,6 +2358,33 @@ export function registerPtyTakeoverCommands(program: Command, deps: PtyTakeoverC
     await deps.registerObservationSink?.();
     const result = await start(); (result.exitCode === 0 ? process.stdout : process.stderr).write(`${result.message}\n`); if (result.notice) process.stderr.write(`${result.notice}\n`); process.exitCode = result.exitCode;
   };
+  pty.command('new')
+    .description('Spawn a named PTY and register it for later access')
+    .requiredOption('--name <name>', 'human-readable PTY name')
+    .option('--purpose <purpose>', 'what this PTY is for')
+    .option('--kind <kind>', 'PTY kind (default: shell)', 'shell')
+    .option('--cwd <path>', 'working directory for the command')
+    .argument('[command...]', 'command and arguments to run after --')
+    .action(async (command: string[] = [], options: { name: string; purpose?: string; kind: string; cwd?: string }) => {
+      await deps.registerObservationSink?.();
+      if (command.length === 0) {
+        process.stderr.write('pty new requires a command after --\n');
+        process.exitCode = 2;
+        return;
+      }
+      try {
+        const handle = (deps.startPty ?? startPty)({
+          cmd: command[0]!, args: command.slice(1), kind: options.kind, nickname: options.name,
+          ...(options.purpose ? { purpose: options.purpose } : {}),
+          ...(options.cwd ? { workdir: options.cwd } : {}),
+        });
+        process.stdout.write(`${handle.id}\t${options.name}\t${options.purpose ?? ''}\n`);
+        process.exitCode = 0;
+      } catch (error) {
+        process.stderr.write(`failed to spawn PTY: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+      }
+    });
   pty.command('list')
     .description('List PTY ids available to other PTY commands')
     // ⭐ 하니스 자식은 **자기 워크트리 인스턴스**에 등록된다 — 부모 뿌리만 보면 안 보인다(실측).
@@ -2316,6 +2421,14 @@ export function registerPtyTakeoverCommands(program: Command, deps: PtyTakeoverC
   pty.command('takeover <ref>').description('Request human write ownership through the PTY arbiter').action((id: string) => run(() => runPtyTakeover(id, deps)));
   registerPtyAttachDriveCommand(pty, run);
   pty.command('release <ref>').description('Return human-owned PTY control to its prior mode').action((id: string) => run(() => runPtyRelease(id, deps)));
+  pty.command('stop-turn <ref>').requiredOption('--force', 'cancel the active turn and its child work without terminating the PTY')
+    .requiredOption('--actor <who>', 'actor type: human or agent').requiredOption('--actor-id <identity>', 'named requesting actor, such as OP or CEO')
+    .requiredOption('--reason <reason>', 'why this turn must be force-stopped').description('Force-stop an active TUI turn').action((id: string, opts: { actor: string; actorId: string; reason: string }) => {
+      const actor = parsePtyWriteActor(opts.actor);
+      return run(() => actor
+        ? runPtyStopTurn(id, actor, opts.actorId, opts.reason, deps)
+        : Promise.resolve({ exitCode: 2, message: `pty stop-turn: --actor must be 'human' or 'agent' (got ${opts.actor})` }));
+    });
   pty.command('state <ref>').option('--json', 'emit the classified frame state as JSON')
     .description('Classify the current PTY screen state').action((id: string, opts: { json?: boolean }) => run(() => runPtyState(id, deps, opts.json === true)));
   pty.command('wait <ref>').requiredOption('--until <state>', 'wait until idle, working, blocked, waiting, or done')

package/src/cli/release-checklist-read-cli.ts

@@ -56,8 +56,11 @@ export async function checklistOutput(v: string, codenames: Record<string, strin
   }
 }
 
+/** `version` scopes the item lookup; the default collector only needs that resolved item. */
 export type ChecklistEvidenceReader = (item: ReturnType<typeof listChecklist>['items'][number], version: string) => readonly ChecklistEvidenceStage[];
 
+const defaultChecklistEvidenceReader: ChecklistEvidenceReader = (item) => collectChecklistEvidenceStages(item);
+
 export type ChecklistEvidenceCommandRunner = (command: string, args: string[], timeout?: number) => { status: number | null; stdout: string; stderr: string; error?: string };
 const evidenceCommand: ChecklistEvidenceCommandRunner = (command, args, timeout = 20_000) => {
   const result = spawnSync(command, args, { cwd: process.cwd(), encoding: 'utf8', timeout, maxBuffer: 4 * 1024 * 1024 });
@@ -151,7 +154,7 @@ export function collectChecklistEvidenceStages(item: ReturnType<typeof listCheck
 }
 
 /** Register the same read commands on the full and lightweight release roots. */
-export function registerChecklistReadCommands(checklist: Command, evidenceReader: ChecklistEvidenceReader = collectChecklistEvidenceStages): void {
+export function registerChecklistReadCommands(checklist: Command, evidenceReader: ChecklistEvidenceReader = defaultChecklistEvidenceReader): void {
   const withContext = (cmd: Command) => cmd.option('--version <v>', '판 또는 별칭').option('--json', '결과 JSON').option('--hq-override', '본부 임대 거부를 관측하며 수동 우회');
   withContext(checklist.command('list').description('모든 칸')).option('--owner <owner>', '자리 또는 하위 자리로 거르기').action(async (opts: { owner?: string }, cmd: Command) => {
     const { version, codenames, json } = readChecklistContext(cmd);
@@ -174,7 +177,7 @@ export function registerChecklistReadCommands(checklist: Command, evidenceReader
 }
 
 /** The light router enters only list/status, so no publishing modules are loaded. */
-export function registerReleaseChecklistReadCommands(program: Command, evidenceReader: ChecklistEvidenceReader = collectChecklistEvidenceStages): void {
+export function registerReleaseChecklistReadCommands(program: Command, evidenceReader: ChecklistEvidenceReader = defaultChecklistEvidenceReader): void {
   const release = program.command('release').description('공개 배포 한 판 — prepare(로컬) → publish(--yes) → verify (docs/manual/MANUAL-versioning-and-release-2026-09-25.md)');
   const checklist = release.command('checklist').description('판별 확인표 조회·갱신')
     .option('--version <v>', '판 또는 별칭(기본: package.json 의 개발판에서 -dev.N 제거)')

package/src/cli/release-cli.ts

@@ -8,9 +8,11 @@
 //   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 recover --run <runId> --pick <sha...> [--from export-check] [--command-root <path>] [--repo-root <path>] [--no-partial] [--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]
+//   elanous release cut-branch --version <x.y.z> [--base <sha>] --pick <sha>... [--append] [--dry-run]
+//     (--append 에서 --base 생략: 런 원장 version-release 기록 또는 release/<v> 끝의 첫 부모에서 스스로 찾는다)
 //
 // 🩸 계기(2026-09-25 v0.1.0 첫 공개): 손으로 밟은 절차에서 둘을 빠뜨릴 뻔했다 — 공개본 git 커밋(판 커밋이 공개본 커밋이 된다) ·
 //    PWA 빌드(빌드 산출은 공개본에 안 실린다 → 빠뜨리면 «웹 화면 없는 판»). 절차를 명령으로 굳힌다.
@@ -43,7 +45,7 @@ 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, type ResumeReleaseDeps } from '../../scripts/release-loop/resume-release.js';
+import { planResumeReleaseRun, recoverReleaseRun, resumeReleaseRun, ReleaseRecoverStopped, type RecoverReleaseDeps } 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';
@@ -54,6 +56,7 @@ import { defaultReleaseGraphRunsRoot, formatPublishProposal, measurePublishWindo
 import { autoStartScheduledRelease, type AutoStartDeferral } from '../release-loop/auto-start.js';
 import { runRehearsalTick, type RehearsalDeps } from '../release-loop/rehearsal.js';
 import { landingFreezeMessage, LandingFrozenError, readLandingFreeze } from '../release-loop/landing-freeze.js';
+import { gateShardLedgerPath, latestGateShardLedger, readGateShardLedger } from '../release-loop/gate-shard-ledger.js';
 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';
@@ -604,9 +607,22 @@ function compareReleaseVersions(a: string, b: string): number {
   return 0;
 }
 
-export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}, landedDeps: LandedButYellowDeps = {}, hqDeps: HqDeps = {}, lightRcDeps: LightRcDeps = {}, rehearsalDeps: RehearsalDeps = {}, resumeDeps: ResumeReleaseDeps = {}, checklistEvidenceReader?: ChecklistEvidenceReader): void {
+export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}, landedDeps: LandedButYellowDeps = {}, hqDeps: HqDeps = {}, lightRcDeps: LightRcDeps = {}, rehearsalDeps: RehearsalDeps = {}, resumeDeps: RecoverReleaseDeps = {}, checklistEvidenceReader?: ChecklistEvidenceReader): void {
   registerRfcCommands(program);
   const release = program.command('release').description('공개 배포 한 판 — prepare(로컬) → publish(--yes) → verify (docs/manual/MANUAL-versioning-and-release-2026-09-25.md)');
+  release.command('gate-shards').description('실행 중에도 읽는 게이트 조각 원장(시도·귀속·증거)')
+    .requiredOption('--version <v>', '조회할 판').option('--all', '과거 전이와 재시도까지 조회').option('--json', '결과 JSON')
+    .action((o: { version: string; all?: boolean; json?: boolean }) => {
+      const path = gateShardLedgerPath(o.version, releaseRunDeps.ledgerRoot ?? releaseLedgerRoot());
+      const ledger = readGateShardLedger(path);
+      if (!ledger) throw new CliUserError(`게이트 조각 원장 없음: ${o.version}`, '게이트가 시작되면 다시 조회하세요.');
+      const rows = o.all ? ledger.rows : latestGateShardLedger(ledger.rows);
+      if (o.json) console.log(JSON.stringify({ version: o.version, path, malformed: ledger.malformed, rows }));
+      else {
+        console.log(`${o.version} 조각 ${rows.length} · 읽지 못한 행 ${ledger.malformed} · ${path}`);
+        for (const row of rows) console.log(`${row.phase}/${row.shardId} ${row.state} ${row.host ?? '?'} rc=${row.rc ?? '?'} ${row.ran ?? '?'}시험 · 실패 ${row.failureIds?.length ?? '?'} · 귀속 ${row.attribution} · ${row.files.length}파일${row.stopReason ? ` · ${row.stopReason}` : ''}`);
+      }
+    });
   const schedule = release.command('schedule').description('판별 컷·착지 마감 조회·갱신');
   const scheduleLedgerRoot = () => releaseRunDeps.ledgerRoot ?? releaseLedgerRoot();
   const ledgerFenceDeps = (): HqDeps => getElanousConfigDirOverride() && !hqDeps.store && !getUserConfig().hq?.arbiter
@@ -917,9 +933,14 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .option('--allow-duplicate-id', '다른 판에 같은 id 가 있어도 경고 후 추가')
     .option('--strict', '대상 경로·완료 경계 경고가 있으면 저장 전 거부')
     .option('--ref <path...>', '근거 문서 — 저장소 상대 경로[#절] (반복 가능)')
-    .action((id: string, title: string, opts: { ref?: string[]; owner?: string; kind?: string; priority?: string; deadlineVersion?: string; predecessor?: string[]; ceoMinutes?: string; ceoDate?: string; accelerator?: boolean; allowDuplicateId?: boolean; strict?: boolean }, cmd: Command) => {
+    .action(async (id: string, title: string, opts: { ref?: string[]; owner?: string; kind?: string; priority?: string; deadlineVersion?: string; predecessor?: string[]; ceoMinutes?: string; ceoDate?: string; accelerator?: boolean; allowDuplicateId?: boolean; strict?: boolean }, cmd: Command) => {
     const { version, json } = context(cmd);
     if (!mayWrite(cmd)) return;
+    const { normalizeEvidenceCommandLines } = await import('../task-agent/evidence-command-normalize.js');
+    const normalized = normalizeEvidenceCommandLines(title);
+    if (opts.strict && normalized.unrecognized.length) throw new CliUserError(`완료 경계 증거 명령 정규화 불가: ${normalized.unrecognized.join(' · ')}`);
+    title = normalized.text;
+    for (const warning of normalized.warnings) console.error(`⚠ ${warning}`);
     const dispatchKind = opts.kind && !['screen', 'postpub'].includes(opts.kind) ? opts.kind as ChecklistDispatchKind : undefined;
     warnChecklistTargetPaths({ title, refs: opts.ref, dispatchKind }, opts.strict);
     const data = addItem(version, { id, title, ...(opts.ref !== undefined ? { refs: opts.ref } : {}), ...(opts.owner !== undefined ? { owner: opts.owner } : {}), ...(opts.kind !== undefined && !dispatchKind ? { kind: opts.kind as ChecklistKind } : {}), ...(dispatchKind ? { dispatchKind } : {}), ...(opts.priority !== undefined ? { priority: opts.priority as PlacementPriority } : {}), ...(opts.deadlineVersion !== undefined ? { deadlineVersion: opts.deadlineVersion } : {}), ...(opts.predecessor !== undefined ? { predecessors: opts.predecessor } : {}), ...(opts.ceoMinutes !== undefined ? { ceoMinutes: ceoMinutes(opts.ceoMinutes) } : {}), ...(opts.ceoDate !== undefined ? { ceoDate: opts.ceoDate } : {}), ...(opts.accelerator ? { accelerator: true } : {}) }, { allowDuplicateId: opts.allowDuplicateId });
@@ -985,9 +1006,14 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
       else features.move(id, from, to, actor(), undefined, undefined, opts.reason);
       if (json) console.log(JSON.stringify(listChecklist(to))); else console.log(`✅ ${id} ${from} → ${to}`);
     });
-  withContext(checklist.command('retitle <id> <title>').description('칸 제목 수정')).option('--strict', '대상 경로·완료 경계 경고가 있으면 저장 전 거부').action((id: string, title: string, opts: { strict?: boolean }, cmd: Command) => {
+  withContext(checklist.command('retitle <id> <title>').description('칸 제목 수정')).option('--strict', '대상 경로·완료 경계 경고가 있으면 저장 전 거부').action(async (id: string, title: string, opts: { strict?: boolean }, cmd: Command) => {
     const { version, json } = context(cmd);
     if (!mayWrite(cmd)) return;
+    const { normalizeEvidenceCommandLines } = await import('../task-agent/evidence-command-normalize.js');
+    const normalized = normalizeEvidenceCommandLines(title);
+    if (opts.strict && normalized.unrecognized.length) throw new CliUserError(`완료 경계 증거 명령 정규화 불가: ${normalized.unrecognized.join(' · ')}`);
+    title = normalized.text;
+    for (const warning of normalized.warnings) console.error(`⚠ ${warning}`);
     const snapshot = listChecklist(version);
     const item = snapshot.items.find((entry) => entry.id === id);
     if (!opts.strict) warnChecklistTargetPaths({ title, evidence: item?.evidence, refs: item?.refs, dispatchKind: item?.dispatchKind });
@@ -1093,12 +1119,12 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
   release.command('cut-branch')
     .description('원래 컷에 main 의 수리 커밋만 얹은 release/<v> 가지를 만들고 push. --append 는 이미 있는 가지에 fast-forward 로만 더 얹는다')
     .requiredOption('--version <v>', '릴리스 판(x.y.z)')
-    .requiredOption('--base <sha>', '원래 컷 SHA')
+    .option('--base <sha>', '원래 컷 SHA(--append 에서 생략하면 런 원장 version-release 기록이나 release/<v> 끝의 첫 부모에서 스스로 찾는다)')
     .requiredOption('--pick <sha...>', '차례로 얹을 main 커밋 SHA')
     .option('--append', '이미 있는 release/<v> 를 출발점으로 fast-forward push(강제 push 없음)')
     .option('--dry-run', '가지·worktree·push 없이 계획만 출력')
     .option('--json', '결과 한 줄 JSON(stdout)')
-    .action(async (o: { version: string; base: string; pick: string[]; append?: boolean; dryRun?: boolean; json?: boolean }) => {
+    .action(async (o: { version: string; base?: string; pick: string[]; append?: boolean; dryRun?: boolean; json?: boolean }) => {
       await jsonAction(o.json, async (log) => cutReleaseBranch({ ...o, log }), () => true);
     });
   const runAction = async (o: { version: string; cutCommit?: string; mainCut?: boolean; prerelease?: string; dryRun?: boolean; ifReady?: boolean; publishAt?: string; forceFreeze?: boolean; forceNew?: boolean; gateExecutor?: string; gateHost?: string; json?: boolean }, logRun = console.log): Promise<boolean | AutoStartDeferral | undefined> => {
@@ -1259,16 +1285,17 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .option('--remote <host>', '게이트 호스트(기본 config gateRemote.host)')
     .option('--local', '원격 대신 이 기계에서 돌린다(원격 자식이 이것으로 다시 불린다)')
     .option('--shards <n>', '시험 분할 수', '4')
+    .option('--shard-concurrency <n>', '동시에 실행할 조각 묶음 수 (1–4, 기본 3)')
     .option('--fixed-shard-distribution', 'self gate 에 그대로 전달 — RSS 사전 측정 없이 --shards N 조각에 정렬 라운드로빈 고정 배정(opt-in · 원격 자식 전달)')
     .option('--rehearsal-tui', '리허설 전용 TUI 화면 점검(원격 자식 전달)')
     .option('--json', '결과 한 줄 JSON(stdout) · 사람 줄은 stderr')
-    .action(async (o: { version: string; base?: string; head?: string; remote?: string; local?: boolean; shards: string; fixedShardDistribution?: boolean; rehearsalTui?: boolean; json?: boolean }) => {
+    .action(async (o: { version: string; base?: string; head?: string; remote?: string; local?: boolean; shards: string; shardConcurrency?: string; fixedShardDistribution?: boolean; rehearsalTui?: boolean; json?: boolean }) => {
       // The root strips `--local` from argv (remote-bookmark attach) before Commander sees it — same read as `self gate`.
       const local = !!o.local || process.argv.slice(2).includes('--local');
       await jsonAction(o.json, async (log) => {
         if (o.remote !== undefined && local) throw new Error('release light-rc: --remote and --local cannot be combined');
         const shards = Number(o.shards);
-        const result = await runLightRc(o.version, { base: o.base, head: o.head, remote: o.remote, local, shards, ...(o.fixedShardDistribution ? { fixedShardDistribution: true } : {}), rehearsalTui: o.rehearsalTui, ledgerRoot: releaseRunDeps.ledgerRoot, log: (l) => console.error(l) }, lightRcDeps);
+        const result = await runLightRc(o.version, { base: o.base, head: o.head, remote: o.remote, local, shards, ...(o.shardConcurrency !== undefined ? { shardConcurrency: Number(o.shardConcurrency) } : {}), ...(o.fixedShardDistribution ? { fixedShardDistribution: true } : {}), rehearsalTui: o.rehearsalTui, ledgerRoot: releaseRunDeps.ledgerRoot, log: (l) => console.error(l) }, lightRcDeps);
         for (const line of formatLightRc(result)) log(line);
         return result;
       }, (r) => r.ok);
@@ -1285,10 +1312,13 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .option('--gate-executor <pod|host>', '다시 도는 gate 의 실행기 전환(--from gate 이전만) — 런 입력에 기록 · 면제 아님')
     .option('--gate-host <ssh-host>', '--gate-executor host 의 SSH 호스트(기본 저장된 런 입력 gateRemote)')
     .option('--gate-pod-pool <pool>', '다시 도는 gate 의 Pod 풀을 전환(--from gate 이전만) — 런 입력에 기록')
+    .option('--reroute-shard <pod-N|auto>', '같은 컷의 조각 한 개를 새로 측정하고 나머지 완전 영수증은 승계(--from gate)')
+    .option('--shard-host <pool-context>', '재지정 조각의 호스트 수동 지정(생략 시 가용 능력 기반 배치)')
+    .option('--shard-os <darwin|linux>', '재지정 pod-N 조각에 필요한 OS 능력')
     .option('--command-root <path>', '노드 명령을 실행할 컷 tip checkout(생략 시 현재 폴더)')
     .option('--dry-run', '재개 preflight만 수행하고 런·상태 원장·시도 횟수는 변경하지 않는다')
     .option('--json', '결과 한 줄 JSON(stdout)')
-    .action(async (o: { run: string; from: string; partial?: boolean; waive?: string; reason?: string; acceptedRegressions?: string; gateExecutor?: string; gateHost?: string; gatePodPool?: string; commandRoot?: string; dryRun?: boolean; json?: boolean }) => {
+    .action(async (o: { run: string; from: string; partial?: boolean; waive?: string; reason?: string; acceptedRegressions?: string; gateExecutor?: string; gateHost?: string; gatePodPool?: string; rerouteShard?: string; shardHost?: string; shardOs?: string; commandRoot?: string; dryRun?: boolean; json?: boolean }) => {
       await jsonAction(o.json, async (log) => {
         let acceptedRegressions: AcceptedRegression[] | undefined;
         if (o.acceptedRegressions !== undefined) {
@@ -1299,13 +1329,18 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
             throw new Error('acceptedRegressions must be an array of {id, note}');
           }
         }
+        if (o.shardOs !== undefined && o.shardOs !== 'darwin' && o.shardOs !== 'linux') throw new Error('--shard-os must be darwin or linux');
+        const shardOs = o.shardOs as 'darwin' | 'linux' | undefined;
         const resumeOptions = { runId: o.run, from: o.from, partial: o.partial, commandRoot: o.commandRoot,
           ...(o.waive === undefined ? {} : { waive: o.waive }),
           ...(o.reason === undefined ? {} : { reason: o.reason }),
           ...(o.acceptedRegressions === undefined ? {} : { acceptedRegressions }),
           ...(o.gateExecutor === undefined ? {} : { gateExecutor: o.gateExecutor }),
           ...(o.gateHost === undefined ? {} : { gateHost: o.gateHost }),
-          ...(o.gatePodPool === undefined ? {} : { gatePodPool: o.gatePodPool }) };
+          ...(o.gatePodPool === undefined ? {} : { gatePodPool: o.gatePodPool }),
+          ...(o.rerouteShard === undefined ? {} : { rerouteShard: o.rerouteShard }),
+          ...(o.shardHost === undefined ? {} : { shardHost: o.shardHost }),
+          ...(shardOs === undefined ? {} : { shardOs }) };
         if (o.dryRun) {
           const plan = await planResumeReleaseRun(resumeOptions, { onSource: log });
           const gate = plan.gatePlan.mode === 'not-run' ? 'gate 실행 없음'
@@ -1328,6 +1363,31 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
           ...(o.gatePodPool !== undefined && poolOverride?.kind === 'gate-pod-pool' ? { gatePodPool: poolOverride } : {}) };
       }, (r) => 'preflight' in r || r.status === 'done' || r.status === 'awaiting-approval');
     });
+  // RELEASE-RECOVER-ONE-CMD (0.2.36): the three repair steps RUNBOOK-release-recover chained by hand, in one command.
+  release.command('recover')
+    .description('발행 실패 복구를 한 명령으로 — release/<v> 에 수리 커밋을 fast-forward 로 얹는 append dry-run → append → resume --from export-check. resume이 거부할 런(상태 · --from 배치 · 컷 정체 · 시도 원장)은 append 전에 읽기 전용으로 먼저 가려 가지를 먼저 움직이지 않는다 · 원장의 append-ok가 가지 끝에 살아 있으면 append 없이 resume부터 재진입한다 · 한 단계라도 실패하면 그 자리에서 멈추고 다음 단계는 실행하지 않는다(사람 판단) · 단계 결과는 resume-attempts 원장에 남는다')
+    .requiredOption('--run <runId>', '실패한 release-loop 런 ID')
+    .requiredOption('--pick <sha...>', 'release/<v> 에 fast-forward 로 얹을 main 수리 커밋 SHA')
+    .option('--from <node>', '재개 시작 노드 — 기본 export-check(컷을 쓰는 첫 노드)')
+    .option('--command-root <path>', '노드 명령을 실행할 컷 tip checkout — 생략 시 recover가 append tip 의 임시 checkout 을 직접 마련한다(운영자 checkout 은 그대로) · 직접 지정하면 사람 판단 경계다: 계획 단계에서 tip 과 대조해 다르면 멈춘다')
+    .option('--repo-root <path>', 'append(cut-branch)를 실행할 checkout — git remote origin 이 있는 곳(생략 시 현재 폴더)')
+    .option('--no-partial', 'GATE-REUSE-BY-DIFF 기본 부분 재검을 끄고 전체 게이트')
+    .option('--json', '결과 한 줄 JSON(stdout) · 사람 줄은 stderr')
+    .action(async (o: { run: string; pick: string[]; from?: string; commandRoot?: string; repoRoot?: string; partial?: boolean; json?: boolean }) => {
+      await jsonAction(o.json, async (log) => {
+        try {
+          return await recoverReleaseRun({ runId: o.run, pick: o.pick,
+            ...(o.from === undefined ? {} : { from: o.from }),
+            ...(o.commandRoot === undefined ? {} : { commandRoot: o.commandRoot }),
+            ...(o.repoRoot === undefined ? {} : { repoRoot: o.repoRoot }),
+            ...(o.partial === undefined ? {} : { partial: o.partial }) },
+          { ...resumeDeps, onSource: log });
+        } catch (caught) {
+          if (!(caught instanceof ReleaseRecoverStopped)) throw caught;
+          return { ok: false as const, error: caught.message, stages: [...caught.stages], notRun: [...caught.notRun] };
+        }
+      }, (r) => r.stages.every((stage) => stage.outcome === 'ok'));
+    });
   release.command('gate-history')
     .description('GATE-FAIL-HISTORY (0.2.29) — 판을 넘는 게이트 실패 표 — 모든 release-loop·light-rc 런 원장 ⊕ gate-verdict 에서 시험 파일별 introduced·preexisting·env·flaky 횟수 · 마지막 실패 판 · 원인 PR(수리 PR 본문 «원인 #N»)')
     .option('--since <판|일>', '이 판(x.y.z)부터 · 또는 그 날(YYYY-MM-DD) 이후 시작된 런부터')
@@ -1389,12 +1449,36 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
             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 };
+          const schedules = listSchedules(ledgerRoot);
+          if (schedules.length === 0) {
+            const resumed = await resumeReleaseRun(resumeOptions, resumeDeps);
+            log(`· 리허설 복구 완료 · run ${o.recoveryRun} · ${resumed.state.status} · gate에서 재개`);
+            return { recovery: 'resumed', runId: o.recoveryRun, status: resumed.state.status, ...resumed };
+          }
         }
         if (o.apply && !mayWriteLedger('release rehearsal tick', false, ledgerRoot)) throw new Error('release rehearsal tick: ledger write denied');
-        const result = await runRehearsalTick({ apply: o.apply, checkout: o.checkout, shards: o.shards === undefined ? undefined : Number(o.shards), remote: o.remote, ledgerRoot }, rehearsalDeps);
+        const result = await runRehearsalTick({ apply: o.apply, checkout: o.checkout, shards: o.shards === undefined ? undefined : Number(o.shards), remote: o.remote, recoveryRun: o.recoveryRun, ledgerRoot }, {
+          ...rehearsalDeps,
+          resumeGate: rehearsalDeps.resumeGate ?? (async (runId, checkout) => {
+            const resumed = await resumeReleaseRun({ runId, from: 'gate', commandRoot: checkout }, resumeDeps);
+            const gate = resumed.state.nodes.find((node) => node.nodeId === 'gate');
+            if (typeof gate?.output !== 'string') throw new Error('release resume --from gate produced no gate output');
+            const outputLine = gate.output.split(/\r?\n/).filter((line) => line.trim().startsWith('{')).at(-1);
+            if (!outputLine) throw new Error('release resume --from gate produced no JSON output');
+            let parsed: Record<string, unknown>;
+            try { parsed = JSON.parse(outputLine) as Record<string, unknown>; }
+            catch { throw new Error('release resume --from gate produced invalid gate JSON'); }
+            const startedAt = Date.parse(gate?.startedAt ?? '');
+            const endedAt = Date.parse(gate?.endedAt ?? '');
+            const summary = parsed.partialSummary as { files?: unknown } | undefined;
+            if (!Number.isSafeInteger(summary?.files) || Number(summary!.files) < 0) throw new Error('release resume --from gate omitted measured partialSummary.files');
+            if (!Number.isFinite(startedAt) || !Number.isFinite(endedAt) || endedAt < startedAt) throw new Error('release resume --from gate omitted valid gate timestamps');
+            return { files: Number(summary!.files),
+              durationMs: endedAt - startedAt,
+              poolOverwriteApplied: (resumed.state.inputOverrides ?? []).some((item) => item.kind === 'gate-pod-pool'),
+              ok: resumed.state.status === 'done' && parsed.outcome === 'ok' };
+          }),
+        });
         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))

package/src/cli/repo-cli.ts

@@ -6,6 +6,7 @@ import type { Command } from 'commander';
 
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { debug } from '../debug/log.js';
+import { spawnWithOwnedStderr } from '../surface/child-process.js';
 import { applyDesignDirection } from '../design/apply-direction.js';
 import { createCustomSystemFromPalette, createCustomSystemFromUrl, unreadTokenCount } from '../design/custom-system-create.js';
 import { libraryDir } from '../design/design-library.js';
@@ -731,7 +732,7 @@ export function registerRepoCommands(program: Command, overrides: RepoCliDeps =
         // ⭐ stderr 는 «흘려 보낸다» — 채점기가 쪽마다 진행을 거기 적는다.
         //   🩸 2026-09-14 7판 terra: 전 쪽 채점이 5분 넘게 «말없이» 돌자 감독자가 「진행 없음」으로 판정해 재작업을 걸었다.
         //   ⛔ 게다가 'pipe' 로 받고 «안 읽으면» 버퍼가 차는 순간 자식이 멈춘다.
-        const proc = Bun.spawn(['bun', join(scripts, script), ...args], { stdout: 'pipe', stderr: 'inherit' });
+        const proc = spawnWithOwnedStderr(['bun', join(scripts, script), ...args], { stdout: 'pipe' });
         const out = await new Response(proc.stdout).text();
         await proc.exited;
         return { code: proc.exitCode ?? 1, out };