@nowcrew/daemon 0.5.19 → 0.5.20

package/dist/execution-runner.js

@@ -1,17 +1,19 @@
 import { createHash } from "node:crypto";
 import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { DaemonToServerExecutionFrameSchema, ExecutionCompletedSchema, ExecutionRejectedSchema, ExecutionStartSchema, } from "./execution-protocol.js";
 import { JournalConflictError } from "./execution-journal.js";
 import { boundExecutionFrame } from "./execution-event-limit.js";
 import { mintAgentToken } from "./token.js";
 import { executeLocal, withLocalExecutionFacts, } from "./local-executor.js";
 import { startDormantSupervisor, } from "./execution-supervisor.js";
-import { buildClaudeArgs, CLAUDE_EFFORT_LEVELS } from "./runtimes/claude.js";
+import { CLAUDE_EFFORT_LEVELS } from "./runtimes/claude.js";
 import { CODEX_EFFORT_LEVELS } from "./runtimes/codex.js";
 import { KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
 import { executionBackendCapability } from "./execution-backend.js";
 import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
+import { RuntimeCancelledError } from "./runtime-cancellation.js";
+import { supervisorLaunch } from "./supervised-runtime.js";
+export { supervisorLaunch } from "./supervised-runtime.js";
 const ACTIVITY_KIND = {
     init: "working",
     text: "thinking",
@@ -183,70 +185,6 @@ function launchProviderConfig(config) {
         ...(config.description === undefined ? {} : { description: config.description }),
     };
 }
-export function supervisorLaunch(request) {
-    const common = {
-        wakePrompt: request.wakePrompt,
-        dangerous: request.effectivePermission === "full_access",
-        effectivePermission: request.effectivePermission,
-        ...(request.model === undefined ? {} : { model: request.model }),
-        ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
-    };
-    if (request.runtime === "claude") {
-        return {
-            command: request.bin,
-            args: buildClaudeArgs({
-                ...common,
-                bin: request.bin,
-                cwd: request.cwd,
-                env: request.env,
-                systemPromptPath: request.systemPromptPath,
-                ...(request.sessionId === undefined ? {} : {
-                    sessionId: request.sessionId,
-                    resume: request.resume,
-                }),
-            }),
-            cwd: request.cwd,
-            env: request.env,
-        };
-    }
-    if (request.runtime === "codex") {
-        return {
-            command: process.execPath,
-            args: [
-                fileURLToPath(new URL("./runtimes/codex-app-server-runner.js", import.meta.url)),
-                "--bin", request.bin,
-            ],
-            cwd: request.cwd,
-            env: request.env,
-            stdinText: JSON.stringify({
-                systemPrompt: request.systemPrompt,
-                wakePrompt: request.wakePrompt,
-                effectivePermission: request.effectivePermission,
-                ...(request.model === undefined ? {} : { model: request.model }),
-                ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
-                ...(request.sessionId === undefined ? {} : { sessionId: request.sessionId }),
-                ...(request.imagePaths === undefined ? {} : { imagePaths: request.imagePaths }),
-                resume: request.resume,
-            }),
-        };
-    }
-    if (request.effectivePermission !== "full_access") {
-        throw new Error(`Kimi ACP cannot enforce ${request.effectivePermission} permission`);
-    }
-    return {
-        command: process.execPath,
-        args: [
-            fileURLToPath(new URL("./runtimes/kimi-acp-runner.js", import.meta.url)),
-            "--bin", request.bin,
-            ...(request.model === undefined ? [] : ["--model", request.model]),
-            ...(request.sessionId === undefined ? [] : ["--session", request.sessionId]),
-            ...(request.resume ? ["--resume"] : []),
-        ],
-        cwd: request.cwd,
-        env: request.env,
-        stdinText: `${request.systemPrompt}\n\n${request.wakePrompt}`,
-    };
-}
 function rejection(executionId, reason, message, at) {
     return ExecutionRejectedSchema.parse({
         type: "execution:rejected",
@@ -494,7 +432,7 @@ export async function runExecution(config, input, dependencies) {
                     catch { /* best-effort console omitted when its envelope cannot fit */ }
                 },
             } : {}),
-            ...(spec.context.externalResponseSessionId ? {
+            ...(spec.context.externalResponseSessionId || spec.context.answerStream ? {
                 onExternalOutput: (text) => {
                     const frame = DaemonToServerExecutionFrameSchema.parse({
                         type: "execution:output",
@@ -513,6 +451,7 @@ export async function runExecution(config, input, dependencies) {
             } : {}),
         };
         const localDependencies = {
+            ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
             launchRuntime: async (request) => {
                 if (launchClosed || dependencies.cancellation?.isRequested())
                     throw new ExecutionCancelledError();
@@ -521,27 +460,42 @@ export async function runExecution(config, input, dependencies) {
                 launchAttempts.add(launchSettled);
                 try {
                     const processStartedAt = now().toISOString();
-                    const guarded = await dependencies.journal.startGuarded(spec.executionId, processStartedAt, () => startSupervisor(supervisorLaunch(request)));
+                    const launchControl = { cancel: null };
+                    const guarded = await dependencies.journal.startGuarded(spec.executionId, processStartedAt, () => startSupervisor(supervisorLaunch(request)), {
+                        beforeRelease: ({ entry, handle, abort }) => {
+                            supervisorState.active = handle;
+                            let stopPromise = null;
+                            let releaseStarted = false;
+                            const stopOnce = (operation) => {
+                                if (stopPromise === null) {
+                                    try {
+                                        stopPromise = Promise.resolve(operation());
+                                    }
+                                    catch (error) {
+                                        stopPromise = Promise.reject(error);
+                                    }
+                                }
+                                return stopPromise;
+                            };
+                            launchControl.cancel = () => stopOnce(releaseStarted ? handle.cancel : abort);
+                            supervisorState.abortOnce = () => stopOnce(abort);
+                            dependencies.cancellation?.register(launchControl.cancel);
+                            startedAt = entry.processStartedAt ?? processStartedAt;
+                            if (dependencies.cancellation?.isRequested()) {
+                                return dependencies.cancellation.waitForStop().then(() => {
+                                    throw new ExecutionCancelledError();
+                                });
+                            }
+                            releaseStarted = true;
+                        },
+                    });
                     if (guarded.kind !== "started") {
                         throw new Error(`Execution became ${guarded.entry.state} before local launch`);
                     }
-                    supervisorState.active = guarded.handle;
-                    let stopPromise = null;
-                    const stopOnce = (operation) => {
-                        if (stopPromise === null) {
-                            try {
-                                stopPromise = Promise.resolve(operation());
-                            }
-                            catch (error) {
-                                stopPromise = Promise.reject(error);
-                            }
-                        }
-                        return stopPromise;
-                    };
-                    const cancelOnce = () => stopOnce(guarded.handle.cancel);
-                    supervisorState.abortOnce = () => stopOnce(guarded.handle.abort);
-                    dependencies.cancellation?.register(cancelOnce);
-                    startedAt = guarded.entry.processStartedAt ?? processStartedAt;
+                    if (launchControl.cancel === null) {
+                        throw new Error("Execution launch cancellation gate was not installed");
+                    }
+                    const installedCancel = launchControl.cancel;
                     await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
                         type: "execution:started",
                         protocolVersion: 1,
@@ -552,14 +506,14 @@ export async function runExecution(config, input, dependencies) {
                         timeout = setTimeout(() => {
                             timedOut = true;
                             try {
-                                void cancelOnce().catch(rejectCancellationFailure);
+                                void installedCancel().catch(rejectCancellationFailure);
                             }
                             catch (error) {
                                 rejectCancellationFailure(error);
                             }
                         }, effectiveTimeoutMs);
                     }
-                    return guarded.handle;
+                    return { ...guarded.handle, cancel: installedCancel };
                 }
                 finally {
                     launchAttempts.delete(launchSettled);
@@ -608,10 +562,10 @@ export async function runExecution(config, input, dependencies) {
                 maxTurns: config.sessionMaxTurns,
             },
         };
-        const result = await cancellable(Promise.race([
+        const result = await Promise.race([
             execute(localInput, callbacks, localDependencies),
             cancellationFailure,
-        ]), dependencies.cancellation);
+        ]);
         if (timeout !== undefined)
             clearTimeout(timeout);
         const finishedAt = now().toISOString();
@@ -652,6 +606,9 @@ export async function runExecution(config, input, dependencies) {
             ...(!spec.reporting.captureFinal || result.finalText === null
                 ? {}
                 : { finalText: result.finalText }),
+            ...(spec.context.answerStream && result.exitCode === 0 && result.externalAnswer
+                ? { externalAnswer: result.externalAnswer }
+                : {}),
             ...(result.usage === undefined ? {} : { usage: result.usage }),
             startedAt,
             finishedAt,
@@ -660,7 +617,8 @@ export async function runExecution(config, input, dependencies) {
     catch (error) {
         if (timeout !== undefined)
             clearTimeout(timeout);
-        if (error instanceof ExecutionCancelledError) {
+        const cancelled = error instanceof ExecutionCancelledError || error instanceof RuntimeCancelledError;
+        if (cancelled) {
             await closeLaunchGate();
             await dependencies.cancellation?.waitForStop();
         }
@@ -673,7 +631,7 @@ export async function runExecution(config, input, dependencies) {
                 throw new AggregateError([error, abortError], `Failed to stop the execution supervisor: ${detail}`);
             }
         }
-        completion = error instanceof ExecutionCancelledError
+        completion = cancelled
             ? ExecutionCompletedSchema.parse({
                 type: "execution:completed",
                 protocolVersion: 1,

package/dist/execution-supervisor.js

@@ -44,6 +44,55 @@ async function waitForProcessGroupExit(pid, timeoutMs) {
         await new Promise((resolve) => setTimeout(resolve, PROCESS_GROUP_POLL_MS));
     }
 }
+async function processGroupExists(pid) {
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ESRCH")
+            return false;
+        if (code === "EPERM")
+            return true;
+        throw error;
+    }
+}
+async function signalOwnedTreeIfPresent(pid, signal, platform, signalTree) {
+    try {
+        await signalTree(pid, signal, platform);
+    }
+    catch (error) {
+        if (error.code !== "ESRCH")
+            throw error;
+    }
+}
+async function terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisorClosed, signalTree) {
+    const waitUntilStopped = () => platform === "win32"
+        ? waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), timeoutMs, pid)
+        : waitForProcessGroupExit(pid, timeoutMs);
+    let termError;
+    try {
+        await signalOwnedTreeIfPresent(pid, "SIGTERM", platform, signalTree);
+        await waitUntilStopped();
+        return;
+    }
+    catch (error) {
+        termError = error;
+    }
+    try {
+        await signalOwnedTreeIfPresent(pid, "SIGKILL", platform, signalTree);
+        await waitUntilStopped();
+    }
+    catch (killError) {
+        throw new AggregateError([termError, killError], "Supervisor process-tree termination failed");
+    }
+}
+async function confirmOrTerminateOwnedTree(pid, platform, timeoutMs, supervisorClosed, signalTree) {
+    if (platform !== "win32" && !(await processGroupExists(pid)))
+        return;
+    await terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisorClosed, signalTree);
+}
 async function withTimeout(promise, timeoutMs, phase) {
     let timer;
     try {
@@ -86,9 +135,13 @@ export async function signalSupervisorTree(pid, signal, platform = process.platf
 }
 export async function startDormantSupervisor(launch, options = {}) {
     const platform = options.platform ?? process.platform;
-    const backend = executionBackendCapability(platform);
-    if (!backend.supported)
-        throw new Error(backend.reason);
+    const ownershipMode = options.ownershipMode ?? "durable";
+    if (ownershipMode === "durable") {
+        const backend = executionBackendCapability(platform);
+        if (!backend.supported)
+            throw new Error(backend.reason);
+    }
+    const signalTree = options.signalTree ?? signalSupervisorTree;
     const childEntry = options.childEntry
         ?? fileURLToPath(new URL("./execution-supervisor-child.js", import.meta.url));
     const abortTimeoutMs = options.abortTimeoutMs ?? DEFAULT_ABORT_TIMEOUT_MS;
@@ -118,12 +171,16 @@ export async function startDormantSupervisor(launch, options = {}) {
             ...(supervisorSpawnError === undefined && signal !== null ? { terminationSignal: signal } : {}),
         }));
     });
+    const supervisorClosed = new Promise((resolve) => child.once("close", () => resolve()));
+    let treeStopPromise = null;
+    const ensureTreeStopped = () => {
+        treeStopPromise ??= confirmOrTerminateOwnedTree(pid, platform, abortTimeoutMs, supervisorClosed, signalTree);
+        return treeStopPromise;
+    };
     const exit = supervisorExit.then(async (result) => {
-        if (platform !== "win32")
-            await waitForProcessGroupExit(pid, abortTimeoutMs);
+        await ensureTreeStopped();
         return result;
     });
-    const supervisorClosed = new Promise((resolve) => child.once("close", () => resolve()));
     let readyResolve;
     let readyReject;
     const ready = new Promise((resolve, reject) => {
@@ -161,41 +218,30 @@ export async function startDormantSupervisor(launch, options = {}) {
     const abort = async () => {
         if (child.exitCode !== null || child.signalCode !== null) {
             await supervisorClosed;
+            await ensureTreeStopped();
             return;
         }
-        try {
-            await signalSupervisorTree(pid, "SIGTERM", platform);
-        }
-        catch (error) {
-            const code = error instanceof Error && "code" in error ? error.code : undefined;
-            if (code !== "ESRCH")
-                throw error;
-        }
-        try {
-            await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
-        }
-        catch (error) {
-            try {
-                await signalSupervisorTree(pid, "SIGKILL", platform);
-            }
-            catch (killError) {
-                const code = killError instanceof Error && "code" in killError ? killError.code : undefined;
-                if (code !== "ESRCH")
-                    throw new AggregateError([error, killError], "Supervisor abort failed");
-            }
-            await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
-        }
+        await ensureTreeStopped();
+        await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
+        await ensureTreeStopped();
     };
     const cancel = async () => {
         if (child.exitCode !== null || child.signalCode !== null) {
             await supervisorClosed;
+            await ensureTreeStopped();
             return;
         }
         try {
             await new Promise((resolve, reject) => {
                 child.send({ type: "abort" }, (error) => error === null ? resolve() : reject(error));
             });
-            await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
+            if (platform === "win32") {
+                await ensureTreeStopped();
+            }
+            else {
+                await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
+                await ensureTreeStopped();
+            }
         }
         catch {
             await abort();
@@ -218,9 +264,8 @@ export async function startDormantSupervisor(launch, options = {}) {
         });
         throw error;
     }
-    return {
+    const handle = {
         pid,
-        parentExitGuard: "pipe-eof",
         stdout: child.stdout,
         stderr: child.stderr,
         exit,
@@ -249,4 +294,7 @@ export async function startDormantSupervisor(launch, options = {}) {
         abort,
         cancel,
     };
+    return ownershipMode === "durable"
+        ? { ...handle, ownershipMode, parentExitGuard: "pipe-eof" }
+        : { ...handle, ownershipMode };
 }

package/dist/external-output.js

@@ -84,3 +84,31 @@ export function stripExternalAnswerMarkers(value) {
     }
     return (sections.length > 0 ? sections.join("") : value).trim();
 }
+/**
+ * 提取 marker 内容:有 marker 返回拼接内容(trim,空→null),无 marker 返回 null。
+ * 与 stripExternalAnswerMarkers 的区别:strip 在无 marker 时回退整段原文(finalText 展示用),
+ * 本函数用于判定"agent 是否给出了频道直接回复"——必须能区分有无 marker。
+ */
+export function extractExternalAnswer(value) {
+    const parts = [];
+    let found = false;
+    let rest = value;
+    for (;;) {
+        const open = rest.indexOf(EXTERNAL_ANSWER_OPEN);
+        if (open < 0)
+            break;
+        found = true;
+        const afterOpen = rest.slice(open + EXTERNAL_ANSWER_OPEN.length);
+        const close = afterOpen.indexOf(EXTERNAL_ANSWER_CLOSE);
+        if (close < 0) {
+            parts.push(afterOpen);
+            break;
+        }
+        parts.push(afterOpen.slice(0, close));
+        rest = afterOpen.slice(close + EXTERNAL_ANSWER_CLOSE.length);
+    }
+    if (!found)
+        return null;
+    const answer = parts.join("").trim();
+    return answer.length > 0 ? answer : null;
+}

package/dist/i18n.js

@@ -17,6 +17,8 @@ export function detectDaemonLang(env = process.env) {
 }
 const zh = {
     "Claude session started": "Claude 会话启动",
+    "Codex session started": "Codex 会话启动",
+    "Files changed": "文件变更",
     "Run failed": "运行出错",
     "Run finished": "本轮结束",
     "Missing CREW_MACHINE_TOKEN (sk_machine_*, printed by seed)": "缺少 CREW_MACHINE_TOKEN（sk_machine_*，由 seed 打印）",
@@ -40,6 +42,7 @@ const zh = {
     "Saved profile '{{name}}' with private credentials.": "已保存配置 '{{name}}'，凭证仅私有可读。",
     "Service '{{id}}' is not installed": "服务 '{{id}}' 尚未安装",
     "Upgraded daemon and restart request accepted for '{{name}}'. Verify with status.": "daemon 已升级，并已请求重启 '{{name}}'；请用 status 确认。",
+    "Upgraded daemon but skipped restart for '{{name}}': {{reason}}": "daemon 已升级，但已跳过 '{{name}}' 的重启：{{reason}}",
     "Upgraded daemon. Installed services were not restarted; pass --profile to restart one.": "daemon 已升级；已安装服务尚未重启，可传入 --profile 重启指定服务。",
     "Service lifecycle requires the built daemon entry (.js), not a TypeScript development entry": "服务生命周期必须使用已构建的 daemon 入口（.js），不能使用 TypeScript 开发入口",
     "Installed '{{id}}'. Use status to confirm runtime state.": "已安装 '{{id}}'；请用 status 确认运行状态。",
@@ -47,6 +50,7 @@ const zh = {
     "{{action}} request accepted for '{{id}}'. Verify with status.": "已接受对 '{{id}}' 的 {{action}} 请求；请用 status 确认。",
     "--token-stdin requires a token on standard input": "--token-stdin 需要从标准输入读取令牌",
     "Service lifecycle requires a global @nowcrew/daemon install; run npm install --global @nowcrew/daemon@latest": "服务生命周期需要全局安装 @nowcrew/daemon；请运行 npm install --global @nowcrew/daemon@latest",
+    "Profile '{{profile}}' conflicts with profile '{{conflict}}': both resolve to agents root '{{agentsRoot}}'. Save it with a unique root, for example: {{command}}": "配置 '{{profile}}' 与配置 '{{conflict}}' 解析到了同一个 agents root '{{agentsRoot}}'。请保存为唯一目录，例如：{{command}}",
 };
 export function translateDaemon(lang, message) {
     if (lang === "zh")
@@ -54,9 +58,5 @@ export function translateDaemon(lang, message) {
     return message;
 }
 export function formatDaemonText(lang, message, values = {}) {
-    let rendered = translateDaemon(lang, message);
-    for (const [key, value] of Object.entries(values)) {
-        rendered = rendered.replaceAll(`{{${key}}}`, String(value));
-    }
-    return rendered;
+    return translateDaemon(lang, message).replace(/\{\{([^{}]+)\}\}/g, (token, key) => Object.hasOwn(values, key) ? String(values[key]) : token);
 }

package/dist/local-executor.js

@@ -11,9 +11,10 @@ import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
 import { toConsoleLines } from "./console.js";
 import { capMemoryForInject, capWorkLogForInject } from "./prompt.js";
-import { decodeExternalOutputEvent, ExternalAnswerDecoder, stripExternalAnswerMarkers, } from "./external-output.js";
-import { cleanupMaterializedAttachments as cleanupAttachments, materializeAttachments, } from "./attachments.js";
+import { decodeExternalOutputEvent, extractExternalAnswer, ExternalAnswerDecoder, stripExternalAnswerMarkers, } from "./external-output.js";
+import { cleanupMaterializedAttachments as cleanupAttachments, executionAttachmentDirectory, materializeAttachments, } from "./attachments.js";
 import { routeRuntimeAttachments, runtimeCapability, } from "./runtime-capabilities.js";
+import { awaitWithCancellation, RuntimeCancelledError, } from "./runtime-cancellation.js";
 function truncateUtf8(value, maxBytes) {
     if (maxBytes <= 0)
         return "";
@@ -138,20 +139,22 @@ function resolvePrompt(prompt, context) {
     return typeof prompt === "string" ? prompt : prompt(context);
 }
 const nativeSessionLeaseTails = new Map();
-async function withKeyedLease(key, operation) {
+async function withKeyedLease(key, operation, cancellation) {
     const predecessor = nativeSessionLeaseTails.get(key) ?? Promise.resolve();
     let release;
     const current = new Promise((resolve) => { release = resolve; });
     const tail = predecessor.then(() => current);
     nativeSessionLeaseTails.set(key, tail);
-    await predecessor;
     try {
+        await awaitWithCancellation(predecessor, cancellation);
         return await operation();
     }
     finally {
         release();
-        if (nativeSessionLeaseTails.get(key) === tail)
-            nativeSessionLeaseTails.delete(key);
+        void tail.then(() => {
+            if (nativeSessionLeaseTails.get(key) === tail)
+                nativeSessionLeaseTails.delete(key);
+        });
     }
 }
 export async function executeLocal(input, callbacks = {}, dependencies = {}) {
@@ -167,14 +170,14 @@ export async function executeLocal(input, callbacks = {}, dependencies = {}) {
         input.keyMode ?? "legacy",
         input.resumeKey ?? input.taskKey ?? "",
     ]);
-    return withKeyedLease(leaseKey, () => executeLocalUnlocked(input, callbacks, dependencies));
+    return withKeyedLease(leaseKey, () => executeLocalUnlocked(input, callbacks, dependencies), dependencies.cancellation);
 }
 async function executeLocalUnlocked(input, callbacks, dependencies) {
     const providerConfig = input.launch.providerConfig ?? {};
     const { runtime } = input;
     const currentModel = runtime.model ?? null;
     const providerFp = providerFingerprint(runtime.name, providerConfig);
-    const workspace = await prepareWorkspace({
+    const workspace = await awaitWithCancellation(prepareWorkspace({
         agentsRoot: input.launch.agentsRoot,
         handle: input.handle,
         cliPath: input.launch.cliPath,
@@ -183,8 +186,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
         ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
         ...(input.launch.description ? { description: input.launch.description } : {}),
-    });
+    }), dependencies.cancellation);
     let materialized = null;
+    let knownAttachmentDirectory = null;
     try {
         const supportsNativeResume = runtime.name === "claude"
             || (dependencies.launchRuntime !== undefined && runtimeCapability(runtime.name).nativeResume);
@@ -208,17 +212,38 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         };
         const systemPrompt = resolvePrompt(input.systemPrompt, promptContext);
         if (input.attachments && input.attachments.length > 0) {
-            materialized = await (dependencies.materializeAttachments ?? materializeAttachments)({
+            if (dependencies.cancellation?.isRequested())
+                throw new RuntimeCancelledError();
+            knownAttachmentDirectory = executionAttachmentDirectory(workspace.runDir, input.executionId);
+            const controller = new AbortController();
+            const materialization = Promise.resolve().then(() => (dependencies.materializeAttachments ?? materializeAttachments)({
                 serverUrl: input.launch.serverUrl,
                 token: input.launch.token,
                 runDir: workspace.runDir,
                 executionId: input.executionId,
                 attachments: input.attachments,
+                signal: controller.signal,
+            }));
+            dependencies.cancellation?.register(async () => {
+                controller.abort(new RuntimeCancelledError());
+                await materialization.then(() => undefined, () => undefined);
             });
+            try {
+                materialized = await materialization;
+            }
+            catch (error) {
+                if (dependencies.cancellation?.isRequested())
+                    throw new RuntimeCancelledError();
+                throw error;
+            }
+            if (dependencies.cancellation?.isRequested()) {
+                await dependencies.cancellation.waitForStop();
+                throw new RuntimeCancelledError();
+            }
         }
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
         const wakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
-        await writeFile(workspace.systemPromptPath, systemPrompt, "utf8");
+        await awaitWithCancellation(writeFile(workspace.systemPromptPath, systemPrompt, "utf8"), dependencies.cancellation);
         const baseEnv = {
             ...process.env,
             ...sanitizeEnvVars(providerConfig.envVars),
@@ -242,6 +267,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         };
         const childEnv = applyProviderEnv(baseEnv, runtime.name, providerConfig, workspace.homeDir);
         const launchRuntime = dependencies.launchRuntime ?? launchLegacyRuntime;
+        if (dependencies.cancellation?.isRequested())
+            throw new RuntimeCancelledError();
         const child = await launchRuntime({
             runtime: runtime.name,
             bin: runtime.name,
@@ -259,6 +286,13 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 ? { imagePaths: attachmentPlan.nativeImagePaths }
                 : {}),
         });
+        if (child.cancel !== undefined) {
+            dependencies.cancellation?.register(child.cancel);
+        }
+        if (dependencies.cancellation?.isRequested()) {
+            await dependencies.cancellation.waitForStop();
+            throw new RuntimeCancelledError();
+        }
         const activities = [];
         let sessionId = launchSessionId;
         let usage;
@@ -301,7 +335,17 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             process.stderr.write(data);
             stderrTail = (stderrTail + String(data)).slice(-STDERR_TAIL_CAP);
         });
-        const { exitCode, spawnError, terminationSignal } = await child.exit;
+        let runtimeExit;
+        try {
+            runtimeExit = await awaitWithCancellation(child.exit, dependencies.cancellation);
+        }
+        catch (error) {
+            if (error instanceof RuntimeCancelledError) {
+                await dependencies.cancellation?.waitForStop();
+            }
+            throw error;
+        }
+        const { exitCode, spawnError, terminationSignal } = runtimeExit;
         const errorTail = [
             stderrTail.trim(),
             spawnError,
@@ -343,17 +387,24 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             finalText: input.captureFinal && finalText !== null
                 ? stripExternalAnswerMarkers(finalText)
                 : null,
+            externalAnswer: input.captureFinal && finalText !== null
+                ? extractExternalAnswer(finalText)
+                : null,
             sentViaCrew,
         };
     }
     finally {
-        if (materialized) {
+        const attachmentDirectories = new Set([
+            ...(knownAttachmentDirectory === null ? [] : [knownAttachmentDirectory]),
+            ...(materialized === null ? [] : [materialized.directory]),
+        ]);
+        for (const directory of attachmentDirectories) {
             try {
-                await (dependencies.cleanupMaterializedAttachments ?? cleanupAttachments)(materialized.directory);
+                await (dependencies.cleanupMaterializedAttachments ?? cleanupAttachments)(directory);
             }
             catch (error) {
                 const detail = error instanceof Error ? error.message : String(error);
-                process.stderr.write(`[execution] failed to remove attachments ${materialized.directory}: ${detail}\n`);
+                process.stderr.write(`[execution] failed to remove attachments ${directory}: ${detail}\n`);
             }
         }
         try {

package/dist/machine-info.js

@@ -24,6 +24,7 @@ export const DAEMON_CAPABILITIES = [
     "execution_telemetry_ack_v1",
     "execution_external_output_v1",
     "execution_attachments_v1",
+    "execution_answer_stream_v1",
 ];
 export const EXECUTION_PROTOCOL = Object.freeze({ min: 1, max: 1 });
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */