@nowcrew/daemon 0.5.18 → 0.5.20

package/dist/execution-journal.js

@@ -558,7 +558,7 @@ export function createExecutionJournal(agentsRoot, options = {}) {
                 return { kind: "created", ...entry };
             });
         },
-        startGuarded: async (executionId, processStartedAt, startDormant) => {
+        startGuarded: async (executionId, processStartedAt, startDormant, hooks) => {
             validateExecutionId(executionId);
             TimestampSchema.parse(processStartedAt);
             return serialized(async () => {
@@ -567,9 +567,21 @@ export function createExecutionJournal(agentsRoot, options = {}) {
                     return { kind: "existing", entry: await confirmDurable(entry) };
                 }
                 const dormant = await startDormant();
+                let abortPromise = null;
+                const abort = () => {
+                    if (abortPromise === null) {
+                        try {
+                            abortPromise = Promise.resolve(dormant.abort());
+                        }
+                        catch (error) {
+                            abortPromise = Promise.reject(error);
+                        }
+                    }
+                    return abortPromise;
+                };
                 const abortWith = async (error) => {
                     try {
-                        await dormant.abort();
+                        await abort();
                     }
                     catch (abortError) {
                         throw new AggregateError([error, abortError], "Dormant runtime abort failed");
@@ -591,6 +603,9 @@ export function createExecutionJournal(agentsRoot, options = {}) {
                     });
                     await writeRecord(updated);
                     try {
+                        const gate = hooks?.beforeRelease?.({ entry: updated, handle: dormant, abort });
+                        if (gate !== undefined)
+                            await gate;
                         await dormant.release();
                     }
                     catch (error) {
@@ -671,8 +686,31 @@ export function createExecutionJournal(agentsRoot, options = {}) {
             }
         }),
         prune: async () => serialized(pruneInternal),
-        close: async () => {
-            await runSerialized(directory, lease.close);
+        close: async (closeOptions = {}) => {
+            const signal = closeOptions.signal;
+            let started = false;
+            const closing = runSerialized(directory, async () => {
+                started = true;
+                if (signal?.aborted)
+                    throw signal.reason ?? new Error("Journal close aborted");
+                await lease.close(closeOptions);
+            });
+            if (signal === undefined)
+                return closing;
+            await new Promise((resolveClose, rejectClose) => {
+                const settle = (settler) => {
+                    signal.removeEventListener("abort", onAbort);
+                    settler();
+                };
+                const onAbort = () => {
+                    if (!started)
+                        settle(() => rejectClose(signal.reason ?? new Error("Journal close aborted")));
+                };
+                signal.addEventListener("abort", onAbort, { once: true });
+                if (signal.aborted)
+                    onAbort();
+                closing.then(() => settle(resolveClose), (error) => settle(() => rejectClose(error)));
+            });
         },
     };
 }

package/dist/execution-protocol.js

@@ -48,7 +48,7 @@ export const LegacyAgentStartSchema = z.object({
         content: z.string().optional(),
         senderHandle: z.string().optional(),
         threadId: z.string().optional(),
-        origin: z.enum(["wecom"]).optional(),
+        origin: z.enum(["wecom", "feishu"]).optional(),
     }).passthrough().optional(),
     scheduledRun: z.object({
         jobId: z.string().min(1),
@@ -85,6 +85,12 @@ export const ConsoleStreamSchema = z.enum([
     "result",
     "error",
 ]);
+export const ExecutionAttachmentSchema = z.object({
+    id: z.string().min(1).max(200),
+    filename: z.string().min(1).max(255),
+    mime: z.string().min(1).max(200),
+    sizeBytes: z.number().int().nonnegative().max(25 * 1024 * 1024),
+}).strict();
 export const ExecutionStartSchema = z.object({
     type: z.literal("execution:start"),
     protocolVersion: ProtocolVersionSchema,
@@ -115,6 +121,9 @@ export const ExecutionStartSchema = z.object({
         channelId: z.string().min(1),
         threadId: z.string().min(1).optional(),
         wakeMessageId: z.string().min(1).optional(),
+        externalResponseSessionId: ExecutionIdSchema.optional(),
+        answerStream: z.boolean().optional(),
+        attachments: z.array(ExecutionAttachmentSchema).max(20).optional(),
     }).strict(),
     reporting: z.object({
         captureFinal: z.boolean(),
@@ -185,6 +194,15 @@ export const ExecutionConsoleSchema = z.object({
     seq: SequenceSchema,
     at: TimestampSchema,
 }).strict();
+export const ExecutionOutputSchema = z.object({
+    type: z.literal("execution:output"),
+    protocolVersion: ProtocolVersionSchema,
+    executionId: ExecutionIdSchema,
+    channel: z.literal("external_answer"),
+    text: z.string().min(1),
+    seq: SequenceSchema,
+    at: TimestampSchema,
+}).strict();
 export const ExecutionUsageSchema = z.object({
     inputTokens: TokenCountSchema,
     outputTokens: TokenCountSchema,
@@ -205,6 +223,7 @@ const RawExecutionCompletedSchema = z.object({
     model: z.string().optional(),
     resumed: z.boolean(),
     finalText: z.string().optional(),
+    externalAnswer: z.string().min(1).optional(),
     boundImDecision: z.enum(["notify", "silent"]).optional(),
     usage: ExecutionUsageSchema.optional(),
     startedAt: TimestampSchema,
@@ -312,6 +331,7 @@ const RawDaemonToServerExecutionFrameSchema = z.discriminatedUnion("type", [
     ExecutionStartedSchema,
     ExecutionActivitySchema,
     ExecutionConsoleSchema,
+    ExecutionOutputSchema,
     RawExecutionCompletedSchema,
     ExecutionSnapshotSchema,
 ]);

package/dist/execution-recovery.js

@@ -0,0 +1,71 @@
+import { join, resolve } from "node:path";
+export async function reconcileExecutionJournal(journal, dependencies) {
+    try {
+        await journal.reconcileAfterRestart();
+    }
+    catch (error) {
+        const agentsRoot = resolve(dependencies.agentsRoot);
+        const errorRecord = typeof error === "object" && error !== null
+            ? error
+            : {};
+        const journalPath = typeof errorRecord.journalPath === "string"
+            ? resolve(errorRecord.journalPath)
+            : join(agentsRoot, ".crew", "executions");
+        const ownerPid = typeof errorRecord.ownerPid === "number" ? errorRecord.ownerPid : undefined;
+        const errorType = error instanceof Error ? error.name : typeof error;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const diagnostics = {
+            server_url: dependencies.serverUrl,
+            agents_root: agentsRoot,
+            journal_path: journalPath,
+            owner_pid: ownerPid,
+            error_type: errorType,
+            error_message: errorMessage,
+        };
+        dependencies.log("execution.recovery_failed", "execution journal 恢复失败", {
+            level: "ERROR",
+            ...diagnostics,
+        });
+        dependencies.writeStderr(`${JSON.stringify({
+            level: "ERROR",
+            event_type: "execution.recovery_failed",
+            message: "execution journal 恢复失败",
+            ...diagnostics,
+        })}\n`);
+        const reportCleanupFailure = (stage, cleanupError) => {
+            const cleanupErrorType = cleanupError instanceof Error ? cleanupError.name : typeof cleanupError;
+            const cleanupErrorMessage = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+            const cleanupDiagnostics = {
+                server_url: dependencies.serverUrl,
+                agents_root: agentsRoot,
+                journal_path: journalPath,
+                owner_pid: ownerPid,
+                cleanup_stage: stage,
+                error_type: cleanupErrorType,
+                error_message: cleanupErrorMessage,
+                recovery_error_type: errorType,
+                recovery_error_message: errorMessage,
+            };
+            dependencies.log("execution.recovery_cleanup_failed", "execution journal 恢复失败后的清理失败", { level: "ERROR", ...cleanupDiagnostics });
+            dependencies.writeStderr(`${JSON.stringify({
+                level: "ERROR",
+                event_type: "execution.recovery_cleanup_failed",
+                message: "execution journal 恢复失败后的清理失败",
+                ...cleanupDiagnostics,
+            })}\n`);
+        };
+        try {
+            await dependencies.flush();
+        }
+        catch (cleanupError) {
+            reportCleanupFailure("slog_flush", cleanupError);
+        }
+        try {
+            await journal.close();
+        }
+        catch (cleanupError) {
+            reportCleanupFailure("journal_close", cleanupError);
+        }
+        throw error;
+    }
+}

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 { buildCodexArgs, CODEX_EFFORT_LEVELS } from "./runtimes/codex.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,56 +185,6 @@ function launchProviderConfig(config) {
         ...(config.description === undefined ? {} : { description: config.description }),
     };
 }
-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: request.bin,
-            args: buildCodexArgs(common),
-            cwd: request.cwd,
-            env: request.env,
-            stdinText: `${request.systemPrompt}\n\n${request.wakePrompt}`,
-        };
-    }
-    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]),
-        ],
-        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",
@@ -442,6 +394,7 @@ export async function runExecution(config, input, dependencies) {
         const providerConfig = launchProviderConfig(credential.config);
         let activitySequence = 0;
         let consoleSequence = 0;
+        let externalOutputSequence = 0;
         const callbacks = {
             ...(spec.reporting.streamActivity ? {
                 onActivity: (activity) => {
@@ -479,8 +432,26 @@ export async function runExecution(config, input, dependencies) {
                     catch { /* best-effort console omitted when its envelope cannot fit */ }
                 },
             } : {}),
+            ...(spec.context.externalResponseSessionId || spec.context.answerStream ? {
+                onExternalOutput: (text) => {
+                    const frame = DaemonToServerExecutionFrameSchema.parse({
+                        type: "execution:output",
+                        protocolVersion: 1,
+                        executionId: spec.executionId,
+                        channel: "external_answer",
+                        text,
+                        seq: externalOutputSequence++,
+                        at: now().toISOString(),
+                    });
+                    try {
+                        telemetry.enqueue(boundExecutionFrame(frame, config.executionLimits.maxEventBytes));
+                    }
+                    catch { /* final completion remains the authoritative repair */ }
+                },
+            } : {}),
         };
         const localDependencies = {
+            ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
             launchRuntime: async (request) => {
                 if (launchClosed || dependencies.cancellation?.isRequested())
                     throw new ExecutionCancelledError();
@@ -489,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,
@@ -520,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);
@@ -543,6 +529,7 @@ export async function runExecution(config, input, dependencies) {
             taskKey: spec.workspace.taskKey,
             ...(spec.workspace.resumeKey === undefined ? {} : { resumeKey: spec.workspace.resumeKey }),
             ...(spec.context.wakeMessageId === undefined ? {} : { wakeMessageId: spec.context.wakeMessageId }),
+            ...(spec.context.attachments === undefined ? {} : { attachments: spec.context.attachments }),
             systemPrompt: withLocalExecutionFacts(spec.instructions.systemPrompt, config.executionLimits.maxPromptBytes
                 - Buffer.byteLength(spec.instructions.wakePrompt, "utf8")),
             wakePrompt: spec.instructions.wakePrompt,
@@ -575,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();
@@ -619,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,
@@ -627,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();
         }
@@ -640,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 };
 }