elanous 0.2.38 → 0.2.41

package/scripts/tui-regress.ts

@@ -4,20 +4,37 @@
 //
 // ⛔ Not under `bun test`: a real PTY of the real TUI is outside the test gate (NODE_ENV=test turns the PTY
 // manifest off, and the run takes ~1 minute). Each check gets a fresh temp config/state dir and its own PTY;
-// both are removed when the check ends, so the run leaves no process or folder behind.
+// the temporary config/state directory is removed when the check ends. Failed checks preserve their screens and
+// effective config under TUI_REGRESS_ARTIFACTS (or the default temp artifact root) for diagnosis.
 import { spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { startPty } from '../src/pty-shell/registry.js';
-import { ERASE, TUI_REGRESS_CHECKS, type TuiCheck, type Verdict } from './lib/tui-regress-checks.js';
+import { ERASE, inputRow, TUI_REGRESS_CHECKS, type TuiCheck, type Verdict } from './lib/tui-regress-checks.js';
+import { preserveTuiRegressFailure } from './lib/tui-regress-evidence.js';
+import { debug } from '../src/debug/log.js';
+import { registerStandaloneLogSink } from '../src/domains/standalone-log-sink.js';
 
 const COLS = 160;
 const ROWS = 50;
-const BOOT_MS = 9_000;
+const BOOT_TIMEOUT_MS = 60_000;
+const BOOT_POLL_MS = 200;
+const RUN_EVENT = 'tui-regress.completed';
 const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+type TuiRegressResult = Verdict & { bootMs: number };
 
-async function runCheck(check: TuiCheck): Promise<Verdict> {
+async function waitForInputPrompt(handle: ReturnType<typeof startPty>): Promise<number> {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < BOOT_TIMEOUT_MS) {
+    if (inputRow(await handle.renderScreen())) return Date.now() - startedAt;
+    await sleep(BOOT_POLL_MS);
+  }
+  throw new Error(`TUI 입력 프롬프트 준비 시간 초과 (${BOOT_TIMEOUT_MS}ms)`);
+}
+
+async function runCheck(check: TuiCheck, runId: string, verificationCommand: string): Promise<TuiRegressResult> {
   const dir = mkdtempSync(join(tmpdir(), `tui-regress-${check.id}-`));
   const cli = join(import.meta.dir, '..', 'bin', 'elanous.mjs');
   if (check.role && check.role !== 'owner') {
@@ -32,8 +49,13 @@ async function runCheck(check: TuiCheck): Promise<Verdict> {
     env: { ...process.env, ELANOUS_DRIVE_TUI: '1', ELANOUS_STATE_DIR: dir },
   });
   const snaps: Record<string, string> = {};
+  let bootMs = 0;
+  let bootStartedAt = Date.now();
+  let bootComplete = false;
   try {
-    await sleep(BOOT_MS);
+    bootStartedAt = Date.now();
+    bootMs = await waitForInputPrompt(handle);
+    bootComplete = true;
     for (const step of check.steps) {
       if (step.kind === 'type') handle.write(step.text);
       else if (step.kind === 'key') handle.write(step.data);
@@ -43,9 +65,52 @@ async function runCheck(check: TuiCheck): Promise<Verdict> {
     }
     // TUI_REGRESS_DUMP=<id> prints that check's screens (to see why a verdict failed).
     if (!json && process.env.TUI_REGRESS_DUMP === check.id) for (const [k, v] of Object.entries(snaps)) console.log(`--- ${check.id}:${k}\n${v.split('\n').filter((l) => l.trim()).join('\n')}`);
-    return check.judge(snaps);
+    const verdict = check.judge(snaps);
+    if (!verdict.ok) {
+      const artifactDir = preserveTuiRegressFailure({
+        runId,
+        event: RUN_EVENT,
+        verificationCommand,
+        artifactRoot: process.env.TUI_REGRESS_ARTIFACTS || join(tmpdir(), 'elanous-tui-regress-failures'),
+        configDir: dir,
+        check: { id: check.id, title: check.title, role: check.role ?? 'owner' },
+        screens: snaps,
+        pty: { cols: COLS, rows: ROWS, bootMs },
+        environment: {
+          driveTui: '1',
+          nodeEnv: process.env.NODE_ENV ?? null,
+          credentialVariablesPresent: Object.keys(process.env).filter((key) => /API.?KEY|TOKEN|SECRET|CREDENTIAL/i.test(key)),
+        },
+        verdict,
+      });
+      return { ...verdict, bootMs, reason: `${verdict.reason} · 증거 보존: ${artifactDir}` };
+    }
+    return { ...verdict, bootMs };
   } catch (error) {
-    return { ok: false, reason: `실행 오류: ${String(error).slice(0, 120)}` };
+    if (!bootComplete) bootMs = Date.now() - bootStartedAt;
+    const verdict: Verdict = { ok: false, reason: `실행 오류: ${String(error).slice(0, 120)}` };
+    try { snaps.failure = await handle.renderScreen(); } catch { /* PTY may already be gone */ }
+    try {
+      const artifactDir = preserveTuiRegressFailure({
+        runId,
+        event: RUN_EVENT,
+        verificationCommand,
+        artifactRoot: process.env.TUI_REGRESS_ARTIFACTS || join(tmpdir(), 'elanous-tui-regress-failures'),
+        configDir: dir,
+        check: { id: check.id, title: check.title, role: check.role ?? 'owner' },
+        screens: snaps,
+        pty: { cols: COLS, rows: ROWS, bootMs },
+        environment: {
+          driveTui: '1',
+          nodeEnv: process.env.NODE_ENV ?? null,
+          credentialVariablesPresent: Object.keys(process.env).filter((key) => /API.?KEY|TOKEN|SECRET|CREDENTIAL/i.test(key)),
+        },
+        verdict,
+      });
+      return { ...verdict, bootMs, reason: `${verdict.reason} · 증거 보존: ${artifactDir}` };
+    } catch (preserveError) {
+      return { ...verdict, bootMs, reason: `${verdict.reason} · 증거 보존 실패: ${String(preserveError).slice(0, 120)}` };
+    }
   } finally {
     try { handle.kill('SIGKILL'); } catch { /* already gone */ }
     rmSync(dir, { recursive: true, force: true });
@@ -58,14 +123,24 @@ const only = onlyArg >= 0 ? new Set((args[onlyArg + 1] ?? '').split(',').map((s)
 const json = args.includes('--json');
 const checks = TUI_REGRESS_CHECKS.filter((check) => !only || only.has(check.id));
 if (checks.length === 0) { console.error('tui-regress: 고른 칸이 없다 (--only 확인)'); process.exit(2); }
+const runId = `run-${randomUUID()}`;
+const verificationCommand = `bun scripts/tui-regress.ts${only ? ` --only ${[...only].join(',')}` : ''} --json`;
+await registerStandaloneLogSink('tui-regress');
 
-const results: { id: string; title: string; ok: boolean; reason: string }[] = [];
+const results: { id: string; title: string; ok: boolean; reason: string; bootMs: number }[] = [];
 for (const check of checks) {
-  const verdict = await runCheck(check);
+  const verdict = await runCheck(check, runId, verificationCommand);
   results.push({ id: check.id, title: check.title, ...verdict });
   if (!json) console.log(`${check.id} ${verdict.ok ? '✅' : '❌'} ${check.title} — ${verdict.reason}`);
 }
 const fail = results.filter((r) => !r.ok).length;
-if (json) console.log(JSON.stringify({ results, pass: results.length - fail, fail }));
+debug.log('tui-regress', RUN_EVENT, {
+  runId,
+  verificationCommand,
+  outcome: fail === 0 ? 'pass' : 'fail',
+  results: results.map(({ id, ok, bootMs }) => ({ id, ok, bootMs })),
+});
+debug.flush();
+if (json) console.log(JSON.stringify({ runId, event: RUN_EVENT, verificationCommand, results, pass: results.length - fail, fail }));
 else console.log(`tui-regress: pass ${results.length - fail} · fail ${fail}`);
 process.exit(fail ? 1 : 0);

package/scripts/ux-sim.ts

@@ -15,6 +15,7 @@
 //   bun scripts/ux-sim.ts --list-trajectories # 저장한 궤적과 출처 목록
 //   bun scripts/ux-sim.ts --fault cred-expiry # 결함 주입: grok 구독 만료 임박 × 갱신 결과 → 디스패처·발사 판정
 //   bun scripts/ux-sim.ts --fault pod-death   # 결함 주입: PARTIAL 줄을 남긴 Pod 가 SIGTERM 으로 지워짐 → 호스트 재방출 판정
+//   bun scripts/ux-sim.ts --fault pod-child-result # 결함 주입: Completed Pod 안의 report-deficit child 결과 보존
 //   bun scripts/ux-sim.ts --fault pool-cap    # 결함 주입: --pod-pool 에 :N 이 빠진 풀 → 승인 판정(limitedBy)
 //   bun scripts/ux-sim.ts --fault sqlite-busy # 결함 주입: 실제 SQLite 잠금 → 로그 배치 버퍼·복구
 //   bun scripts/ux-sim.ts emit child-error-long --json # 사건 주입(L0): 격리 우주 원장에 주입 줄 → 소비자 목록
@@ -128,7 +129,7 @@ if (argv[0] === 'seat-seq') {
 //     ***영영 모른다*** — 오늘 이 저장소가 같은 함정을 다른 도구에서 이미 한 번 고쳤다.
 //  ⛔ 그래서 「알려진 플래그」를 «한 곳»에 두고, 그 밖의 `--` 인자는 거부한다.
 const KNOWN_FLAGS = new Set([
-  '--list', '--list-trajectories', '--computer-use', '--trajectory', '--from-run',
+  '--list', '--list-trajectories', '--computer-use', '--trajectory', '--from-run', '--seminar-rehearsal',
   '--save-trajectory', '--esc', '--queue', '--width', '--height', '--draft', '--fault',
 ]);
 {
@@ -142,6 +143,17 @@ const KNOWN_FLAGS = new Set([
 }
 if (argv.includes('--list')) { console.log([...PHASES, 'computer-use: normal | capture-stalls | capture-fails | target-missing'].join('\n')); process.exit(0); }
 
+if (argv.includes('--seminar-rehearsal')) {
+  if (argv.length !== 1) {
+    console.error('⛔ --seminar-rehearsal 는 단독 모드다');
+    process.exit(2);
+  }
+  const { renderSeminarRehearsal, seminarRehearsalSweep } = await import('../src/ux-sim/seminar-rehearsal.js');
+  const result = seminarRehearsalSweep();
+  console.log(renderSeminarRehearsal(result).join('\n'));
+  process.exit(result.verdict === 'pass' ? 0 : 1);
+}
+
 {
   // `--fault=<이름>` 꼴도 받는다 — KNOWN_FLAGS 는 등호 꼴을 통과시키므로 여기서 놓치면 조용히 기본 국면으로 빠진다.
   const eq = argv.find((a) => a.startsWith('--fault='));
@@ -159,6 +171,11 @@ if (argv.includes('--fault')) {
     console.log(renderPodDeath(simPodDeath()).join('\n'));
     process.exit(0);
   }
+  if (fault === 'pod-child-result') {
+    const { podChildResultScenario, renderPodChildResult } = await import('../src/ux-sim/fault-pod-child-result.js');
+    console.log(renderPodChildResult(podChildResultScenario()).join('\n'));
+    process.exit(0);
+  }
   if (fault === 'pool-cap') {
     const { poolCapSweep, renderPoolCap } = await import('../src/ux-sim/fault-pool-cap.js');
     console.log(renderPoolCap(poolCapSweep()).join('\n'));
@@ -169,7 +186,7 @@ if (argv.includes('--fault')) {
     console.log(renderSqliteBusy(simSqliteBusy()).join('\n'));
     process.exit(0);
   }
-  console.error(`⛔ 모르는 결함이다: ${fault ?? '(없음)'} — 아는 것: cred-expiry · pod-death · pool-cap · sqlite-busy`);
+  console.error(`⛔ 모르는 결함이다: ${fault ?? '(없음)'} — 아는 것: cred-expiry · pod-death · pod-child-result · pool-cap · sqlite-busy`);
   process.exit(2);
 }
 

package/src/acp/core-turn-bridge.ts

@@ -57,6 +57,13 @@ import { resolveSessionSurfaceProfile } from '../session-runtime/index.js';
 import { classifyTuiChatIntent, formatTuiRouteLine, isSeatOpsDirective, type TuiChatRoute } from '../core-turn/short-question.js';
 import { HARNESS_ROLE_ENV } from '../harness/harness-space.js';
 import { createReasoningThoughtBuffer } from './reasoning-thought-buffer.js';
+import {
+  REQUEST_SIZE_MAX_CHARS,
+  createRequestSizeGuard,
+  estimateRequestChars,
+  formatRequestSizeStatus,
+  type RequestSizeGuard,
+} from '../session/request-size-guard.js';
 
 const FACT_QUESTION_INSTRUCTION = '사실·최신 정보 질문이다. WebSearch 를 1~2회 쓰고 검색 결과(제목·스니펫·URL)로 답하라. 출처 링크를 붙여라. 셸·브라우저·파일 도구는 검색 결과로 부족할 때만. 도구 예산에 닿으면 지금까지 근거로 답하고 끝에 «더 찾아볼까요?»를 붙여라.';
 
@@ -143,6 +150,18 @@ export interface CoreTurnBridgeDeps {
   /** TUI-H1-SEAT-GOALLOOP — the seat this TUI works for (`detectSeatTui`), read per turn. null/absent = a human
    *  conversation TUI (routing unchanged). A seat TUI sends operational directives to the goal loop. */
   resolveSeat?: () => string | null;
+  /** TUI-TOKEN-GUARD-WIRE — host write-back for the #32254 request-size cap.
+   *  Compacts the host's own history store (the one `getMessages` reads) in place
+   *  so the next prompt does not reload the original. The bridge re-reads
+   *  `getMessages` after `fired:true`. Only consulted on `tuiRouting` turns. */
+  compactPersistedHistory?: (ctx: {
+    sessionId: string;
+    userText: string;
+    requestChars: number;
+    maxChars: number;
+  }) => Promise<{ fired: boolean; reason: string }>;
+  /** Override the request-size cap (tests). Defaults to `REQUEST_SIZE_MAX_CHARS`. */
+  requestSizeMaxChars?: number;
 }
 
 /** Default abort-poll cadence. 50ms = 20 Hz: responsive without
@@ -224,7 +243,7 @@ export function bridgeCoreTurnToAcp(
     (poll as unknown as { unref?: () => void }).unref?.();
 
     try {
-      const messages = await Promise.resolve(
+      let messages = await Promise.resolve(
         deps.getMessages({
           sessionId: turnCtx.sessionId,
           userText: turnCtx.userText,
@@ -318,9 +337,71 @@ export function bridgeCoreTurnToAcp(
       }
       const explicitMaxToolTurns = deps.resolveMaxToolTurns?.({ sessionId: turnCtx.sessionId });
       const maxToolTurns = explicitMaxToolTurns ?? (factQuestion ? getUserConfig().chat.factQuestion.maxToolTurns : undefined);
-      const turnMessages: LLMMessage[] = factQuestion
-        ? [{ role: 'system', content: FACT_QUESTION_INSTRUCTION }, ...messages]
-        : messages;
+      const withFactInstruction = (seed: LLMMessage[]): LLMMessage[] => factQuestion
+        ? [{ role: 'system', content: FACT_QUESTION_INSTRUCTION }, ...seed]
+        : seed;
+      let turnMessages: LLMMessage[] = withFactInstruction(messages);
+      // TUI-TOKEN-GUARD-WIRE — exact serialized provider measurement owns
+      // first-request compaction; the seed estimate is telemetry only. This
+      // keeps turn-0 history untouched until compactFirstRequest writes back.
+      let requestSizeGuard: RequestSizeGuard | undefined;
+      if (deps.tuiRouting === true) {
+        const maxChars = deps.requestSizeMaxChars ?? REQUEST_SIZE_MAX_CHARS;
+        let historyCompacted = false;
+        const compactHistory = async (requestChars: number, stage: 'first-request') => {
+          if (!deps.compactPersistedHistory || historyCompacted) return false;
+          let fired = false;
+          let reason = 'no-op';
+          try {
+            const result = await deps.compactPersistedHistory({
+              sessionId: turnCtx.sessionId, userText: turnCtx.userText, requestChars, maxChars,
+            });
+            fired = result.fired;
+            reason = result.reason;
+            historyCompacted = fired;
+          } catch (error) {
+            reason = 'compaction-error';
+            debug.log('llm.request', 'request-size-compact-error', {
+              stage, requestChars, maxChars, message: error instanceof Error ? error.message : String(error),
+            }, { level: 'warn' });
+          }
+          return { fired, reason };
+        };
+        const estimatedSeedChars = estimateRequestChars(turnMessages, tools);
+        debug.log('llm.request', 'request-size-compact', {
+          stage: 'estimate', sessionId: turnCtx.sessionId,
+          beforeChars: estimatedSeedChars, maxChars,
+          compacted: false, reason: 'awaiting-exact-wire-measurement',
+        });
+        requestSizeGuard = createRequestSizeGuard({
+          maxChars,
+          compactOptions: () => {
+            const guardModel = modelOverride ?? getUserConfig().llm?.model;
+            const guardConfig = getUserConfig().chat;
+            const preserveLastN = guardConfig?.autoCompact?.preserveLastN;
+            const archiveEnabled = guardConfig?.compact?.archiveEnabled;
+            return {
+              sessionId: turnCtx.sessionId,
+              ...(guardModel ? { activeModelId: guardModel } : {}),
+              ...(preserveLastN !== undefined ? { preserveLastN } : {}),
+              ...(archiveEnabled !== undefined ? { archiveEnabled } : {}),
+            };
+          },
+          // The preflight estimate missed (wire over cap, seed under): still write the
+          // compaction back so the next prompt starts small, then compact this request live.
+          compactFirstRequest: async (_current, info) => {
+            await compactHistory(info.requestChars, 'first-request');
+            return null;
+          },
+          onMeasured: (measurement) => {
+            if (!measurement.compacted) return;
+            void turnCtx.pushSessionUpdate(
+              { sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: formatRequestSizeStatus(measurement) } },
+              { status: true },
+            );
+          },
+        });
+      }
       let toolCallCount = 0;
       const toolKinds = new Set<string>();
       const observeToolBudget = () => {
@@ -369,6 +450,8 @@ export function bridgeCoreTurnToAcp(
       const runTurnDispatch = (c: CoreTurnContext): Promise<unknown> =>
         armGoalLoop
           ? runGoalLoop(c, {
+              // ACP owns an interactive provider loop: keep its post-completion response contract.
+              terminalCompletionShortcut: false,
               ...(goalLoopCfg?.maxIterations !== undefined ? { maxIterations: goalLoopCfg.maxIterations } : {}),
               // #29 처방 — 자리 판정으로 goal loop 에 «되돌아온» 턴만 빈 evidence 완료를 답으로 받는다.
               ...(route.reason.startsWith('seat-') ? { lenientCompletionEvidence: true } : {}),
@@ -432,8 +515,15 @@ export function bridgeCoreTurnToAcp(
         ...(modelOverride !== undefined ? { modelOverride } : {}),
         ...(autohealProvider ?? {}),
         ...(maxToolTurns !== undefined ? { maxToolTurns } : {}),
+        ...(requestSizeGuard ? { requestSizeGuard } : {}),
         ...((!factQuestion || explicitMaxToolTurns !== undefined) && deps.budgetGrant !== undefined ? { budgetGrant: deps.budgetGrant } : {}),
         callbacks: {
+          onStatus: (line) => {
+            void turnCtx.pushSessionUpdate(
+              { sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: line } },
+              { status: true },
+            );
+          },
           onGoalInterim: (text) => {
             void turnCtx.pushSessionUpdate(
               { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: '' } },

package/src/agent/autonomous-tools.ts

@@ -13,7 +13,7 @@
 // 콜백으로 위임(tgChat/dcChannel 정체성은 서피스가 소유).
 
 import { buildDelegateAgentTool, dispatchDelegateAgent } from '../boot/daemon-tools/delegate-agent.js';
-import { buildSelfImplementDaemonSpec, dispatchSelfImplement } from '../boot/daemon-tools/self-implement.js';
+import { buildSelfImplementDaemonSpec, dispatchSelfImplement, dispatchSelfImplementManaged } from '../boot/daemon-tools/self-implement.js';
 // ⛔ 잎 모듈에서 받는다 — 순환 import TDZ 를 «구조적으로» 없앤 자리(`self-implement-names.ts` 머리말).
 import { SELF_IMPLEMENT_TOOL_NAMES } from '../boot/daemon-tools/self-implement-names.js';
 import { dispatchRelayShellPrompt } from '../skills/tools/relay-shell.js';
@@ -80,6 +80,9 @@ export function buildAutonomousToolSpecs(): LLMToolSpec[] {
 export interface AutonomousToolTurnCtx {
   cwd: string;
   signal: AbortSignal;
+  /** Core-turn identity used to make a managed SelfImplement admission retry-safe. */
+  sessionId?: string;
+  toolCallId?: string;
   surfaceHitlChannels?: ConfirmChannel[];
   surfaceQuestionChannels?: QuestionChannel[];
   surfaceFileSink?: FileSink;
@@ -139,18 +142,22 @@ export async function dispatchAutonomousTool(
     const hctx = {
       cwd: ctx.cwd,
       signal: ctx.signal,
+      ...(ctx.sessionId ? { sessionId: ctx.sessionId } : {}),
+      ...(ctx.toolCallId ? { toolCallId: ctx.toolCallId } : {}),
       ...(ctx.userText ? { userText: ctx.userText } : {}),
       ...(surfaceChannels ? { surfaceHitlChannels: surfaceChannels } : {}),
       ...(surfaceQuestionChannels ? { surfaceQuestionChannels } : {}),
       ...(surfaceFileSink ? { surfaceFileSink } : {}),
       ...(ctx.emitFeedback ? { emitFeedback: ctx.emitFeedback } : {}), // start-ack/진행 push
     };
-    const dispatch = ctx.selfImplementDispatch ?? dispatchSelfImplement;
+    const dispatch = ctx.selfImplementDispatch;
     return wrapAutonomousTool(
       {
         toolNames: SELF_IMPLEMENT_TOOL_NAMES as readonly string[],
         label: 'SelfImplement',
-        run: () => dispatch(args, hctx as Parameters<typeof dispatchSelfImplement>[1]),
+        run: () => dispatch
+          ? dispatch(args, hctx as Parameters<typeof dispatchSelfImplement>[1])
+          : dispatchSelfImplementManaged(args, hctx as Parameters<typeof dispatchSelfImplementManaged>[1]),
       },
       args,
       hctx,

package/src/agent/monad-agent-turn.ts

@@ -18,6 +18,7 @@ import { existsSync } from 'node:fs';
 import type { UserConfig } from '../user-config.js';
 import { runTurn, type RunTurnOpts } from '../session/chat.js';
 import type { SessionSource } from '../session/index.js';
+import type { CoreTurnDispatchTool } from '../core-turn/index.js';
 import { buildContinuationAgentTools } from '../dispatch/continuation-turn-runner.js';
 import { buildTerminalCapableTurn } from './terminal-surface.js';
 // ★ turn 조립기 통일 Phase 1(2026-07-22) — 자율tool 5종(delegate·SelfImplement·RelayShell·RunDevHarness·
@@ -202,7 +203,7 @@ export function makeElanousAgentRunTurn(cfg: UserConfig, surface: SessionSource,
     // Track whether the turn handed off to an ACP delegate — the footer then
     // reads acp-<backend> instead of self·<model>.
     let delegatedBackend: string | undefined;
-    const dispatch = async (name: string, args: Record<string, unknown>): Promise<unknown> => {
+    const dispatch: CoreTurnDispatchTool = async (name, args, dispatchCtx) => {
       // ⭐ 소환기(F2 · 2026-07-26) — 이 서피스도 SelfImplement/RunDevHarness/
       //   SolveMission 을 defer 하므로 tier-flip 이 ToolSearch 를 주입한다.
       //   라우팅이 없으면 모델이 소환을 시도하는 순간 "unknown tool" 이다.
@@ -217,6 +218,8 @@ export function makeElanousAgentRunTurn(cfg: UserConfig, surface: SessionSource,
           // Forward the turn's abort signal (from a /cancel-aware controller) so
           // an in-flight delegation can be cancelled; inert signal otherwise.
           signal: opts.signal ?? new AbortController().signal,
+          ...(dispatchCtx?.sessionId ? { sessionId: dispatchCtx.sessionId } : {}),
+          ...(dispatchCtx?.callId ? { toolCallId: dispatchCtx.callId } : {}),
           ...(surfaceChannels ? { surfaceHitlChannels: surfaceChannels } : {}),
           ...(surfaceQuestionChannels ? { surfaceQuestionChannels } : {}),
           ...(surfaceFileSink ? { surfaceFileSink } : {}),

package/src/agent/registry.ts

@@ -159,9 +159,9 @@ export class AgentRegistry {
    *  wants to register the task with the registry before deciding
    *  whether to run it (e.g., confirmation gate). Always depth=0 —
    *  manual register has no parent context. */
-  register(definition: AgentDefinition, prompt: string): AgentTask {
+  register(definition: AgentDefinition, prompt: string, opts: { id?: string } = {}): AgentTask {
     const task: AgentTask = {
-      id: randomUUID(),
+      id: opts.id ?? randomUUID(),
       definition,
       prompt,
       depth: 0,
@@ -176,6 +176,30 @@ export class AgentRegistry {
     return task;
   }
 
+  /** Run a registered non-LLM job under the same observable/cancellable task lifecycle. */
+  async runManaged<T>(id: string, runner: (signal: AbortSignal) => Promise<T>, renderResult: (value: T) => string = String): Promise<T> {
+    const task = this.tasks.get(id);
+    if (!task) throw new Error(`agent task not found: ${id}`);
+    if (task.state !== 'pending') throw new Error(`agent task is not pending: ${id} (${task.state})`);
+    task.state = 'running';
+    task.startedAt = Date.now();
+    try {
+      const value = await runner(task.controller.signal);
+      task.state = task.controller.signal.aborted ? 'aborted' : 'done';
+      task.result = renderResult(value);
+      return value;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (task.controller.signal.aborted) task.state = 'aborted';
+      else { task.state = 'error'; task.error = message; }
+      task.result = message;
+      throw error;
+    } finally {
+      task.finishedAt = Date.now();
+      this.notifyTaskDone(task);
+    }
+  }
+
   get(id: string): AgentTask | undefined {
     return this.tasks.get(id);
   }

package/src/agent/shared-app-tools.ts

@@ -39,7 +39,7 @@ export function buildSharedAppTools(cfg?: UserConfig): SharedAppTools {
   // context(B5) — 기억 조회 같은 긴 코어 도구가 진행 한 줄(emitFeedback)을 낼 수 있게 코어까지 넘긴다.
   const dispatch = async (name: string, args: Record<string, unknown>, context?: ToolRuntimeContext): Promise<unknown> =>
     name === skillsList.name ? dispatchElanousSkillsList(args as ElanousSkillsListArgs) :
-      name === skill.id ? skill.run(args as unknown as SkillExecArgs, { surface: 'skill' }) :
+      name === skill.id ? skill.run(args as unknown as SkillExecArgs, { surface: context?.surface ?? 'skill', signal: context?.signal }) :
         fin && fin.names.has(name) ? fin.dispatch(name, args) : core.dispatch(name, args, undefined, context);
   return { specs, names, dispatch };
 }

package/src/agent/surface-ux/build.ts

@@ -75,7 +75,7 @@ function buildSurfaceUx(src: SurfaceUxSource): SurfaceUx {
       debug.log('surface-ux.confirm', 'answered', { surface, channel: res.channel, answer: res.answer });
       return res.answer === true;
     },
-    async question(req) {
+    async question(req, opts) {
       if (!questionChannels || questionChannels.length === 0) {
         debug.log('surface-ux.confirm', 'question', {
           surface,
@@ -83,8 +83,17 @@ function buildSurfaceUx(src: SurfaceUxSource): SurfaceUx {
         });
         return null;
       }
-      const res = await requestQuestion({ request: req, channels: questionChannels });
-      if (res.channel === 'all-failed' || res.channel === 'timeout') {
+      const res = await requestQuestion({ request: req, channels: questionChannels, ...(opts?.timeoutMs === undefined ? {} : { timeoutMs: opts.timeoutMs }) });
+      if (res.channel === 'timeout') {
+        debug.log('surface-ux.confirm', 'question', {
+          surface,
+          mode: 'timeout',
+          elapsedMs: res.elapsedMs,
+          timeoutMs: opts?.timeoutMs,
+        });
+        return null;
+      }
+      if (res.channel === 'all-failed') {
         debug.log('surface-ux.confirm', 'question', {
           surface,
           mode: QUESTION_OBSERVATION_MODE.unanswered,

package/src/agent/surface-ux/types.ts

@@ -54,7 +54,7 @@ export interface SurfaceUx {
   /** HITL 승인(버튼). 채널 없으면 **fail-closed → false**(자동승인 금지·제1원칙). */
   confirm(req: ConfirmRequest): Promise<boolean>;
   /** 구조화 질문(N옵션). 채널 없으면 null(호출자가 default-and-note). */
-  question(req: AskUserQuestionRequest): Promise<AskUserQuestionResult | null>;
+  question(req: AskUserQuestionRequest, opts?: { timeoutMs?: number }): Promise<AskUserQuestionResult | null>;
   /** 큰 출력 파일 첨부(fire-and-forget · 실패 삼킴). sink 없으면 no-op. */
   spillFile(f: SurfaceSpillFile): void;
   /** 진행 상태 push(비동기·best-effort). emitFeedback 없으면 no-op. */

package/src/agent/task-notification.ts

@@ -28,11 +28,12 @@ import {
   type AgentRegistry,
 } from './registry.js';
 import type { AgentTask } from './types.js';
+import type { RunStopRecord } from '../self-implement/run-stop.js';
 import { globalAgentFlash } from '../display/agent-flash.js';
 import { debug } from '../debug/log.js';
-import { DATA_DIR } from '../config.js';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 
 /** Max chars of the child's final result we echo in the notification.
@@ -65,10 +66,15 @@ export interface PendingTaskNotification {
 }
 
 export class TaskNotificationQueue {
+  private readonly persistencePath: string;
   constructor(
-    private readonly resultDir = join(DATA_DIR, 'agent-results'),
+    private readonly resultDir = join(effectiveInstanceRoot(), 'data', 'agent-results'),
     private readonly maxResultChars = 10_000_000,
-  ) {}
+    persistencePath?: string,
+  ) {
+    this.persistencePath = persistencePath ?? '';
+    if (this.persistencePath) this.restore();
+  }
 
   private queue: PendingTaskNotification[] = [];
   /** De-dup guard — same task.finishedAt can fire twice if a caller
@@ -96,6 +102,13 @@ export class TaskNotificationQueue {
     return () => { this.wakeListeners.delete(listener); };
   }
 
+  /** Replay restored pending receipts to one newly installed wake consumer. */
+  replayPendingWakes(listener: (n: PendingTaskNotification) => void): void {
+    for (const pending of this.queue) {
+      try { listener(pending); } catch { /* replay listener isolation */ }
+    }
+  }
+
   enqueue(n: PendingTaskNotification): void {
     if (this.seen.has(n.taskId)) return;
     let pending = n;
@@ -119,6 +132,7 @@ export class TaskNotificationQueue {
     }
     this.seen.add(n.taskId);
     this.queue.push(pending);
+    this.persist();
     debug.log('agent.task-notification', 'wake', { taskId: n.taskId, size: this.queue.length });
     for (const listener of this.wakeListeners) {
       try {
@@ -141,6 +155,7 @@ export class TaskNotificationQueue {
   drain(): PendingTaskNotification[] {
     const out = this.queue;
     this.queue = [];
+    this.persist();
     // NOTE: we keep `seen` populated so a listener firing a second
     // time for the same task (rare but possible under races) still
     // can't double-inject. `seen` grows unbounded across a session;
@@ -172,10 +187,64 @@ export class TaskNotificationQueue {
   clear(): void {
     this.queue = [];
     this.seen.clear();
+    this.persist();
   }
+
+  private restore(): void {
+    try {
+      const value: unknown = JSON.parse(readFileSync(this.persistencePath, 'utf8'));
+      if (!value || typeof value !== 'object') throw new Error('invalid task notification snapshot');
+      const snapshot = value as { version?: number; queue?: PendingTaskNotification[]; seen?: string[] };
+      if (snapshot.version !== 1 || !Array.isArray(snapshot.queue) || !Array.isArray(snapshot.seen)) throw new Error('invalid task notification snapshot');
+      this.queue = snapshot.queue;
+      this.seen = new Set(snapshot.seen);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return;
+      debug.log('agent.task-notification', 'restore-failed', { path: this.persistencePath, reason: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+    }
+  }
+
+  private persist(): void {
+    if (!this.persistencePath) return;
+    try {
+      mkdirSync(dirname(this.persistencePath), { recursive: true });
+      const temp = `${this.persistencePath}.${randomUUID()}.tmp`;
+      writeFileSync(temp, `${JSON.stringify({ version: 1, queue: this.queue, seen: [...this.seen] })}\n`, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+      renameSync(temp, this.persistencePath);
+    } catch (error) {
+      debug.log('agent.task-notification', 'persist-failed', { path: this.persistencePath, reason: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+    }
+  }
+}
+
+export function resolveTaskNotificationPaths(instanceRoot = effectiveInstanceRoot()): { resultDir: string; persistencePath: string } {
+  const dataDir = process.env.ELANOUS_DATA_DIR?.trim() || join(instanceRoot, 'data');
+  return { resultDir: join(dataDir, 'agent-results'), persistencePath: join(dataDir, 'agent-task-notifications.json') };
 }
 
-export const globalTaskNotificationQueue = new TaskNotificationQueue();
+const taskNotificationPaths = resolveTaskNotificationPaths();
+export const globalTaskNotificationQueue = new TaskNotificationQueue(
+  taskNotificationPaths.resultDir, 10_000_000, taskNotificationPaths.persistencePath,
+);
+
+/** Wake a parent as soon as a SelfImplement run records its terminal stop, even if post-stop cleanup stalls. */
+export function enqueueSelfImplementRunStopNotification(
+  input: { runId: string; taskId: string; feature: string; stop: RunStopRecord },
+  queue: TaskNotificationQueue = globalTaskNotificationQueue,
+): void {
+  const { runId, taskId, feature, stop } = input;
+  queue.enqueue({
+    taskId: `self-implement-stop:${runId}:${taskId}`,
+    agentName: 'SelfImplement',
+    label: feature.slice(0, 80),
+    state: 'error',
+    output: `SelfImplement run ${runId} stopped (${stop.class}${stop.site ? ` at ${stop.site}` : ''}): ${stop.cause} · next: ${stop.nextMove}`,
+    truncated: false,
+    errorMessage: stop.cause,
+    durationMs: 0,
+    finishedAt: Date.now(),
+  });
+}
 
 // ── Auto-wire background task completion ─────────────────────────────
 //

package/src/agent/types.ts

@@ -72,6 +72,9 @@ export interface AgentDefinition {
  *  other than by going through registry methods. */
 export interface AgentTask {
   id: string;
+  /** Optional identity links for managed non-LLM jobs hosted by the registry. */
+  runId?: string;
+  parentSessionId?: string;
   definition: AgentDefinition;
   /** Caller-supplied short label for this specific spawn — distinct
    *  from `definition.description` which is the boilerplate stamp