elanous 0.2.38 → 0.2.40

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/src/acp/core-turn-bridge.ts

@@ -369,6 +369,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 } : {}),
@@ -434,6 +436,12 @@ export function bridgeCoreTurnToAcp(
         ...(maxToolTurns !== undefined ? { maxToolTurns } : {}),
         ...((!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

package/src/agent-mission/driver.ts

@@ -31,7 +31,7 @@ import { verdictForFinalPtyScreen } from '../cli/pty-drive-verdict.js';
 import { reemitPtyUsage } from '../budget/pty-usage-reemit.js';
 import { classifyAuthError } from '../oauth/codex.js';
 import { normalizeFallbackChain, type FallbackStep } from '../oauth/fallback-chain.js';
-import { runPtyControlLoop, controlDepsForHandle, type ControlDecision, type ControlObservation, type RunSupervisor } from '../autopilot/pty-control-loop.js';
+import { runPtyControlLoop, controlDepsForHandle, VERIFY_DONE_STOP, type ControlDecision, type ControlObservation, type RunSupervisor } from '../autopilot/pty-control-loop.js';
 import { probeControlStance, stanceBlocksWrite } from '../pty-shell/pty-control-stance.js';
 import { mapControlStance, supervisionObservationFields } from '../self-implement/supervision-vocabulary.js';
 import { createLlmControlBrain, type StreamLLMFn } from '../autopilot/llm-control-brain.js';
@@ -956,6 +956,8 @@ export function createMissionVerifyDone(opts: MissionVerifyDoneOpts): (obs?: Con
 
 export interface MissionControlBrainOpts {
   readonly mission: string;
+  /** When false, the supervisor may observe and verify but must not inject unrequested follow-up text. */
+  readonly allowFollowup?: boolean;
   readonly evidenceReady: () => boolean;
   readonly search: (query: string, step?: number) => Promise<void> | void;
   /** PTY에서 실행 중인 에이전트. 미지정 시 기존 codex 기본값을 유지한다. */
@@ -1039,6 +1041,10 @@ ${opts.handoffEnabled ? ` - "handoff": 다른 담당자로 넘길 때 to(codex/c
       if (decision.action === 'handoff' && decision.to && decision.mission) return { action: 'handoff', to: decision.to, mission: decision.mission, ...(decision.carry ? { carry: decision.carry } : {}) };
       if (decision.action === 'ask-human') return { action: 'ask-human', reason: decision.reason, ...(decision.url ? { url: decision.url } : {}), ...(decision.code ? { code: decision.code } : {}) };
       if (decision.action === 'send') {
+        if (opts.allowFollowup === false) {
+          debug.log('agent-mission', 'followup-suppressed', { step: obs.step, reason: 'verbatim mission' });
+          return { action: 'wait' };
+        }
         lastCommand = decision.text || 'continue';
         return { action: 'input', text: `${lastCommand}\r` };
       }
@@ -1480,6 +1486,7 @@ export async function runAgentMission(spec: AgentMissionSpec, deps: AgentMission
   const startedAt = Date.now();
   const contextOwner = !deps.contextEventRun;
   const contextRunId = contextOwner ? ensureRunId() : undefined;
+  const resultRunId = contextRunId ?? ensureRunId();
   let contextPrNumber: number | undefined;
   const emitContext = (kind: 'task-claimed' | 'task-done', detail: string): void => {
     if (!contextOwner) return;
@@ -1604,7 +1611,13 @@ export async function runAgentMission(spec: AgentMissionSpec, deps: AgentMission
     }
   }
   return result;
-  } finally { emitContext('task-done', result?.ok ? 'completed' : 'ended'); }
+  } finally {
+    if (result?.reason === 'aborted') {
+      try { debug.log('agent-mission', 'result', { runId: resultRunId, ok: false, reason: 'aborted', rounds: result.rounds, committed: false }); }
+      catch { /* a result receipt must not mask the cancellation result */ }
+    }
+    emitContext('task-done', result?.ok ? 'completed' : 'ended');
+  }
 }
 
 async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDeps, startedAt: number, initialFiles?: ReadonlyMap<string, string>): Promise<AgentMissionResult> {
@@ -2060,6 +2073,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   const search = createMissionSearch({ worktree: wt.path, omniPath });
   const brain = createMissionControlBrain({
     mission: spec.mission,
+    allowFollowup: spec.enhance !== false,
     backend,
     stream: deps.controlStream,
     handoffEnabled: true,
@@ -2236,6 +2250,10 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       },
       verifyDone: spec.chain && spec.chain.length > 1 ? async () => ({ ok: true as const }) : async (obs) => {
         const verdict = await verifyDone(obs);
+        if (!verdict.ok && spec.enhance === false) {
+          decisionEvent({ step: 'recover', text: 'Evidence check failed; retry disabled for verbatim mission', detail: { blocked: verdict.retry, action: 'Stop without modifying the mission' } });
+          return { ...verdict, stop: VERIFY_DONE_STOP };
+        }
         if (!verdict.ok) decisionEvent({ step: 'recover', text: 'Evidence check requires another attempt', detail: { blocked: verdict.retry, action: 'Retry after fixing evidence' } });
         return verdict;
       },
@@ -2347,9 +2365,17 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     stopLive();
     throw new Error('AGENT_YIELDED: PTY 제어가 사람에게 이양됨(takeover) — 자율 미션 중단');
   }
-
   if (deps.isMissionAborted?.()) return { ok: false, reason: 'aborted', worktree: wt.path, branch: wt.branch,
     rounds: round, evidencePath: null, committed: false, usedOmniCrawl: usedOmni, detail: 'aborted' };
+
+  if (control.termination.kind === 'error' && control.termination.code === VERIFY_DONE_STOP) {
+    stopLive();
+    if (h.pid) await (deps.terminateProcessTree ?? terminateMissionProcessTree)(h.pid);
+    try { h.kill(); } catch { /* noop */ }
+    if (backend.name === 'claude') cleanupClaude();
+    return { ok: false, worktree: wt.path, branch: wt.branch,
+      rounds: round, evidencePath: null, evidenceSatisfied: false, committed: false, usedOmniCrawl: usedOmni, detail: control.termination.message };
+  }
   const finalEv = verifyEvidence(wt.path, spec.evidence);
   const finalScreen = await h.renderScreen();
   const driveVerdict = verdictForFinalPtyScreen({ screen: finalScreen, inputHistory: submittedInputs, exitCode: h.exitCode ?? null, artifactEvidence: finalEv.ok });

package/src/agent-mission/mission-cli.ts

@@ -33,6 +33,7 @@ export interface MissionCliOpts {
 
 export interface MissionCliDeps {
   resolveBackend: (name?: string) => AgentBackend;
+  signal?: AbortSignal;
   readFile?: (path: string) => string;
   runDevPipeline?: typeof runDevPipeline;
 }
@@ -115,7 +116,7 @@ export async function runAgentMissionCliCommand(
   });
   const { result, exitCode } = await executeAgentMissionReroute(
     spec, agentBackend,
-    deps.runDevPipeline ? { runDevPipeline: deps.runDevPipeline } : undefined,
+    { ...(deps.runDevPipeline ? { runDevPipeline: deps.runDevPipeline } : {}), ...(deps.signal ? { signal: deps.signal } : {}) },
   );
   return { ok: true, result, exitCode };
 }