@nowcrew/daemon 0.5.11 → 0.5.13

package/dist/execution-runner.js

@@ -0,0 +1,637 @@
+import { createHash } from "node:crypto";
+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 { buildKimiArgs, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
+const ACTIVITY_KIND = {
+    init: "working",
+    text: "thinking",
+    reading: "reading",
+    sending: "sending",
+    checking: "checking",
+    claiming: "claiming",
+    crew: "working",
+    tool: "working",
+    tool_result: "working",
+    done: "done",
+    error: "error",
+};
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, nested]) => [key, canonical(nested)]));
+    }
+    return value;
+}
+export function hashExecutionSpec(spec) {
+    return createHash("sha256").update(JSON.stringify(canonical(spec))).digest("hex");
+}
+async function reportBestEffort(report, frame, timeoutMs) {
+    let timeout;
+    try {
+        return await Promise.race([
+            Promise.resolve(report(frame)).then(() => true, () => true),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(false), timeoutMs);
+            }),
+        ]);
+    }
+    catch {
+        return true;
+    }
+    finally {
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+    }
+}
+const DEFAULT_TELEMETRY_DRAIN_TIMEOUT_MS = 2_000;
+const DEFAULT_TELEMETRY_MAX_PENDING_FRAMES = 256;
+const DEFAULT_TELEMETRY_MAX_PENDING_BYTES = 1_048_576;
+const MAX_TIMER_MS = 2_147_483_647;
+class TelemetryQueue {
+    report;
+    timeoutMs;
+    maxPendingFrames;
+    maxPendingBytes;
+    pending = [];
+    idleWaiters = [];
+    pendingBytes = 0;
+    running = false;
+    closed = false;
+    constructor(report, timeoutMs, maxPendingFrames, maxPendingBytes) {
+        this.report = report;
+        this.timeoutMs = timeoutMs;
+        this.maxPendingFrames = maxPendingFrames;
+        this.maxPendingBytes = maxPendingBytes;
+    }
+    enqueue(frame) {
+        if (this.closed)
+            return;
+        const bytes = Buffer.byteLength(JSON.stringify(frame), "utf8");
+        if (this.pending.length >= this.maxPendingFrames
+            || this.pendingBytes + bytes > this.maxPendingBytes)
+            return;
+        this.pending.push({ frame, bytes });
+        this.pendingBytes += bytes;
+        void this.pump();
+    }
+    async closeAndDrain() {
+        this.closed = true;
+        if (!this.running && this.pending.length === 0)
+            return;
+        let timeout;
+        let resolveIdle;
+        const idleWaiter = () => resolveIdle();
+        const drained = await Promise.race([
+            new Promise((resolve) => {
+                resolveIdle = () => resolve(true);
+                this.idleWaiters.push(idleWaiter);
+            }),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(false), this.timeoutMs);
+            }),
+        ]);
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+        if (!drained) {
+            const waiterIndex = this.idleWaiters.indexOf(idleWaiter);
+            if (waiterIndex >= 0)
+                this.idleWaiters.splice(waiterIndex, 1);
+            this.fuse();
+        }
+    }
+    async pump() {
+        if (this.running)
+            return;
+        this.running = true;
+        while (this.pending.length > 0) {
+            const pending = this.pending.shift();
+            if (pending !== undefined) {
+                this.pendingBytes -= pending.bytes;
+                await this.reportBounded(pending.frame);
+            }
+        }
+        this.running = false;
+        for (const resolve of this.idleWaiters.splice(0))
+            resolve();
+    }
+    async reportBounded(frame) {
+        const settled = await reportBestEffort(this.report, frame, this.timeoutMs);
+        if (!settled)
+            this.fuse();
+    }
+    fuse() {
+        this.closed = true;
+        this.pending.length = 0;
+        this.pendingBytes = 0;
+    }
+}
+function telemetryDrainTimeout(value) {
+    if (value === undefined || !Number.isFinite(value))
+        return DEFAULT_TELEMETRY_DRAIN_TIMEOUT_MS;
+    return Math.min(MAX_TIMER_MS, Math.max(1, Math.floor(value)));
+}
+function positiveTelemetryLimit(value, fallback) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    return Math.max(1, Math.floor(value));
+}
+function effectivePermission(spec, config) {
+    const requested = spec.permissions.requested === "local_default"
+        ? (config.dangerous ? "full_access" : "workspace_write")
+        : spec.permissions.requested;
+    if (!config.dangerous && requested === "full_access")
+        return "workspace_write";
+    return requested;
+}
+function validReasoning(spec) {
+    const reasoning = spec.runtime.reasoning;
+    if (reasoning === undefined || reasoning === "default")
+        return true;
+    if (spec.runtime.name === "claude") {
+        return CLAUDE_EFFORT_LEVELS.includes(reasoning);
+    }
+    if (spec.runtime.name === "codex") {
+        return CODEX_EFFORT_LEVELS.includes(reasoning);
+    }
+    return KIMI_EFFORT_LEVELS.includes(reasoning);
+}
+function launchProviderConfig(config) {
+    if (config === undefined)
+        return {};
+    return {
+        ...(config.provider === undefined ? {} : { provider: config.provider }),
+        ...(config.providerBaseUrl === undefined ? {} : { providerBaseUrl: config.providerBaseUrl }),
+        ...(config.providerApiKey === undefined ? {} : { providerApiKey: config.providerApiKey }),
+        ...(config.providerAuthMode === undefined ? {} : { providerAuthMode: config.providerAuthMode }),
+        ...(config.providerSmallFastModel === undefined
+            ? {}
+            : { providerSmallFastModel: config.providerSmallFastModel }),
+        ...(config.envVars === undefined ? {} : { envVars: config.envVars }),
+        ...(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}`,
+        };
+    }
+    return {
+        command: request.bin,
+        args: buildKimiArgs({
+            wakePrompt: `${request.systemPrompt}\n\n${request.wakePrompt}`,
+            effectivePermission: request.effectivePermission,
+            ...(request.model === undefined ? {} : { model: request.model }),
+        }),
+        cwd: request.cwd,
+        env: request.env,
+    };
+}
+function rejection(executionId, reason, message, at) {
+    return ExecutionRejectedSchema.parse({
+        type: "execution:rejected",
+        protocolVersion: 1,
+        executionId,
+        reason,
+        message,
+        at,
+    });
+}
+function admission(spec, config, dependencies, at) {
+    if (dependencies.platform === "win32" || (dependencies.platform === undefined && process.platform === "win32")) {
+        return { rejected: rejection(spec.executionId, "capability_missing", "Execution supervisor is unavailable on Windows", at) };
+    }
+    const promptBytes = Buffer.byteLength(spec.instructions.systemPrompt, "utf8")
+        + Buffer.byteLength(spec.instructions.wakePrompt, "utf8");
+    if (promptBytes > config.executionLimits.maxPromptBytes) {
+        return { rejected: rejection(spec.executionId, "resource_limit", "Prompt exceeds the local byte limit", at) };
+    }
+    if (spec.runtime.timeoutMs !== undefined
+        && spec.runtime.timeoutMs > config.executionLimits.maxTimeoutMs) {
+        return { rejected: rejection(spec.executionId, "resource_limit", "Timeout exceeds the local limit", at) };
+    }
+    if (!dependencies.facts.availableRuntimes.includes(spec.runtime.name)) {
+        return { rejected: rejection(spec.executionId, "runtime_unavailable", "Requested runtime is unavailable", at) };
+    }
+    if (!validReasoning(spec)) {
+        return { rejected: rejection(spec.executionId, "invalid_spec", "Reasoning mode is unsupported by the runtime", at) };
+    }
+    if (!Number.isInteger(dependencies.facts.activeForAgent)
+        || !Number.isInteger(dependencies.facts.queuedForAgent)
+        || dependencies.facts.activeForAgent < 0
+        || dependencies.facts.queuedForAgent < 0) {
+        return { rejected: rejection(spec.executionId, "invalid_spec", "Invalid local resource facts", at) };
+    }
+    const slotInvalid = dependencies.slot?.state === "ready"
+        ? dependencies.facts.activeForAgent >= config.executionLimits.maxParallelPerAgent
+        : dependencies.slot?.state === "queued"
+            ? dependencies.facts.activeForAgent < config.executionLimits.maxParallelPerAgent
+                || dependencies.facts.queuedForAgent >= config.executionLimits.maxQueuedPerAgent
+            : false;
+    if (slotInvalid || (dependencies.slot === undefined && (dependencies.facts.activeForAgent >= config.executionLimits.maxParallelPerAgent
+        || dependencies.facts.queuedForAgent >= config.executionLimits.maxQueuedPerAgent))) {
+        return { rejected: rejection(spec.executionId, "resource_limit", "Local execution capacity is exhausted", at) };
+    }
+    const permission = effectivePermission(spec, config);
+    if (spec.runtime.name === "kimi" && permission !== "full_access") {
+        return { rejected: rejection(spec.executionId, "local_policy_denied", `Kimi cannot enforce ${permission} permission`, at) };
+    }
+    return { spec, permission };
+}
+class ExecutionCancelledError extends Error {
+    constructor() {
+        super("Execution cancelled before completion");
+        this.name = "ExecutionCancelledError";
+    }
+}
+async function cancellable(promise, cancellation) {
+    if (cancellation === undefined)
+        return promise;
+    if (cancellation.isRequested())
+        throw new ExecutionCancelledError();
+    return Promise.race([
+        promise,
+        cancellation.requested.then(() => { throw new ExecutionCancelledError(); }),
+    ]);
+}
+function failedCompletion(spec, error, startedAt, finishedAt) {
+    const message = error instanceof Error ? error.message : String(error);
+    return ExecutionCompletedSchema.parse({
+        type: "execution:completed",
+        protocolVersion: 1,
+        executionId: spec.executionId,
+        outcome: "failed",
+        errorCode: "local_execution_failed",
+        errorMessage: message || "Unknown local execution failure",
+        runtime: spec.runtime.name,
+        ...(spec.runtime.model === undefined ? {} : { model: spec.runtime.model }),
+        resumed: false,
+        startedAt,
+        finishedAt,
+    });
+}
+export async function runExecution(config, input, dependencies) {
+    const now = dependencies.now ?? (() => new Date());
+    const initialAt = now().toISOString();
+    const parsed = ExecutionStartSchema.safeParse(input);
+    if (!parsed.success) {
+        const executionId = typeof input === "object" && input !== null && "executionId" in input
+            && typeof input.executionId === "string"
+            ? input.executionId
+            : null;
+        if (executionId === null)
+            throw new TypeError("Invalid execution spec without an executionId");
+        const frame = ExecutionRejectedSchema.parse(boundExecutionFrame(rejection(executionId, "invalid_spec", parsed.error.message, initialAt), config.executionLimits.maxEventBytes));
+        await dependencies.report(frame);
+        return { kind: "rejected", frame };
+    }
+    const spec = parsed.data;
+    const bestEffortTimeoutMs = telemetryDrainTimeout(dependencies.telemetryDrainTimeoutMs);
+    const specHash = hashExecutionSpec(spec);
+    const replay = await dependencies.journal.get(spec.executionId);
+    if (replay !== null) {
+        if (replay.specHash !== specHash) {
+            throw new JournalConflictError(`Execution ${spec.executionId} already has a different specHash`);
+        }
+        const replayPermission = replay.effectivePermission ?? effectivePermission(spec, config);
+        if ((replay.state === "completed" || replay.state === "interrupted")
+            && replay.completion !== null) {
+            await dependencies.report(boundExecutionFrame(replay.completion, config.executionLimits.maxEventBytes));
+            return { kind: "existing", entry: replay };
+        }
+        await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
+            type: "execution:accepted",
+            protocolVersion: 1,
+            executionId: spec.executionId,
+            state: dependencies.slot?.state ?? "ready",
+            effectivePermission: replayPermission,
+            at: replay.acceptedAt,
+        }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
+        if (replay.state === "running" && replay.processStartedAt !== null) {
+            await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
+                type: "execution:started",
+                protocolVersion: 1,
+                executionId: spec.executionId,
+                at: replay.processStartedAt,
+            }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
+        }
+        return { kind: "existing", entry: replay };
+    }
+    const checked = admission(spec, config, dependencies, initialAt);
+    if ("rejected" in checked) {
+        const frame = ExecutionRejectedSchema.parse(boundExecutionFrame(checked.rejected, config.executionLimits.maxEventBytes));
+        await dependencies.report(frame);
+        return { kind: "rejected", frame };
+    }
+    const { permission } = checked;
+    const effectiveTimeoutMs = spec.runtime.timeoutMs ?? config.executionLimits.maxTimeoutMs;
+    const accepted = await dependencies.journal.accept(spec.executionId, specHash, {
+        runtime: spec.runtime.name,
+        ...(spec.runtime.model === undefined ? {} : { model: spec.runtime.model }),
+        resumed: false,
+        effectivePermission: permission,
+    });
+    if (accepted.kind === "existing") {
+        if ((accepted.state === "completed" || accepted.state === "interrupted")
+            && accepted.completion !== null) {
+            await dependencies.report(boundExecutionFrame(accepted.completion, config.executionLimits.maxEventBytes));
+            return { kind: "existing", entry: accepted };
+        }
+        await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
+            type: "execution:accepted",
+            protocolVersion: 1,
+            executionId: spec.executionId,
+            state: dependencies.slot?.state ?? "ready",
+            effectivePermission: accepted.effectivePermission ?? permission,
+            at: accepted.acceptedAt,
+        }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
+        if (accepted.state === "running" && accepted.processStartedAt !== null) {
+            await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
+                type: "execution:started",
+                protocolVersion: 1,
+                executionId: spec.executionId,
+                at: accepted.processStartedAt,
+            }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
+        }
+        return { kind: "existing", entry: accepted };
+    }
+    await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
+        type: "execution:accepted",
+        protocolVersion: 1,
+        executionId: spec.executionId,
+        state: dependencies.slot?.state ?? "ready",
+        effectivePermission: permission,
+        at: accepted.acceptedAt,
+    }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
+    const mint = dependencies.mintAgentToken ?? mintAgentToken;
+    const execute = dependencies.executeLocal ?? executeLocal;
+    const startSupervisor = dependencies.startSupervisor ?? startDormantSupervisor;
+    const telemetry = new TelemetryQueue(dependencies.report, bestEffortTimeoutMs, positiveTelemetryLimit(dependencies.telemetryMaxPendingFrames, DEFAULT_TELEMETRY_MAX_PENDING_FRAMES), Math.max(config.executionLimits.maxEventBytes, positiveTelemetryLimit(dependencies.telemetryMaxPendingBytes, DEFAULT_TELEMETRY_MAX_PENDING_BYTES)));
+    const supervisorState = { active: null, abortOnce: null };
+    let launchClosed = false;
+    const launchAttempts = new Set();
+    const closeLaunchGate = async () => {
+        launchClosed = true;
+        await Promise.all([...launchAttempts]);
+    };
+    let startedAt = accepted.acceptedAt;
+    let timeout;
+    let timedOut = false;
+    let completion;
+    let rejectCancellationFailure;
+    const cancellationFailure = new Promise((_resolve, reject) => {
+        rejectCancellationFailure = reject;
+    });
+    try {
+        if (dependencies.slot !== undefined) {
+            await cancellable(dependencies.slot.ready, dependencies.cancellation);
+        }
+        const credential = await cancellable(mint(config.serverUrl, config.machineToken, spec.agent.handle, undefined, { executionId: spec.executionId }), dependencies.cancellation);
+        const providerConfig = launchProviderConfig(credential.config);
+        let activitySequence = 0;
+        let consoleSequence = 0;
+        const callbacks = {
+            ...(spec.reporting.streamActivity ? {
+                onActivity: (activity) => {
+                    const frame = DaemonToServerExecutionFrameSchema.parse({
+                        type: "execution:activity",
+                        protocolVersion: 1,
+                        executionId: spec.executionId,
+                        activity: ACTIVITY_KIND[activity.kind] ?? "working",
+                        detail: activity.detail ?? activity.label,
+                        seq: activitySequence++,
+                        at: now().toISOString(),
+                    });
+                    try {
+                        const bounded = boundExecutionFrame(frame, config.executionLimits.maxEventBytes);
+                        telemetry.enqueue(bounded);
+                    }
+                    catch { /* best-effort activity omitted when its envelope cannot fit */ }
+                },
+            } : {}),
+            ...(spec.reporting.streamConsole ? {
+                onConsole: (chunk) => {
+                    const frame = DaemonToServerExecutionFrameSchema.parse({
+                        type: "execution:console",
+                        protocolVersion: 1,
+                        executionId: spec.executionId,
+                        stream: chunk.stream,
+                        text: chunk.text,
+                        seq: consoleSequence++,
+                        at: now().toISOString(),
+                    });
+                    try {
+                        const bounded = boundExecutionFrame(frame, config.executionLimits.maxEventBytes);
+                        telemetry.enqueue(bounded);
+                    }
+                    catch { /* best-effort console omitted when its envelope cannot fit */ }
+                },
+            } : {}),
+        };
+        const localDependencies = {
+            launchRuntime: async (request) => {
+                if (launchClosed || dependencies.cancellation?.isRequested())
+                    throw new ExecutionCancelledError();
+                let settleLaunch;
+                const launchSettled = new Promise((resolve) => { settleLaunch = resolve; });
+                launchAttempts.add(launchSettled);
+                try {
+                    const processStartedAt = now().toISOString();
+                    const guarded = await dependencies.journal.startGuarded(spec.executionId, processStartedAt, () => startSupervisor(supervisorLaunch(request)));
+                    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;
+                    await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
+                        type: "execution:started",
+                        protocolVersion: 1,
+                        executionId: spec.executionId,
+                        at: startedAt,
+                    }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
+                    if (!dependencies.cancellation?.isRequested()) {
+                        timeout = setTimeout(() => {
+                            timedOut = true;
+                            try {
+                                void cancelOnce().catch(rejectCancellationFailure);
+                            }
+                            catch (error) {
+                                rejectCancellationFailure(error);
+                            }
+                        }, effectiveTimeoutMs);
+                    }
+                    return guarded.handle;
+                }
+                finally {
+                    launchAttempts.delete(launchSettled);
+                    settleLaunch();
+                }
+            },
+        };
+        const localInput = {
+            executionId: spec.executionId,
+            handle: spec.agent.handle,
+            channelId: spec.context.channelId,
+            keyMode: "opaque",
+            taskKey: spec.workspace.taskKey,
+            ...(spec.workspace.resumeKey === undefined ? {} : { resumeKey: spec.workspace.resumeKey }),
+            ...(spec.context.wakeMessageId === undefined ? {} : { wakeMessageId: spec.context.wakeMessageId }),
+            systemPrompt: withLocalExecutionFacts(spec.instructions.systemPrompt, config.executionLimits.maxPromptBytes
+                - Buffer.byteLength(spec.instructions.wakePrompt, "utf8")),
+            wakePrompt: spec.instructions.wakePrompt,
+            runtime: {
+                name: spec.runtime.name,
+                ...(spec.runtime.model === undefined ? {} : { model: spec.runtime.model }),
+                ...(spec.runtime.reasoning === undefined ? {} : { reasoning: spec.runtime.reasoning }),
+            },
+            effectivePermission: permission,
+            captureFinal: spec.reporting.captureFinal,
+            launch: {
+                serverUrl: config.serverUrl,
+                token: credential.token,
+                agentId: credential.agentId,
+                agentsRoot: config.agentsRoot,
+                cliPath: config.cliPath,
+                providerConfig,
+                ...(providerConfig.description ? { description: providerConfig.description } : {}),
+            },
+            session: {
+                enabled: config.resume,
+                warmMs: config.resumeWarmMs,
+                budgetTokens: config.sessionBudgetTokens,
+                softTokens: config.sessionSoftTokens,
+                maxTurns: config.sessionMaxTurns,
+            },
+        };
+        const result = await cancellable(Promise.race([
+            execute(localInput, callbacks, localDependencies),
+            cancellationFailure,
+        ]), dependencies.cancellation);
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+        const finishedAt = now().toISOString();
+        completion = ExecutionCompletedSchema.parse(timedOut ? {
+            type: "execution:completed",
+            protocolVersion: 1,
+            executionId: spec.executionId,
+            outcome: "cancelled",
+            errorCode: "timeout",
+            errorMessage: "Execution exceeded its local timeout",
+            runtime: result.runtime,
+            ...(result.model === null ? {} : { model: result.model }),
+            resumed: result.resumed,
+            startedAt,
+            finishedAt,
+        } : {
+            type: "execution:completed",
+            protocolVersion: 1,
+            executionId: spec.executionId,
+            outcome: result.exitCode === 0 ? "succeeded" : "failed",
+            exitCode: result.exitCode,
+            ...(result.terminationSignal === undefined ? {} : { terminationSignal: result.terminationSignal }),
+            ...(result.exitCode === 0 ? {} : {
+                errorCode: "runtime_failed",
+                ...(result.errorMessage ? { errorMessage: result.errorMessage } : {}),
+            }),
+            runtime: result.runtime,
+            ...(result.model === null ? {} : { model: result.model }),
+            resumed: result.resumed,
+            ...(!spec.reporting.captureFinal || result.finalText === null
+                ? {}
+                : { finalText: result.finalText }),
+            ...(result.usage === undefined ? {} : { usage: result.usage }),
+            startedAt,
+            finishedAt,
+        });
+    }
+    catch (error) {
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+        if (error instanceof ExecutionCancelledError) {
+            await closeLaunchGate();
+            await dependencies.cancellation?.waitForStop();
+        }
+        else if (supervisorState.active !== null && supervisorState.abortOnce !== null) {
+            try {
+                await supervisorState.abortOnce();
+            }
+            catch (abortError) {
+                const detail = abortError instanceof Error ? abortError.message : String(abortError);
+                throw new AggregateError([error, abortError], `Failed to stop the execution supervisor: ${detail}`);
+            }
+        }
+        completion = error instanceof ExecutionCancelledError
+            ? ExecutionCompletedSchema.parse({
+                type: "execution:completed",
+                protocolVersion: 1,
+                executionId: spec.executionId,
+                outcome: "cancelled",
+                errorCode: "cancelled",
+                errorMessage: "Execution cancelled by server request",
+                runtime: spec.runtime.name,
+                ...(spec.runtime.model === undefined ? {} : { model: spec.runtime.model }),
+                resumed: false,
+                startedAt,
+                finishedAt: now().toISOString(),
+            })
+            : failedCompletion(spec, error, startedAt, now().toISOString());
+    }
+    completion = boundExecutionFrame(completion, config.executionLimits.maxEventBytes);
+    await telemetry.closeAndDrain();
+    await dependencies.journal.complete(spec.executionId, completion);
+    await dependencies.report(completion);
+    return { kind: "completed", frame: completion };
+}