elanous 0.2.38 → 0.2.40

package/src/cli/agent-cli.ts

@@ -68,6 +68,25 @@ export function setCliAgentDispatchForTesting(dispatch: CliAgentDispatch | undef
   cliAgentDispatchForTesting = dispatch;
 }
 
+/** A completed standalone agent turn must not wait forever for a tool's leftover handle. */
+function armAgentCliExitSafetyNet(): void {
+  const timer = setTimeout(() => {
+    try {
+      const runtime = process as typeof process & {
+        _getActiveHandles?: () => Array<{ constructor?: { name?: string } }>;
+        _getActiveRequests?: () => Array<{ constructor?: { name?: string } }>;
+      };
+      const handleTypes = runtime._getActiveHandles?.().map(h => h.constructor?.name ?? 'unknown') ?? [];
+      const requestTypes = runtime._getActiveRequests?.().map(r => r.constructor?.name ?? 'unknown') ?? [];
+      debug.log('agent.cli.exit', 'grace-expired', { handleTypes, requestTypes }, { level: 'warn' });
+      debug.flush();
+    } finally {
+      process.exit(0);
+    }
+  }, 1_000);
+  timer.unref();
+}
+
 export function registerAgentCommands(program: Command): void {
   const agentCommand = program
   .command('agent')
@@ -128,6 +147,10 @@ export function registerAgentCommands(program: Command): void {
       // commander stores --no-tools as `tools: false`, plain absence as undefined → default true here.
       enableTools: opts.tools !== false,
     });
+    // runChatTurnCli has already flushed its JSON reply. Let clean turns exit
+    // naturally; a referenced child/socket/timer left by a tool gets one second
+    // before we log the surviving handles and end this standalone process.
+    armAgentCliExitSafetyNet();
   });
 
 // ── agent dispatch — RFC #7333 `A1` (트리거) ──
