elanous 0.2.37 → 0.2.38

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

@@ -4,7 +4,7 @@ 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 { getPty, listPty, renamePty, requestPtyTakeover, startPty, type StartOpts } 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 { 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';
@@ -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. */
@@ -1492,7 +1516,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,
@@ -2280,6 +2306,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')
     // ⭐ 하니스 자식은 **자기 워크트리 인스턴스**에 등록된다 — 부모 뿌리만 보면 안 보인다(실측).

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';
@@ -604,7 +606,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 = {}, 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)');
   const schedule = release.command('schedule').description('판별 컷·착지 마감 조회·갱신');
@@ -917,9 +919,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 +992,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 +1105,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 +1271,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);
@@ -1328,6 +1341,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) 이후 시작된 런부터')

package/src/cli/review-carry.ts

@@ -0,0 +1,77 @@
+/** Prove that a PR's new head is exactly a clean merge of main into its reviewed head. */
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { delimiter, join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const SHA = /^[0-9a-f]{40}$/i;
+const MAX = 32 * 1024 * 1024;
+
+export type ReviewCarryProof = { ok: true; oldBase: string; newBase: string; patchId: string; pathsModesHash: string }
+  | { ok: false; reason: string };
+
+/** No refs, index, or worktree are changed. merge-tree objects live in a disposable directory. */
+export function proveReviewCarry(cwd: string, oldHead: string, newHead: string, remote = 'origin', branch = 'main'): ReviewCarryProof {
+  if (!SHA.test(oldHead) || !SHA.test(newHead) || oldHead === newHead) return { ok: false, reason: 'carry-invalid-head' };
+  const run = (args: string[], env?: NodeJS.ProcessEnv, input?: string) => spawnSync('git', args,
+    { cwd, env, input, encoding: 'utf8', maxBuffer: MAX });
+  const read = (args: string[], env?: NodeJS.ProcessEnv): string | null => {
+    const result = run(args, env);
+    return result.status === 0 && !result.error ? result.stdout.trim() : null;
+  };
+  const parents = read(['rev-list', '--parents', '-n', '1', newHead])?.split(/\s+/);
+  if (!parents || parents.length !== 3 || parents[0]?.toLowerCase() !== newHead.toLowerCase()
+    || parents[1]?.toLowerCase() !== oldHead.toLowerCase() || !SHA.test(parents[2] ?? '')) {
+    return { ok: false, reason: 'carry-not-direct-main-merge' };
+  }
+  const newBase = parents[2]!.toLowerCase();
+  const main = read(['rev-parse', '--verify', `refs/remotes/${remote}/${branch}`]);
+  if (!main || !SHA.test(main) || run(['merge-base', '--is-ancestor', newBase, main]).status !== 0) {
+    return { ok: false, reason: 'carry-main-parent-unmeasured' };
+  }
+  const oldBase = read(['merge-base', oldHead, newBase]);
+  if (!oldBase || !SHA.test(oldBase)) return { ok: false, reason: 'carry-old-base-unmeasured' };
+  if (oldBase.toLowerCase() === oldHead.toLowerCase()) return { ok: false, reason: 'carry-no-pr-patch' };
+  const objects = read(['rev-parse', '--git-path', 'objects']);
+  if (!objects) return { ok: false, reason: 'carry-object-directory-unmeasured' };
+  let temporary: string;
+  try { temporary = mkdtempSync(join(tmpdir(), 'elanous-review-carry-')); }
+  catch { return { ok: false, reason: 'carry-temp-directory-unmeasured' }; }
+  const env = { ...process.env, GIT_OBJECT_DIRECTORY: temporary,
+    GIT_ALTERNATE_OBJECT_DIRECTORIES: [resolve(cwd, objects), process.env.GIT_ALTERNATE_OBJECT_DIRECTORIES].filter(Boolean).join(delimiter) };
+  try {
+    const mergedTree = read(['merge-tree', '--write-tree', oldHead, newBase], env);
+    if (!mergedTree || !SHA.test(mergedTree)) return { ok: false, reason: 'carry-merge-conflict-or-unmeasured' };
+    const actualTree = read(['rev-parse', '--verify', `${newHead}^{tree}`]);
+    if (!actualTree || actualTree.toLowerCase() !== mergedTree.toLowerCase()) {
+      return { ok: false, reason: 'carry-merge-tree-changed' };
+    }
+    const changed = (from: string, to: string, objectEnv?: NodeJS.ProcessEnv) => {
+      const raw = run(['diff', '--raw', '--no-renames', '--no-abbrev', '-z', from, to], objectEnv);
+      const numstat = read(['diff', '--numstat', from, to], objectEnv);
+      const diff = read(['diff', '--no-ext-diff', '--no-renames', '--binary', from, to], objectEnv);
+      if (raw.status !== 0 || raw.error || numstat === null || !diff) return null;
+      if (numstat.split('\n').some((line) => /^-\t-\t/.test(line))) return null;
+      const fields = raw.stdout.split('\0').filter(Boolean);
+      if (!fields.length || fields.length % 2 !== 0) return null;
+      const pathsModes: string[] = [];
+      for (let i = 0; i < fields.length; i += 2) {
+        const match = /^:([0-7]{6}) ([0-7]{6}) [0-9a-f]{40,64} [0-9a-f]{40,64} ([A-Z])$/i.exec(fields[i]!);
+        if (!match || !fields[i + 1] || !['A', 'M', 'D', 'T'].includes(match[3]!)) return null;
+        pathsModes.push(`${match[3]}\0${match[1]}\0${match[2]}\0${fields[i + 1]}`);
+      }
+      const patched = run(['patch-id', '--stable'], objectEnv, `${diff}\n`);
+      const patchId = patched.status === 0 && !patched.error ? patched.stdout.trim().split(/\s+/)[0] : null;
+      return patchId && SHA.test(patchId) ? { patchId: patchId.toLowerCase(), pathsModes: pathsModes.sort() } : null;
+    };
+    const before = changed(oldBase, oldHead);
+    const after = changed(newBase, newHead);
+    if (!before || !after) return { ok: false, reason: 'carry-patch-unmeasured' };
+    if (before.patchId !== after.patchId || JSON.stringify(before.pathsModes) !== JSON.stringify(after.pathsModes)) {
+      return { ok: false, reason: 'carry-patch-or-path-mode-changed' };
+    }
+    return { ok: true, oldBase: oldBase.toLowerCase(), newBase, patchId: before.patchId,
+      pathsModesHash: createHash('sha256').update(JSON.stringify(before.pathsModes)).digest('hex') };
+  } finally { rmSync(temporary, { recursive: true, force: true }); }
+}

package/src/cli/self-update.ts

@@ -496,7 +496,7 @@ export function assessRailSafe(input: AssessRailSafeInput): {
   const heldVersions = plan.removed.filter((name) => {
     const path = join(input.versionsDir, name);
     try {
-      return listedProcessCommands(listProcesses(pgrepPathPattern(path)), readCommand).some((argv) => argv.includes(path));
+      return listedProcessCommands(listProcesses(pgrepPathPattern(path)), readCommand).some((argv) => argvReferencesVersion(argv, path));
     } catch { return false; }
   });
   let releaseRunActive = false;

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

@@ -5,6 +5,8 @@ import { readCardSalvageBranch, refreshCardRunBinding } from '../task-agent/card
 import { captureReviewResults } from '../task-agent/review-result-capture.js';
 import type { TasksCliDeps } from './tasks-cli.js';
 import { registerTaskAgentSink } from './tasks-read-cli.js';
+import { readFileSync } from 'node:fs';
+import { loadGoalAskRecords } from '../self-implement/goal-ask-store.js';
 
 /**
  * CLI-ENTRY-LAZY — `tasks show ta-…`(TASK-AGENT 과제 카드) 상세. `tasks-read-cli.ts` 가 카드 id 일 때만 싣는다.
@@ -30,6 +32,34 @@ function moveLine(card: TaskCard): string {
   return `${move.kind}${move.command ? ` — elanous ${move.command.map(shellQuote).join(' ')}` : ''} (${move.reason})`;
 }
 
+const GOAL_BODY_SUMMARY_LIMIT = 8_000;
+
+function cardGoalEvidence(card: TaskCard, deps: TasksCliDeps): {
+  goalFile: string | null; goalBody: string | null; hasTddPlan: boolean | null;
+  hasBoundary: boolean | null; knowhowInjected: boolean | null;
+} {
+  let document: { goalFile: string; goalBody: string } | null = null;
+  try {
+    if (card.goalId && deps.cardGoalDocument) document = deps.cardGoalDocument(card.goalId);
+    else if (card.goalId) {
+      const record = loadGoalAskRecords({ goalId: card.goalId, limit: 1 })[0];
+      if (record) document = { goalFile: record.goalFile, goalBody: readFileSync(record.goalFile, 'utf8') };
+    }
+  } catch (error) {
+    try { debug.log('task-agent', 'card-goal-read-failed', { cardId: card.id, goalId: card.goalId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+  }
+  if (!document) return { goalFile: null, goalBody: null, hasTddPlan: null, hasBoundary: null, knowhowInjected: null };
+  const body = document.goalBody;
+  const hasTddPlan = /^#{1,6}\s+.*(?:TDD|test[- ]driven|테스트 주도).*$/im.test(body);
+  const hasBoundary = /(?:완료 경계|완료 조건|acceptance criteria|completion boundary)/i.test(body);
+  const knowhowInjected = /\[KNOWHOW-PACK\b[^\]]*\]/i.test(body);
+  return {
+    goalFile: document.goalFile,
+    goalBody: body.length <= GOAL_BODY_SUMMARY_LIMIT ? body : `${body.slice(0, GOAL_BODY_SUMMARY_LIMIT)}… [truncated]`,
+    hasTddPlan, hasBoundary, knowhowInjected,
+  };
+}
+
 export function headLine(text: string): string {
   const first = text.split('\n')[0]!.trim();
   return first.length > 100 ? `${first.slice(0, 100)}…` : first;
@@ -152,7 +182,7 @@ export async function showTaskCard(id: string, opts: { json?: boolean }, deps: T
   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 } : {}) }));
+  if (opts.json) out(JSON.stringify({ card, nextMove: nextMoveFor(card), ...cardGoalEvidence(card, deps), 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}` : ''}`);