@nowcrew/daemon 0.5.26 → 0.5.28

package/dist/execution-runner.js

@@ -1,659 +0,0 @@
-import { createHash } from "node:crypto";
-import { join } from "node:path";
-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 { 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",
-    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, () => false),
-            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 rejection(executionId, reason, message, at) {
-    return ExecutionRejectedSchema.parse({
-        type: "execution:rejected",
-        protocolVersion: 1,
-        executionId,
-        reason,
-        message,
-        at,
-    });
-}
-function admission(spec, config, dependencies, at) {
-    const backend = executionBackendCapability(dependencies.platform ?? process.platform);
-    if (!backend.supported) {
-        return { rejected: rejection(spec.executionId, "capability_missing", backend.reason, 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 readBoundImDecision = dependencies.readBoundImDecision ?? readBoundImDecisionFile;
-    const resetBoundImDecision = dependencies.resetBoundImDecision ?? resetBoundImDecisionFile;
-    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 boundImDecision = spec.reporting.allowBoundImDecision
-        ? "silent"
-        : undefined;
-    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, agentRunId: spec.executionId }), dependencies.cancellation);
-        const providerConfig = launchProviderConfig(credential.config);
-        let activitySequence = 0;
-        let consoleSequence = 0;
-        let externalOutputSequence = 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,
-                        ...(chunk.payload ? { payload: chunk.payload } : {}),
-                        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 */ }
-                },
-            } : {}),
-            ...(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();
-                let settleLaunch;
-                const launchSettled = new Promise((resolve) => { settleLaunch = resolve; });
-                launchAttempts.add(launchSettled);
-                try {
-                    const processStartedAt = now().toISOString();
-                    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`);
-                    }
-                    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,
-                        executionId: spec.executionId,
-                        at: startedAt,
-                    }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
-                    if (!dependencies.cancellation?.isRequested()) {
-                        timeout = setTimeout(() => {
-                            timedOut = true;
-                            try {
-                                void installedCancel().catch(rejectCancellationFailure);
-                            }
-                            catch (error) {
-                                rejectCancellationFailure(error);
-                            }
-                        }, effectiveTimeoutMs);
-                    }
-                    return { ...guarded.handle, cancel: installedCancel };
-                }
-                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 }),
-            ...(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,
-            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 } : {}),
-                ...(spec.reporting.allowBoundImDecision ? {
-                    systemEnv: {
-                        CREW_BOUND_IM_DECISION_FILE: `.bound-im-decision-${spec.executionId}.json`,
-                    },
-                } : {}),
-            },
-            session: {
-                enabled: config.resume,
-                warmMs: config.resumeWarmMs,
-                budgetTokens: config.sessionBudgetTokens,
-                softTokens: config.sessionSoftTokens,
-                maxTurns: config.sessionMaxTurns,
-            },
-        };
-        const result = await Promise.race([
-            execute(localInput, callbacks, localDependencies),
-            cancellationFailure,
-        ]);
-        if (timeout !== undefined)
-            clearTimeout(timeout);
-        const finishedAt = now().toISOString();
-        if (spec.reporting.allowBoundImDecision) {
-            const path = join(result.workspaceRunDir, `.bound-im-decision-${spec.executionId}.json`);
-            const selected = await readBoundImDecision(path);
-            await resetBoundImDecision(path);
-            boundImDecision = selected?.decision ?? "silent";
-        }
-        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,
-            ...(boundImDecision ? { boundImDecision } : {}),
-            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,
-            ...(boundImDecision ? { boundImDecision } : {}),
-            ...(!spec.reporting.captureFinal || result.finalText === null
-                ? {}
-                : { finalText: result.finalText }),
-            // externalAnswer 是本轮完成的权威结果,与 answerStream(增量流式的可选增强)解耦转发;
-            // 否则能力协商降级后模型仍可能沿用同线程记住的 marker 契约,回复却永远发不到频道
-            // (incident: 2026-07-30, 2026-08-03)。
-            ...(result.exitCode === 0 && result.externalAnswer
-                ? { externalAnswer: result.externalAnswer }
-                : {}),
-            ...(result.usage === undefined ? {} : { usage: result.usage }),
-            startedAt,
-            finishedAt,
-        });
-    }
-    catch (error) {
-        if (timeout !== undefined)
-            clearTimeout(timeout);
-        const cancelled = error instanceof ExecutionCancelledError || error instanceof RuntimeCancelledError;
-        if (cancelled) {
-            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 = cancelled
-            ? 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 };
-}