@@ -413,7 +436,7 @@ tierCmd
  *  ui.info trailer and instead emits exactly ONE JSON line on stdout
  *  at end-of-turn:
  *    {sessionId, provider, model, reply, finalReply, transcript, logPath,
- *     budget, durationMs, ts}
+ *     budget, durationMs, ts, incomplete}
  *  Stable shape so LLMs can self-spawn `elanous chat` for follow-ups
  *  without parsing human-readable terminal output. */
 export async function runChatTurnCli(opts: {
@@ -484,7 +507,7 @@ export async function runChatTurnCli(opts: {
     dbg.setAmbientSessionId?.(session.id);
   } catch { /* debug module unavailable — fine */ }
   const replyChunks: string[] = [];
-  // Tool calls delimit assistant messages. finalReply retains its last non-empty-message meaning.
+  // Tool calls delimit assistant messages. Only text after the last tool call can be the final reply.
   let segmentChunks: string[] = [];
   let lastSegment = '';
   let finalMessage = '';
@@ -507,14 +530,17 @@ export async function runChatTurnCli(opts: {
   let tools: ReturnType<typeof buildCliAgentTools> | undefined;
   let dispatchTool: ((name: string, args: Record<string, unknown>) => Promise<unknown>) | undefined;
   let enabledToolNames: string[] | undefined;
+  const toolAbort = new AbortController();
+  const abortToolsOnSigint = (): void => toolAbort.abort();
   if (opts.enableTools) {
     const built = buildCliAgentTools(opts.cfg, harnessSpace ? {
       sessionId: session.id,
       emitFeedback: emitHarnessFeedbackProgress,
     } : undefined);   // ★ cfg 전달 → financeEnabled 시 finance 팩 노출(서피스 게이팅 정리)
     tools = built;
-    dispatchTool = built.dispatch;
+    dispatchTool = (name, args) => built.dispatch(name, args, { signal: toolAbort.signal });
     enabledToolNames = built.specs.map(s => s.name);
+    process.once('SIGINT', abortToolsOnSigint);
   }
   // Wire the universal preamble (project anchor + project tree +
   // family addendum + session-specific guidance) into every CLI system
@@ -604,6 +630,8 @@ export async function runChatTurnCli(opts: {
       process.exit(2);
     }
     throw err;
+  } finally {
+    if (opts.enableTools) process.removeListener('SIGINT', abortToolsOnSigint);
   }
   if (!sawToolCall && replyChunks.length === 0 && result.text) {
     replyChunks.push(result.text);
@@ -611,6 +639,7 @@ export async function runChatTurnCli(opts: {
     if (!opts.json && !opts.enableTools) process.stdout.write(result.text);
   }
   closeSegment();
+  const incomplete = sawToolCall && finalMessage.length === 0;
   if (opts.json) {
     let logPath: string | null = null;
     try {
@@ -624,17 +653,23 @@ export async function runChatTurnCli(opts: {
       model: result.model ?? null,
       reply: finalMessage,
       transcript: replyChunks.join(''),
-      finalReply: lastSegment,
+      finalReply: sawToolCall ? finalMessage : lastSegment,
+      incomplete,
       budget: sessionBudget(session.id),
       durationMs: Date.now() - startedAt,
       logPath,
       ts: new Date().toISOString(),
     };
     await writeStdoutJson(JSON.stringify(out) + '\n');
+    if (incomplete) process.exitCode = 1;
     return;
   }
   if (opts.enableTools) process.stdout.write(`${finalMessage}\n`);
   else process.stdout.write('\n');
+  if (incomplete) {
+    console.error('Turn ended without a final assistant reply.');
+    process.exitCode = 1;
+  }
   ui.info(`[session ${session.id.slice(0, 8)}  ${result.provider}${result.model ? '/' + result.model : ''}  ${sessionBudget(session.id)}]`);
 }
 
@@ -655,7 +690,7 @@ export function buildCliAgentTools(
   trustedWorkingDirectory?: string,
 ): {
   specs: import('../llm.js').LLMToolSpec[];
-  dispatch: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+  dispatch: (name: string, args: Record<string, unknown>, context?: { signal?: AbortSignal }) => Promise<unknown>;
   workingDirectory: string;
 } {
   // An explicitly assigned child cwd is stable for its isolated lifetime. An
@@ -706,7 +741,7 @@ export function buildCliAgentTools(
   //   게이트. [[project_skill_native_duplication_surface_gating]].
   const shared = (require('../agent/shared-app-tools.js') as typeof import('../agent/shared-app-tools.js')).buildSharedAppTools(cfg);
   for (const s of shared.specs) specs.push(s);
-  for (const name of shared.names) dispatchByName.set(name, async (args) => shared.dispatch(name, args));
+  for (const name of shared.names) dispatchByName.set(name, async (args, signal) => shared.dispatch(name, args, { surface: 'tui', signal }));
   // Installed knowledge is queryable in CLI chat as well as the dashboard runtime.
   // No installed packs => preserve the existing CLI tool list and avoid creating a KGS database.
   const { kgsDefaultDbPath } = require('../knowledge/kgs/sqlite-store.js') as typeof import('../knowledge/kgs/sqlite-store.js');
@@ -751,10 +786,10 @@ export function buildCliAgentTools(
   const dispatchSessionRuntimeTool = sr.dispatchSessionRuntimeTool;
   const createPlanner = sr.createSearchPlannerState;
   const plannerState = createPlanner({ maxAutoNarrowCandidates: 2 });
-  const dispatch = async (name: string, args: Record<string, unknown>): Promise<unknown> => {
+  const dispatch = async (name: string, args: Record<string, unknown>, context?: { signal?: AbortSignal }): Promise<unknown> => {
     try {
       const direct = dispatchByName.get(name);
-      if (direct) return await direct(args);
+      if (direct) return await direct(args, context?.signal);
       // ⭐ BACKLOG L1b (2026-09-25) — ToolSearch 는 지연 도구가 있으면 «자동으로 광고»되는데 이 CLI 디스패처만
       //   라우팅이 없어 `plugin tool unavailable in CLI: ToolSearch` 로 죽었다(daemon·monad-agent-turn 은 라우팅한다).
       //   ⇒ 같은 공용 라우터로 이 CLI 의 도구 풀에서 찾는다.

package/src/cli/intake-cli.ts

@@ -5,7 +5,7 @@ import type { Command } from 'commander';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { readNexusRuntime } from '../nexus/runtime.js';
 import { resolveRoleLlm } from '../user-config.js';
-import { runIntakeToTasks, type IntakeTaskInput, type IntakeTaskRequest, type IntakeToTasksResult } from '../intake-plane/intake-to-tasks.js';
+import { approveChannelPublish, runIntakeToTasks, type IntakeTaskInput, type IntakeTaskRequest, type IntakeToTasksResult } from '../intake-plane/intake-to-tasks.js';
 import { writeStdoutJson } from './stdout-json.js';
 import { writeStdoutFully } from './stdout-flush.js';
 import { runGitCommand } from '../git-fs/runner.js';
@@ -37,6 +37,8 @@ export interface IntakeCliDeps extends IntakeCandidatesCliDeps {
   root?: string;
   /** 텔레그램 «저장된 메시지» 연결 (기본 gramjsFetchSaved) — 시험은 가짜 fetch 를 넣는다. */
   connectSaved?: () => Promise<{ fetch: FetchSavedMessages; close: () => Promise<void> }>;
+  /** 수집 연결 실패를 CLI 사용자에게 보고한다. */
+  error?: (message: string) => void;
 }
 
 /** `--limit` 원 문자열 → 0 이상의 정수. 숫자만(`/^\d+$/`) 받고 나머지('' · 공백 · 음수 · 소수)는 거부한다. */
@@ -535,6 +537,24 @@ export function registerIntakeCommands(program: Command, candidateDeps: IntakeCl
       if (result.failed > 0) process.exitCode = 1;
     });
 
+  intakeCmd
+    .command('approve-channel-post <id>')
+    .description('보호 범주의 채널 게시 초안을 사람 승인한다 (외부 게시 커넥터는 호출하지 않는다)')
+    .requiredOption('--by <approver>', '승인자: MK | 대표')
+    .option('--json', '구조화 출력')
+    .action(async (id: string, opts: { by: string; json?: boolean }) => {
+      const { effectiveInstanceRoot } = await import('../instance/resolve.js');
+      const approved = approveChannelPublish(candidateDeps.root ?? effectiveInstanceRoot(), id, opts.by);
+      if (!approved) {
+        console.error(`대기 중인 보호 초안을 찾지 못했거나 승인자(${opts.by})가 MK·대표가 아니다: ${id}`);
+        process.exitCode = 1;
+        return;
+      }
+      const result = { id, status: approved.status, approvedBy: approved.approvedBy, category: approved.category };
+      if (opts.json) await writeStdoutFully(JSON.stringify(result) + '\n');
+      else console.log(`${id} → ${approved.status} · 승인자 ${approved.approvedBy} · 외부 게시 미실행`);
+    });
+
   intakeCmd
     .command('collect-telegram-saved')
     .description('텔레그램 «저장된 메시지»를 읽기만 해 흡수 원장에 넣는다 (커서 이후만 · 호스트 전용 · 개인 메모는 user-private)')
@@ -546,6 +566,7 @@ export function registerIntakeCommands(program: Command, candidateDeps: IntakeCl
         ...(candidateDeps.root ? { root: candidateDeps.root } : {}),
         ...(candidateDeps.connectSaved ? { connect: candidateDeps.connectSaved } : {}),
         ...(candidateDeps.write ? { write: candidateDeps.write } : {}),
+        ...(candidateDeps.error ? { error: candidateDeps.error } : {}),
       });
     });
 

package/src/cli/lesson-cli.ts

@@ -2,6 +2,7 @@ import type { Command } from 'commander';
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
+import { FrictionInputError, FrictionLedger, frictionActor, type FrictionRecordInput } from '../lessons/friction-ledger.js';
 import { importLessons, scanLessonDocs } from '../lessons/lesson-import.js';
 import { LessonInputError, LessonLedger, type LessonLedgerOptions, type LessonRow, type LessonDetail } from '../lessons/lesson-ledger.js';
 
@@ -47,6 +48,18 @@ function validAuthoringLessonClass(value: string): boolean {
 export function registerLessonCommands(program: Command, options: LessonLedgerOptions = {}, out: Pick<Console, 'log'> = console): void {
   const root = program.command('lesson').description('사고 · 원인 · 처방 · 재발 교훈 원장');
   const ledger = () => new LessonLedger(options);
+  // 손 걸음 원장은 그림자 기록이다: 비밀 꼴 note 는 빼고 남기며, 어떤 경우에도 lesson 명령을 실패시키지 않는다.
+  const recordFriction = (input: FrictionRecordInput): void => {
+    const friction = new FrictionLedger(options);
+    const attempts = input.note ? [input, { ...input, note: '' }] : [input];
+    for (const attempt of attempts) {
+      try { friction.record(attempt); return; }
+      catch (error) {
+        debug.log('lessons.friction', 'skipped', { kind: attempt.kind, signature: attempt.signature,
+          reason: error instanceof FrictionInputError ? error.message : String(error) });
+      }
+    }
+  };
   const emit = (value: unknown, json: boolean | undefined, text: string) => out.log(json ? JSON.stringify(value) : text);
   root.command('import').description('INCIDENT·FINDING 문서 교훈 미리 보기 (기본값); --apply 로 적재')
     .option('--apply', '원장에 적재').option('--json', 'JSON 출력').option('--by <name>', '기록자 (기본 AI_AGENT)')
@@ -128,11 +141,12 @@ export function registerLessonCommands(program: Command, options: LessonLedgerOp
         return;
       }
       const required = ['incident', 'cause', 'remedy', 'owner', 'source'] as const;
+      const lessonId = id ?? '';
       const missing: string[] = required.filter((key) => typeof o[key] !== 'string' || !(o[key] as string).trim());
-      if (!id?.trim()) missing.unshift('id');
+      if (!lessonId.trim()) missing.unshift('id');
       if (missing.length) throw new LessonInputError(`required: ${missing.map(key => key === 'id' ? 'id' : `--${key}`).join(', ')}`);
       const by = actor(typeof o.by === 'string' ? o.by : undefined);
-      const row = ledger().add({ id, incident: o.incident as string, cause: o.cause as string, remedy: o.remedy as string,
+      const row = ledger().add({ id: lessonId, incident: o.incident as string, cause: o.cause as string, remedy: o.remedy as string,
         owner: o.owner as string, source: o.source as string, by,
         ...(o.enforcedBy !== undefined ? { enforcedBy: o.enforcedBy as string } : {}),
         ...(o.disproof !== undefined ? { disproof: o.disproof as string } : {}) });
@@ -140,7 +154,9 @@ export function registerLessonCommands(program: Command, options: LessonLedgerOp
     }));
   root.command('recur <id>').requiredOption('--source <path>').option('--note <text>').option('--by <name>')
     .action(handle('recur', (id: string, o: { source: string; note?: string; by?: string }) => {
-      const row = ledger().recur(id, { source: o.source, note: o.note ?? '', by: actor(o.by) });
+      const by = actor(o.by);
+      const row = ledger().recur(id, { source: o.source, note: o.note ?? '', by });
+      recordFriction({ actor: frictionActor(by), kind: 'hand-step', signature: row.incident ?? `lesson ${row.id}`, note: o.note ?? '', ref: o.source });
       emit(row, false, format(row));
     }));
   root.command('enforce <id>').requiredOption('--enforced-by <paths>').option('--by <name>')

package/src/cli/log-event-names.ts

@@ -1362,6 +1362,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "status",
   "status-ledger",
   "status-port-resolved",
+  "status-question-interim-reprompt",
   "stdin-backpressure",
   "stdout",
   "step",

package/src/cli/pod-cli.ts

@@ -14,7 +14,7 @@ import { getUserConfig } from '../user-config.js';
 import { listCodexAccountsInStore } from '../oauth/codex-account-store.js';
 import { parsePodPool, resolvePodPoolSpec, podPoolHostLease, type PoolKubectl } from '../task-orchestrator/surfaces/pod-pool.js';
 import { leaseKubectl, measurePoolLease, probePoolDns, probePoolGitHub, recommendConcurrency, type PoolLeaseMeasure, type PoolDnsProbe, type ExternalGitHubProbe } from '../task-orchestrator/surfaces/pod-lease.js';
-import { POD_COMMAND_DEADLINE_SECONDS, runPodCommand, type PodCommandResult, type RunPodCommandOptions } from '../task-orchestrator/surfaces/pod-command-job.js';
+import { POD_COMMAND_DEADLINE_SECONDS, parseCpuRightsizeRequest, runPodCommand, type PodCommandResult, type PodCpuRightsizeRequest, type RunPodCommandOptions } from '../task-orchestrator/surfaces/pod-command-job.js';
 import { hostLeaseCounts, leaseHasPendingPod } from '../pod-lease/host-lease.js';
 
 export interface PodCliIo {
@@ -220,7 +220,8 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
     .allowUnknownOption(true)
     .allowExcessArguments(true)
     .option('--lite', '네트워크 스킬(omni-crawl·omni-digest)만 쓰는 명령 — 작은 이미지 ⊕ 2Gi 한도(POD7 · clone 불가)')
-    .action(async (opts: { pool?: string; skill?: string; llm?: string; clone?: boolean; deadline?: string; lite?: boolean }, command: Command) => {
+    .option('--cpu-rightsize <json>', 'POD-CPU-REQUEST-RIGHTSIZE-2-FU: 공존 재측정 요청(JSON 파일 경로 또는 인라인 JSON) — { condition?, samples[], priorLaunches[] }. 선행 조건·측정이 모자라면 발사하지 않는다')
+    .action(async (opts: { pool?: string; skill?: string; llm?: string; clone?: boolean; deadline?: string; lite?: boolean; cpuRightsize?: string }, command: Command) => {
       const argv = process.argv.slice(2);
       const sep = argv.indexOf('--');
       const fromArgv = sep >= 0 ? argv.slice(sep + 1) : [];
@@ -244,6 +245,19 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
           return;
         }
       }
+      // POD-CPU-REQUEST-RIGHTSIZE-2-FU — the OP-facing measurement launch reads its request from JSON (file path or inline).
+      let cpuRightsize: PodCpuRightsizeRequest | undefined;
+      if (opts.cpuRightsize !== undefined) {
+        try {
+          const source = opts.cpuRightsize.trim();
+          const text = source.startsWith('{') ? source : readFileSync(source, 'utf8');
+          cpuRightsize = parseCpuRightsizeRequest(JSON.parse(text), '--cpu-rightsize');
+        } catch (err) {
+          io.error(`pod run: --cpu-rightsize — ${err instanceof Error ? err.message : String(err)}`);
+          io.exit(2);
+          return;
+        }
+      }
       const skills = (opts.skill ?? '').split(',').map((s) => s.trim()).filter(Boolean);
       const cloneWarning = podCloneWithoutInstallWarning(commandArgs, opts.clone);
       if (cloneWarning !== null) {
@@ -268,6 +282,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
           ...(opts.llm === 'grok' ? { llm: 'grok' as const } : {}),
           ...(opts.clone ? { clone: true } : {}),
           ...(opts.lite ? { lite: true } : {}),
+          ...(cpuRightsize ? { cpuRightsize } : {}),
           ...(deadlineSeconds !== undefined ? { deadlineSeconds } : {}),
         });
         if (result.image) io.error(`[pod] image ${result.image} · job ${result.job}`);

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

@@ -5,7 +5,7 @@ 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, 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 { 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';
@@ -1467,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;
 }
@@ -1534,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, {
@@ -1549,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 };
   }
 }
 
@@ -1848,8 +1858,9 @@ function remotePtyListJsonRow(row: RemoteTerminalListItem): PtyListJsonRow {
     runTerminationSource: 'unknown',
     runStoreIo: 'not-checked',
     ownerRunUsage: 'unknown',
-    // 원격 응답은 턴·판을 안 싣는다 — «모른다»로(로컬과 같은 키).
+    // 원격 응답은 턴·판·진전을 안 싣는다 — «모른다»로(로컬과 같은 키).
     turn: UNKNOWN_TURN_CELL,
+    progress: 'unknown',
     build: null,
   };
 }
@@ -2167,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,
     })
@@ -2193,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)은 이 칸을 안 낸다 — 기계마다 다른 값이 목록에 새지 않게.
@@ -2294,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` 는 인자 없음).
@@ -2369,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-cli.ts

@@ -56,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';
@@ -609,6 +610,19 @@ function compareReleaseVersions(a: string, b: string): number {
 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
@@ -1298,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) {
@@ -1312,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 실행 없음'
@@ -1427,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 };