@astrosheep/keiyaku 0.1.87 → 1.0.0

package/build/agents/harness/index.js

@@ -0,0 +1,622 @@
+import { randomUUID } from "node:crypto";
+import { FlowError } from "../../flow-error.js";
+import { StringTailBuffer } from "../string-tail-buffer.js";
+import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../session.js";
+import { startClaudeAgentSdk, claudeSessionSchema, } from "../providers/claude-agent-sdk.js";
+import { startCodexAppServer, codexAppServerSessionSchema, } from "../providers/codex-app-server.js";
+import { startCodexSdk, codexThreadSchema, } from "../providers/codex-sdk.js";
+import { startOpencode, opencodeSessionSchema, } from "../providers/opencode-sdk.js";
+import { startPi, piSessionSchema, } from "../providers/pi.js";
+import { SubagentFailure, } from "../types.js";
+import { createEventChannel } from "./event-channel.js";
+import { buildSyncCheckpointCallback, createReplayRunStartGate, markReplayCompleted, pumpSupervisor, snapshotReplayPrompt } from "./pump.js";
+import { createAbortError, renderCapturedText } from "./runtime.js";
+import { acquireAdmissionLock, createProjectionExecutionId, demoteSubmittedTellsForReplay, generationResultPath, listTellIds, markTellSubmitted, publishGenerationResult, publishVerdict, readAdmissionLock, readGenerationLaunch, releaseAdmissionLockOwned, touchHeartbeat } from "../../core/projection-core.js";
+import { wakeProjection } from "../../core/projection-wake.js";
+export function summon(terms) {
+    return createProjection(terms);
+}
+export function resume(terms) {
+    return createProjection(terms, terms);
+}
+function mintOutcome(draft) {
+    return draft;
+}
+function effectivePolicyFor(shared) {
+    return shared.terms.provider === "codex-sdk" ? shared.terms.effectivePolicy : undefined;
+}
+function createProjection(terms, resumeTerms) {
+    switch (terms.provider) {
+        case "pi":
+        case "claude-agent-sdk":
+        case "codex-app-server":
+            return createSteerableProjection(terms, resumeTerms);
+        case "codex-sdk":
+        case "opencode-sdk":
+            return createReplayProjection(terms, resumeTerms);
+        default:
+            return assertNever(terms);
+    }
+}
+function createSteerableProjection(terms, resumeTerms) {
+    const shared = createProjectionState(terms, resumeTerms);
+    const pendingTells = [];
+    let flushActive = false;
+    const flushPendingTells = async () => {
+        const initialEnqueue = shared.live?.enqueue;
+        if (flushActive || shared.terminal || !initialEnqueue)
+            return;
+        flushActive = true;
+        try {
+            while (!shared.terminal && pendingTells.length > 0) {
+                const enqueue = shared.live?.enqueue;
+                if (!enqueue)
+                    break;
+                const nextTell = pendingTells.shift();
+                if (!nextTell)
+                    break;
+                await enqueue(nextTell);
+            }
+        }
+        finally {
+            flushActive = false;
+            if (!shared.terminal && pendingTells.length > 0 && shared.live?.enqueue) {
+                void flushPendingTells();
+            }
+        }
+    };
+    shared.onLive = (live) => {
+        shared.live = live;
+        void flushPendingTells();
+    };
+    const outcome = settleProjection(shared).then((value) => finalizeProjectionLedger(shared, value));
+    return {
+        mode: "steerable",
+        get id() {
+            return shared.id;
+        },
+        get events() {
+            return shared.publicEvents.iterable;
+        },
+        get outcome() {
+            return outcome;
+        },
+        tell(tell) {
+            if (shared.terminal)
+                return;
+            pendingTells.push(tell);
+            void flushPendingTells();
+        },
+        recallTells() {
+            return pendingTells.splice(0, pendingTells.length);
+        },
+        dismiss() {
+            dismissProjection(shared);
+        },
+    };
+}
+function createReplayProjection(terms, resumeTerms) {
+    const shared = createProjectionState(terms, resumeTerms);
+    shared.onLive = (live) => {
+        shared.live = live;
+    };
+    const outcome = settleProjection(shared).then((value) => finalizeProjectionLedger(shared, value));
+    return {
+        mode: "replay",
+        get id() {
+            return shared.id;
+        },
+        get events() {
+            return shared.publicEvents.iterable;
+        },
+        get outcome() {
+            return outcome;
+        },
+        dismiss() {
+            dismissProjection(shared);
+        },
+    };
+}
+function createProjectionState(terms, resumeTerms) {
+    const shared = {
+        id: randomUUID(),
+        terms,
+        resumeTerms,
+        publicEvents: createEventChannel(),
+        lifecycleAbort: new AbortController(),
+        dismissed: false,
+        externallyAborted: false,
+        terminal: false,
+        onLive() { },
+    };
+    if (terms.signal) {
+        const listener = () => {
+            shared.externallyAborted = true;
+            if (!shared.lifecycleAbort.signal.aborted) {
+                shared.lifecycleAbort.abort(terms.signal?.reason);
+            }
+        };
+        terms.signal.addEventListener("abort", listener, { once: true });
+        if (terms.signal.aborted) {
+            listener();
+        }
+    }
+    return shared;
+}
+function finalizeProjectionLedger(shared, outcome) {
+    const directory = shared.terms.projectionDir;
+    const executionId = shared.terms.projectionExecutionId;
+    if (!directory || !executionId)
+        return outcome;
+    const now = Date.now();
+    publishGenerationResult(directory, {
+        version: 1,
+        executionId,
+        status: outcome.status,
+        createdAt: new Date(now).toISOString(),
+        session: outcome.session,
+        responsePath: generationResultPath(directory, executionId),
+        detail: outcome.status === "failed" ? outcome.error?.message : undefined,
+    });
+    // A stale/duplicate child must never replace a later generation's verdict.
+    if (readAdmissionLock(directory)?.executionId !== executionId)
+        return outcome;
+    const pending = ["inbox", "inflight", "submitted"].some((layer) => listTellIds(directory, layer).length > 0);
+    if (pending && outcome.status === "completed") {
+        // The resume lock is acquired by the one wake orchestrator before it releases
+        // this generation's admission; a crash leaves result-without-done for self-heal.
+        wakeProjection(directory, "sweep-wake", { handoffExecutionId: executionId });
+        return outcome;
+    }
+    publishVerdict(directory, outcome.status === "completed" ? "done" : outcome.status === "dismissed" ? "dismissed" : "failed", now, outcome.status === "failed" ? outcome.error?.message : undefined);
+    releaseAdmissionLockOwned(directory, executionId);
+    if (listTellIds(directory, "inbox").length > 0)
+        wakeProjection(directory, "sweep-wake");
+    return outcome;
+}
+function dismissProjection(shared) {
+    if (shared.dismissed || shared.terminal)
+        return;
+    shared.dismissed = true;
+    if (!shared.lifecycleAbort.signal.aborted) {
+        shared.lifecycleAbort.abort(createAbortError(`${shared.terms.provider} exec dismissed`));
+    }
+    requestAbort(shared.live);
+}
+function requestAbort(live) {
+    if (!live)
+        return;
+    void Promise.resolve()
+        .then(() => live.abort())
+        .catch(() => undefined);
+}
+async function settleProjection(shared) {
+    const state = {
+        outputBuffer: new StringTailBuffer(shared.terms.maxCaptureChars),
+        diagnosticsBuffer: new StringTailBuffer(shared.terms.maxCaptureChars),
+        warnings: [],
+    };
+    let timedOut = false;
+    let idleTimedOut = false;
+    let abortRequested = false;
+    const timeout = setTimeout(() => {
+        timedOut = true;
+        shared.lifecycleAbort.abort(createAbortError(`${shared.terms.provider} exec timed out`));
+    }, shared.terms.timeoutMs);
+    timeout.unref?.();
+    let idleTimeout;
+    const refreshIdleTimeout = () => {
+        if (idleTimeout)
+            clearTimeout(idleTimeout);
+        idleTimeout = setTimeout(() => {
+            idleTimedOut = true;
+            shared.lifecycleAbort.abort(createAbortError(`${shared.terms.provider} exec idle timed out`));
+        }, shared.terms.idleTimeoutMs);
+        idleTimeout.unref?.();
+    };
+    refreshIdleTimeout();
+    const requestLiveAbort = () => {
+        if (abortRequested)
+            return;
+        abortRequested = true;
+        requestAbort(shared.live);
+    };
+    shared.lifecycleAbort.signal.addEventListener("abort", requestLiveAbort, { once: true });
+    try {
+        if (shared.terms.projectionDir) {
+            const executionId = shared.terms.projectionExecutionId ?? createProjectionExecutionId();
+            const acquired = acquireAdmissionLock(shared.terms.projectionDir, process.pid, Date.now(), executionId);
+            if (acquired === "taken")
+                throw new FlowError("INTERNAL_STATE", "projection already has an active generation");
+            touchHeartbeat(shared.terms.projectionDir, Date.now());
+            demoteSubmittedTellsForReplay(shared.terms.projectionDir, executionId);
+        }
+        const launchTellFence = shared.terms.projectionDir && shared.terms.projectionExecutionId
+            ? readGenerationLaunch(shared.terms.projectionDir, shared.terms.projectionExecutionId).inputs.tellFence
+            : undefined;
+        const tellFence = launchTellFence === undefined
+            ? []
+            : Array.isArray(launchTellFence) && launchTellFence.every((tellId) => typeof tellId === "string")
+                ? launchTellFence
+                : (() => { throw new FlowError("INTERNAL_STATE", "generation launch has an invalid tellFence"); })();
+        const launchSnapshot = shared.terms.projectionDir && shared.terms.projectionExecutionId
+            ? snapshotReplayPrompt(shared.terms.projectionDir, shared.terms.prompt, tellFence, shared.terms.projectionExecutionId)
+            : undefined;
+        const launchTerms = launchSnapshot
+            ? shared.terms.provider === "codex-sdk" && launchSnapshot.effort
+                ? { ...shared.terms, prompt: launchSnapshot.prompt, threadOptions: { ...shared.terms.threadOptions, modelReasoningEffort: launchSnapshot.effort === "max" ? "xhigh" : launchSnapshot.effort } }
+                : { ...shared.terms, prompt: launchSnapshot.prompt }
+            : shared.terms;
+        const live = await startLiveProjection(launchTerms, shared.lifecycleAbort.signal, shared.resumeTerms, launchSnapshot?.tellIds);
+        // A constructed driver is not an SDK run acknowledgement. Tier-2 has no
+        // live steer surface, so the first provider event is the earliest harness
+        // observable start; a successful no-event completion is the only fallback.
+        const replayStartGate = launchSnapshot && shared.terms.provider !== "codex-app-server" && shared.terms.projectionDir && shared.terms.projectionExecutionId
+            ? createReplayRunStartGate(shared.terms.projectionDir, shared.terms.projectionExecutionId, launchSnapshot.tellIds)
+            : undefined;
+        shared.onLive(live);
+        if (shared.lifecycleAbort.signal.aborted) {
+            requestLiveAbort();
+        }
+        const projectionDir = shared.terms.projectionDir;
+        if (projectionDir) {
+            // Supervisor mode: pump with heartbeat, checkpoint, claim inbox, deliver tells.
+            await pumpSupervisor(live, projectionDir, shared.publicEvents, (event) => {
+                replayStartGate?.observeProviderEvent();
+                refreshIdleTimeout();
+                processEvent(state, event);
+            });
+        }
+        else {
+            // Legacy mode: direct event loop without supervisor pump.
+            for await (const event of live.events) {
+                replayStartGate?.observeProviderEvent();
+                shared.publicEvents.push(event);
+                refreshIdleTimeout();
+                processEvent(state, event);
+            }
+        }
+        const completionResult = await live.completion.then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+        const completionOutcome = completionResult.ok ? completionResult.value : undefined;
+        if (state.failEvent) {
+            return failFromFailEvent(shared, state, state.failEvent);
+        }
+        if (!completionResult.ok) {
+            return classifyFailure(shared, state, completionResult.error, timedOut, idleTimedOut);
+        }
+        if (shared.lifecycleAbort.signal.aborted) {
+            return classifyFailure(shared, state, shared.lifecycleAbort.signal.reason, timedOut, idleTimedOut);
+        }
+        if (!state.doneEvent && !completionOutcome) {
+            return failWithError(shared, state, {
+                code: "SUBAGENT_EXEC_ERROR",
+                message: `${shared.terms.provider} exec ended before completion`,
+                timeoutMs: shared.terms.timeoutMs,
+                exitCode: null,
+            }, state.finalMessageCandidate);
+        }
+        const finalMessage = state.doneEvent?.finalMessage ??
+            completionOutcome?.finalMessage ??
+            state.finalMessageCandidate ??
+            renderCapturedText(state.outputBuffer).trim();
+        const session = state.doneEvent?.session ?? completionOutcome?.session;
+        if (!session) {
+            return failWithError(shared, state, {
+                code: "SUBAGENT_EXEC_ERROR",
+                message: `${shared.terms.provider} exec ended without a session handle`,
+                timeoutMs: shared.terms.timeoutMs,
+                exitCode: null,
+            }, finalMessage);
+        }
+        // A provider may complete successfully without emitting any observable
+        // events. Its successful completion is still a real run start.
+        replayStartGate?.observeSuccessfulCompletion();
+        if (launchSnapshot && shared.terms.projectionDir && shared.terms.projectionExecutionId) {
+            markReplayCompleted(shared.terms.projectionDir, shared.terms.projectionExecutionId);
+        }
+        return mintOutcome({
+            status: "completed",
+            finalMessage,
+            output: renderCapturedText(state.outputBuffer),
+            diagnostics: renderCapturedText(state.diagnosticsBuffer),
+            session,
+            warnings: [...state.warnings],
+            ...(effectivePolicyFor(shared) ? { effectivePolicy: effectivePolicyFor(shared) } : {}),
+        });
+    }
+    catch (error) {
+        if (error instanceof FlowError) {
+            throw error;
+        }
+        return classifyFailure(shared, state, error, timedOut, idleTimedOut);
+    }
+    finally {
+        clearTimeout(timeout);
+        if (idleTimeout)
+            clearTimeout(idleTimeout);
+        shared.lifecycleAbort.signal.removeEventListener("abort", requestLiveAbort);
+        shared.terminal = true;
+        shared.publicEvents.close();
+    }
+}
+function processEvent(state, event) {
+    switch (event.type) {
+        case "output":
+            state.outputBuffer.append(`${JSON.stringify(event.value)}\n`);
+            return;
+        case "diagnostic":
+            state.diagnosticsBuffer.append(event.text);
+            return;
+        case "message":
+            state.finalMessageCandidate = event.text;
+            return;
+        case "warning":
+            state.warnings.push(event.warning);
+            return;
+        case "done":
+            state.doneEvent = event;
+            state.session = event.session;
+            if (event.finalMessage !== undefined) {
+                state.finalMessageCandidate = event.finalMessage;
+            }
+            return;
+        case "fail":
+            state.failEvent = event;
+            if (event.diagnostics) {
+                state.diagnosticsBuffer.append(event.diagnostics);
+            }
+            return;
+    }
+}
+function failFromFailEvent(shared, state, failEvent) {
+    const code = failEvent.code === "PROJECTION_STATE_ERROR" || failEvent.code === undefined
+        ? "SUBAGENT_EXEC_ERROR"
+        : failEvent.code;
+    const diagnostics = failEvent.code === "PROJECTION_STATE_ERROR"
+        ? [renderCapturedText(state.diagnosticsBuffer), "PROJECTION_STATE_ERROR"].filter(Boolean).join("\n")
+        : renderCapturedText(state.diagnosticsBuffer);
+    return failWithError(shared, state, {
+        code,
+        message: failEvent.message,
+        timeoutMs: shared.terms.timeoutMs,
+        exitCode: failEvent.exitCode ?? null,
+    }, state.finalMessageCandidate, failEvent.diagnostics ?? diagnostics);
+}
+function classifyFailure(shared, state, error, timedOut, idleTimedOut) {
+    if (shared.dismissed || shared.externallyAborted) {
+        return mintOutcome({
+            status: "dismissed",
+            finalMessage: state.finalMessageCandidate ?? "",
+            output: renderCapturedText(state.outputBuffer),
+            diagnostics: renderCapturedText(state.diagnosticsBuffer),
+            session: state.session ?? fallbackSession(shared),
+            warnings: [...state.warnings],
+            ...(effectivePolicyFor(shared) ? { effectivePolicy: effectivePolicyFor(shared) } : {}),
+        });
+    }
+    if (timedOut) {
+        return failWithError(shared, state, {
+            code: "SUBAGENT_TIMEOUT",
+            message: `${shared.terms.provider} exec timed out`,
+            timeoutMs: shared.terms.timeoutMs,
+            exitCode: null,
+        }, state.finalMessageCandidate);
+    }
+    if (idleTimedOut) {
+        return failWithError(shared, state, {
+            code: "SUBAGENT_TIMEOUT",
+            message: `${shared.terms.provider} exec idle timed out`,
+            timeoutMs: shared.terms.idleTimeoutMs,
+            exitCode: null,
+        }, state.finalMessageCandidate);
+    }
+    if (error instanceof SubagentFailure) {
+        return failWithError(shared, state, {
+            code: error.code,
+            message: error.message,
+            timeoutMs: error.timeoutMs,
+            exitCode: error.exitCode,
+        }, state.finalMessageCandidate ?? error.message, error.diagnostics || renderCapturedText(state.diagnosticsBuffer), error.output || renderCapturedText(state.outputBuffer));
+    }
+    const message = error instanceof Error ? error.message : `Unknown ${shared.terms.provider} exec error`;
+    appendThrownMessage(state.diagnosticsBuffer, message);
+    return failWithError(shared, state, {
+        code: "SUBAGENT_EXEC_ERROR",
+        message,
+        timeoutMs: null,
+        exitCode: null,
+    }, state.finalMessageCandidate ?? message);
+}
+function failWithError(shared, state, error, finalMessage, diagnostics = renderCapturedText(state.diagnosticsBuffer), output = renderCapturedText(state.outputBuffer)) {
+    return mintOutcome({
+        status: "failed",
+        error,
+        finalMessage: finalMessage ?? error.message,
+        output,
+        diagnostics,
+        session: state.session ?? fallbackSession(shared),
+        warnings: [...state.warnings],
+        ...(effectivePolicyFor(shared) ? { effectivePolicy: effectivePolicyFor(shared) } : {}),
+    });
+}
+function fallbackSession(shared) {
+    return shared.resumeTerms?.session ?? {
+        provider: shared.terms.provider,
+        version: SUBAGENT_SESSION_VERSION,
+        handle: null,
+    };
+}
+function appendThrownMessage(buffer, message) {
+    if (message.length === 0)
+        return;
+    const snapshot = buffer.snapshot().text;
+    if (snapshot.length > 0 && !snapshot.endsWith("\n")) {
+        buffer.append("\n");
+    }
+    buffer.append(message);
+}
+function admitResumeShape(provider, schema, session, resumePath) {
+    const envelopeResult = subagentSessionEnvelopeSchema.safeParse(session);
+    if (!envelopeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session envelope.`);
+    }
+    if (session.provider !== provider) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${provider}'. Cross-provider resume is not supported.`);
+    }
+    if (session.version !== SUBAGENT_SESSION_VERSION) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' uses unsupported session version '${session.version}' for provider '${session.provider}'.`);
+    }
+    const shapeResult = schema.safeParse(session.handle);
+    if (!shapeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session handle for provider '${session.provider}'.`);
+    }
+    return shapeResult.data;
+}
+async function startLiveProjection(terms, signal, resumeTerms, initialTellIds = []) {
+    const projectionCheckpoint = terms.projectionDir ? buildSyncCheckpointCallback(terms.projectionDir) : undefined;
+    let appServerInitialFencePending = terms.provider === "codex-app-server" && initialTellIds.length > 0;
+    const onSyncCheckpoint = terms.projectionDir
+        ? (control, checkpoint) => {
+            if (appServerInitialFencePending && terms.projectionExecutionId) {
+                for (const tellId of initialTellIds) {
+                    if (listTellIds(terms.projectionDir, "inflight").includes(tellId)) {
+                        markTellSubmitted(terms.projectionDir, tellId, { executionId: terms.projectionExecutionId, fence: checkpoint.fence });
+                    }
+                }
+                appServerInitialFencePending = false;
+                return;
+            }
+            projectionCheckpoint?.(control, checkpoint);
+        }
+        : "onCheckpoint" in terms
+            ? terms.onCheckpoint
+            : undefined;
+    switch (terms.provider) {
+        case "pi": {
+            if (resumeTerms) {
+                const session = admitResumeShape("pi", piSessionSchema, resumeTerms.session, resumeTerms.resumePath);
+                return startPi(terms.prompt, terms.workdir, {
+                    model: terms.model,
+                    thinkingLevel: terms.thinkingLevel,
+                    signal,
+                    sessionFile: session.sessionFile,
+                    appendSystemPromptOverride: terms.appendSystemPromptOverride,
+                    onSyncCheckpoint,
+                    onEvidence: terms.onEvidence,
+                });
+            }
+            return startPi(terms.prompt, terms.workdir, {
+                model: terms.model,
+                thinkingLevel: terms.thinkingLevel,
+                signal,
+                appendSystemPromptOverride: terms.appendSystemPromptOverride,
+                onSyncCheckpoint,
+                onEvidence: terms.onEvidence,
+            });
+        }
+        case "claude-agent-sdk": {
+            if (resumeTerms) {
+                const session = admitResumeShape("claude-agent-sdk", claudeSessionSchema, resumeTerms.session, resumeTerms.resumePath);
+                return startClaudeAgentSdk(terms.prompt, terms.workdir, {
+                    model: terms.model,
+                    executable: terms.executable,
+                    effort: terms.effort,
+                    signal,
+                    permissionMode: terms.permissionMode,
+                    settingSources: terms.settingSources,
+                    systemPrompt: terms.systemPrompt,
+                    sessionId: session.sessionId,
+                    onSyncCheckpoint,
+                    onEvidence: terms.onEvidence,
+                });
+            }
+            return startClaudeAgentSdk(terms.prompt, terms.workdir, {
+                model: terms.model,
+                executable: terms.executable,
+                effort: terms.effort,
+                signal,
+                permissionMode: terms.permissionMode,
+                settingSources: terms.settingSources,
+                systemPrompt: terms.systemPrompt,
+                onSyncCheckpoint,
+                onEvidence: terms.onEvidence,
+            });
+        }
+        case "codex-app-server": {
+            if (resumeTerms) {
+                const session = admitResumeShape("codex-app-server", codexAppServerSessionSchema, resumeTerms.session, resumeTerms.resumePath);
+                return startCodexAppServer(terms.prompt, terms.workdir, {
+                    model: terms.model,
+                    effort: terms.effort,
+                    profile: terms.profile,
+                    config: terms.config,
+                    executable: terms.executable,
+                    signal,
+                    threadId: session.threadId,
+                    codexHome: session.codexHome,
+                    developerInstructions: terms.developerInstructions,
+                    onSyncCheckpoint,
+                    onEvidence: terms.onEvidence,
+                });
+            }
+            return startCodexAppServer(terms.prompt, terms.workdir, {
+                model: terms.model,
+                effort: terms.effort,
+                profile: terms.profile,
+                config: terms.config,
+                executable: terms.executable,
+                signal,
+                developerInstructions: terms.developerInstructions,
+                onSyncCheckpoint,
+                onEvidence: terms.onEvidence,
+            });
+        }
+        case "codex-sdk": {
+            if (resumeTerms) {
+                const session = admitResumeShape("codex-sdk", codexThreadSchema, resumeTerms.session, resumeTerms.resumePath);
+                return startCodexSdk(terms.prompt, terms.workdir, {
+                    model: terms.model,
+                    profile: terms.profile,
+                    config: terms.config,
+                    threadOptions: terms.threadOptions,
+                    executable: terms.executable,
+                    signal,
+                    threadId: session.threadId,
+                    onEvidence: terms.onEvidence,
+                });
+            }
+            return startCodexSdk(terms.prompt, terms.workdir, {
+                model: terms.model,
+                profile: terms.profile,
+                config: terms.config,
+                threadOptions: terms.threadOptions,
+                executable: terms.executable,
+                signal,
+                onEvidence: terms.onEvidence,
+            });
+        }
+        case "opencode-sdk": {
+            if (resumeTerms) {
+                const session = admitResumeShape("opencode-sdk", opencodeSessionSchema, resumeTerms.session, resumeTerms.resumePath);
+                return startOpencode(terms.prompt, terms.workdir, {
+                    model: terms.model,
+                    executable: terms.executable,
+                    signal,
+                    sessionId: session.sessionId,
+                    onEvidence: terms.onEvidence,
+                });
+            }
+            return startOpencode(terms.prompt, terms.workdir, {
+                model: terms.model,
+                executable: terms.executable,
+                signal,
+                onEvidence: terms.onEvidence,
+            });
+        }
+        default:
+            return assertNever(terms);
+    }
+}
+function assertNever(_value) {
+    throw new Error("Unhandled provider");
+}