@nowcrew/daemon 0.5.45 → 0.5.46

package/dist/runtime-capabilities.js

@@ -1,4 +1,4 @@
-export const LOCAL_EXECUTION_RUNTIMES = ["claude", "codex", "kimi"];
+export const LOCAL_EXECUTION_RUNTIMES = ["claude", "codex", "kimi", "hermes", "opencode"];
 export const LOCAL_RUNTIME_CAPABILITIES = Object.freeze({
     claude: Object.freeze({
         transport: "claude-stream-json",
@@ -15,6 +15,16 @@ export const LOCAL_RUNTIME_CAPABILITIES = Object.freeze({
         nativeResume: true,
         systemPromptTransport: "protocol",
     }),
+    hermes: Object.freeze({
+        transport: "hermes-acp",
+        nativeResume: true,
+        systemPromptTransport: "file",
+    }),
+    opencode: Object.freeze({
+        transport: "opencode-json",
+        nativeResume: true,
+        systemPromptTransport: "file",
+    }),
 });
 export function runtimeCapability(runtime) {
     return LOCAL_RUNTIME_CAPABILITIES[runtime];

package/dist/runtime-probe.js

@@ -0,0 +1,26 @@
+import { executableRuntimes } from "./runtime-capabilities.js";
+export function conservativeExecutionRuntimes(installed) {
+    return executableRuntimes(installed)
+        .filter((runtime) => runtime === "claude" || runtime === "codex");
+}
+export function createRuntimeProbeCoordinator() {
+    const abort = new AbortController();
+    const flights = new Map();
+    return {
+        detect(installed, detector) {
+            const key = [...installed].sort().join("\0");
+            const existing = flights.get(key);
+            if (existing)
+                return existing;
+            const pending = detector(installed, abort.signal).catch((error) => {
+                flights.delete(key);
+                throw error;
+            });
+            flights.set(key, pending);
+            return pending;
+        },
+        stop() {
+            abort.abort();
+        },
+    };
+}

package/dist/runtime-startup-gate.js

@@ -77,6 +77,8 @@ export function createRuntimeStartupGate(limits, now = Date.now) {
                 claude: activeByRuntime.get("claude") ?? 0,
                 codex: activeByRuntime.get("codex") ?? 0,
                 kimi: activeByRuntime.get("kimi") ?? 0,
+                hermes: activeByRuntime.get("hermes") ?? 0,
+                opencode: activeByRuntime.get("opencode") ?? 0,
             },
         }),
     };

package/dist/runtimes/codex-app-server-runner.js

@@ -193,10 +193,20 @@ export function mapCodexNotification(method, params) {
                     type: "command_execution",
                     command: value.item.command,
                     ...(value.item.status === undefined ? {} : { status: value.item.status }),
+                    ...(typeof value.item.exitCode === "number" ? { exit_code: value.item.exitCode } : {}),
                     ...(value.item.aggregatedOutput == null ? {} : { aggregated_output: value.item.aggregatedOutput }),
                 },
             }];
     }
+    if (value.item.type === "fileChange" && Array.isArray(value.item.changes)) {
+        return [{
+                type: "diagnostic.file_change",
+                ...(value.item.status === undefined ? {} : { status: value.item.status }),
+                changes: value.item.changes.flatMap((change) => typeof change.path === "string"
+                    ? [{ path: change.path, ...(change.kind === undefined ? {} : { kind: change.kind }) }]
+                    : []),
+            }];
+    }
     return [];
 }
 async function readRunnerInput() {

package/dist/runtimes/hermes-models.js

@@ -0,0 +1,117 @@
+import { once } from "node:events";
+import { Readable, Writable } from "node:stream";
+import spawn from "cross-spawn";
+import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
+import { augmentedPath } from "../runtime-path.js";
+const HERMES_MODEL_PROBE_TIMEOUT_MS = 8_000;
+function nonEmptyString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function selectOptions(options, category) {
+    const aliases = category === "model"
+        ? new Set(["model"])
+        : new Set(["reasoning", "effort", "thought level", "thinking level"]);
+    const matches = (options ?? []).filter((option) => (option.type === "select" && (option.category === category
+        || aliases.has(option.id.toLowerCase())
+        || aliases.has(option.name.toLowerCase()))));
+    if (matches.length !== 1)
+        return null;
+    const match = matches[0];
+    const values = match.options.flatMap((option) => "options" in option ? option.options : [option]);
+    return {
+        current: nonEmptyString(match.currentValue),
+        values: values.map((option) => ({ modelId: option.value, name: option.name })),
+    };
+}
+export function normalizeHermesModels(session) {
+    const modelConfig = selectOptions(session.configOptions, "model");
+    const effortConfig = selectOptions(session.configOptions, "thought_level");
+    const extension = session.models;
+    const rows = extension?.availableModels ?? extension?.available_models ?? modelConfig?.values ?? [];
+    const current = nonEmptyString(extension?.currentModelId)
+        ?? nonEmptyString(extension?.current_model_id)
+        ?? modelConfig?.current
+        ?? null;
+    const reasoning = [...new Set((effortConfig?.values ?? [])
+            .map((option) => nonEmptyString(option.modelId ?? option.model_id ?? option.id))
+            .filter((value) => value !== null))];
+    const seen = new Set();
+    return rows.flatMap((row) => {
+        const id = nonEmptyString(row.modelId ?? row.model_id ?? row.id);
+        if (id === null || seen.has(id))
+            return [];
+        seen.add(id);
+        return [{
+                id,
+                label: nonEmptyString(row.name) ?? id,
+                ...(id === current ? { default: true } : {}),
+                ...(reasoning.length > 0 ? { reasoning } : {}),
+            }];
+    });
+}
+async function stopChild(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    const closed = once(child, "close").then(() => undefined);
+    child.kill("SIGTERM");
+    let timer;
+    const graceful = await Promise.race([
+        closed.then(() => true),
+        new Promise((resolve) => { timer = setTimeout(() => resolve(false), 1_000); }),
+    ]);
+    if (timer !== undefined)
+        clearTimeout(timer);
+    if (!graceful && child.exitCode === null && child.signalCode === null) {
+        child.kill("SIGKILL");
+        await closed;
+    }
+}
+export async function listHermesModels(options = {}) {
+    const spawnProcess = options.spawnProcess ?? spawn;
+    const child = spawnProcess("hermes", ["acp"], {
+        cwd: process.cwd(),
+        env: { ...process.env, PATH: augmentedPath() },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (child.stdin === null || child.stdout === null || child.stderr === null)
+        return [];
+    child.stderr.resume();
+    const app = client({ name: "nowcrew-daemon-hermes-models" })
+        .onRequest(methods.client.session.requestPermission, () => ({
+        outcome: { outcome: "cancelled" },
+    }))
+        .onNotification(methods.client.session.update, () => undefined);
+    let timer;
+    try {
+        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const discovery = app.connectWith(stream, async (context) => {
+            await context.request(methods.agent.initialize, {
+                protocolVersion: PROTOCOL_VERSION,
+                clientCapabilities: {},
+                clientInfo: { name: "nowcrew-daemon", version: "1" },
+            });
+            const session = await context.request(methods.agent.session.new, {
+                cwd: process.cwd(),
+                mcpServers: [],
+            });
+            return normalizeHermesModels(session);
+        });
+        return await Promise.race([
+            discovery,
+            new Promise((resolve) => {
+                timer = setTimeout(() => {
+                    void stopChild(child);
+                    resolve([]);
+                }, HERMES_MODEL_PROBE_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        await stopChild(child);
+    }
+}

package/dist/runtimes/hermes.js

@@ -0,0 +1,6 @@
+import spawn from "cross-spawn";
+import { probeKimiAcp } from "./kimi-acp-runner.js";
+/** Hermes and Kimi expose the same ACP initialize contract; execution policy stays provider-specific. */
+export function probeHermesAcp(options, spawnProcess = spawn) {
+    return probeKimiAcp({ ...options, provider: "hermes" }, spawnProcess);
+}

package/dist/runtimes/kimi-acp-runner.js

@@ -3,7 +3,7 @@ import { parseArgs } from "node:util";
 import { Readable, Writable } from "node:stream";
 import { pathToFileURL } from "node:url";
 import spawn from "cross-spawn";
-import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
+import { PROTOCOL_VERSION, RequestError, client, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
 import { augmentedPath } from "../runtime-path.js";
 import { startFirstProgressWatchdog } from "./progress-watchdog.js";
 import { assertKimiLegacyPromptFits, buildKimiArgs } from "./kimi.js";
@@ -33,13 +33,13 @@ function textContent(content) {
     }).join("\n");
 }
 /** Translate stable ACP updates into daemon-owned NDJSON, without exposing thought chunks. */
-export function mapKimiAcpUpdate(update) {
+export function mapAcpUpdate(provider, update) {
     if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
-        return [{ type: "kimi.acp.text_delta", text: update.content.text }];
+        return [{ type: `${provider}.acp.text_delta`, text: update.content.text }];
     }
     if (update.sessionUpdate === "tool_call") {
         return [{
-                type: "kimi.acp.tool_call",
+                type: `${provider}.acp.tool_call`,
                 id: update.toolCallId,
                 title: update.title,
                 ...(update.kind === undefined ? {} : { kind: update.kind }),
@@ -50,7 +50,7 @@ export function mapKimiAcpUpdate(update) {
     if (update.sessionUpdate === "tool_call_update") {
         const output = textContent(update.content);
         return [{
-                type: "kimi.acp.tool_result",
+                type: `${provider}.acp.tool_result`,
                 id: update.toolCallId,
                 ...(update.status === undefined ? {} : { status: update.status }),
                 ...(output ? { content: output } : {}),
@@ -58,6 +58,9 @@ export function mapKimiAcpUpdate(update) {
     }
     return [];
 }
+export function mapKimiAcpUpdate(update) {
+    return mapAcpUpdate("kimi", update);
+}
 function safeErrorMessage(error, prompt) {
     const raw = error instanceof Error ? error.message : String(error);
     const redacted = prompt && raw.includes(prompt) ? raw.replaceAll(prompt, "[prompt redacted]") : raw;
@@ -67,6 +70,20 @@ export function isKimiAuthenticationRequired(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /\bauthentication required\b/i.test(message);
 }
+export function isAcpSessionNotFound(error) {
+    if (!(error instanceof RequestError) || (error.code !== -32602 && error.code !== -32603)) {
+        return false;
+    }
+    let data = "";
+    try {
+        data = JSON.stringify(error.data ?? "");
+    }
+    catch {
+        data = String(error.data ?? "");
+    }
+    return /session not found|no session found|unknown (?:durable )?session/i
+        .test(`${error.message} ${data}`);
+}
 export function kimiResumeMethod(capabilities) {
     if (capabilities?.sessionCapabilities?.resume != null)
         return "resume";
@@ -88,6 +105,36 @@ export function selectKimiPermission(params) {
         ? { outcome: { outcome: "cancelled" } }
         : { outcome: { outcome: "selected", optionId: allowed.optionId } };
 }
+function selectConfigId(options, category) {
+    const normalizedNames = category === "model"
+        ? new Set(["model"])
+        : new Set(["reasoning", "effort", "thought level", "thinking level"]);
+    const matches = (options ?? []).filter((option) => (option.type === "select"
+        && (option.category === category
+            || normalizedNames.has(option.id.toLowerCase())
+            || normalizedNames.has(option.name.toLowerCase()))));
+    return matches.length === 1 ? matches[0].id : null;
+}
+async function applySessionConfig(context, provider, sessionId, configOptions, options) {
+    const modelConfigId = provider === "kimi" && options.model
+        ? "model"
+        : selectConfigId(configOptions, "model");
+    if (options.model && modelConfigId !== null) {
+        await context.request(methods.agent.session.setConfigOption, {
+            sessionId,
+            configId: modelConfigId,
+            value: options.model,
+        });
+    }
+    const reasoningConfigId = selectConfigId(configOptions, "thought_level");
+    if (options.reasoning && reasoningConfigId !== null) {
+        await context.request(methods.agent.session.setConfigOption, {
+            sessionId,
+            configId: reasoningConfigId,
+            value: options.reasoning,
+        });
+    }
+}
 async function readPrompt() {
     process.stdin.setEncoding("utf8");
     let prompt = "";
@@ -116,6 +163,7 @@ async function stopChild(child) {
 }
 /** Probe the ACP transport without starting a session or forcing an optional interactive login flow. */
 export async function probeKimiAcp(options, spawnProcess = spawn) {
+    const provider = options.provider ?? "kimi";
     const child = spawnProcess(options.bin, ["acp"], {
         cwd: process.cwd(),
         // probe 在 daemon 自身 PATH 下运行,补上用户级 CLI 目录,与 which 探测保持一致。
@@ -125,12 +173,13 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
     if (child.stdin === null || child.stdout === null || child.stderr === null)
         return false;
     child.stderr.resume();
-    const app = client({ name: "nowcrew-daemon-kimi-probe" })
+    const app = client({ name: `nowcrew-daemon-${provider}-probe` })
         .onRequest(methods.client.session.requestPermission, () => ({
         outcome: { outcome: "cancelled" },
     }))
         .onNotification(methods.client.session.update, () => undefined);
     let timeout;
+    let onAbort;
     try {
         const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
         const connected = app.connectWith(stream, async (context) => {
@@ -149,6 +198,16 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
                     resolve(false);
                 }, PROBE_TIMEOUT_MS);
             }),
+            new Promise((resolve) => {
+                onAbort = () => {
+                    void stopChild(child);
+                    resolve(false);
+                };
+                if (options.signal?.aborted)
+                    onAbort();
+                else
+                    options.signal?.addEventListener("abort", onAbort, { once: true });
+            }),
         ]);
         return result;
     }
@@ -158,10 +217,14 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
     finally {
         if (timeout !== undefined)
             clearTimeout(timeout);
+        if (onAbort !== undefined)
+            options.signal?.removeEventListener("abort", onAbort);
         await stopChild(child);
     }
 }
 export async function runKimiAcp(options) {
+    const provider = options.provider ?? "kimi";
+    const displayName = provider === "kimi" ? "Kimi" : "Hermes";
     const prompt = await readPrompt();
     const child = spawn(options.bin, ["acp"], {
         cwd: process.cwd(),
@@ -170,7 +233,7 @@ export async function runKimiAcp(options) {
     });
     let runtimeChild = child;
     if (child.stdin === null || child.stdout === null || child.stderr === null) {
-        throw new Error("Kimi ACP process did not expose stdio");
+        throw new Error(`${displayName} ACP process did not expose stdio`);
     }
     child.stderr.pipe(process.stderr, { end: false });
     let context = null;
@@ -192,12 +255,12 @@ export async function runKimiAcp(options) {
     };
     process.once("SIGTERM", onSignal);
     process.once("SIGINT", onSignal);
-    const app = client({ name: "nowcrew-daemon-kimi" })
+    const app = client({ name: `nowcrew-daemon-${provider}` })
         .onRequest(methods.client.session.requestPermission, ({ params }) => selectKimiPermission(params))
         .onNotification(methods.client.session.update, async ({ params }) => {
         acpSemanticProgress = true;
         firstProgress.observe();
-        for (const event of mapKimiAcpUpdate(params.update))
+        for (const event of mapAcpUpdate(provider, params.update))
             await jsonLine(event);
     });
     let firstProgress = startFirstProgressWatchdog(() => undefined);
@@ -211,29 +274,44 @@ export async function runKimiAcp(options) {
                 clientCapabilities: {},
                 clientInfo: { name: "nowcrew-daemon", version: "1" },
             });
-            if (process.env.CREW_KIMI_ACP_DEBUG === "1") {
-                process.stderr.write(`Kimi ACP auth methods: ${JSON.stringify(initialized.authMethods ?? [])}\n`);
+            if (provider === "kimi" && process.env.CREW_KIMI_ACP_DEBUG === "1") {
+                process.stderr.write(`${displayName} ACP auth methods: ${JSON.stringify(initialized.authMethods ?? [])}\n`);
             }
+            let configOptions;
             if (options.resume && options.sessionId) {
                 const resumeMethod = kimiResumeMethod(initialized.agentCapabilities);
-                if (resumeMethod === "resume") {
-                    await nextContext.request(methods.agent.session.resume, {
-                        sessionId: options.sessionId,
-                        cwd: process.cwd(),
-                        mcpServers: [],
-                    });
+                try {
+                    if (resumeMethod === "resume") {
+                        const resumed = await nextContext.request(methods.agent.session.resume, {
+                            sessionId: options.sessionId,
+                            cwd: process.cwd(),
+                            mcpServers: [],
+                        });
+                        configOptions = resumed.configOptions;
+                    }
+                    else if (resumeMethod === "load") {
+                        const loaded = await nextContext.request(methods.agent.session.load, {
+                            sessionId: options.sessionId,
+                            cwd: process.cwd(),
+                            mcpServers: [],
+                        });
+                        configOptions = loaded.configOptions;
+                    }
+                    else {
+                        throw new Error(`${displayName} ACP does not advertise session resume support`);
+                    }
+                    sessionId = options.sessionId;
                 }
-                else if (resumeMethod === "load") {
-                    await nextContext.request(methods.agent.session.load, {
-                        sessionId: options.sessionId,
+                catch (error) {
+                    if (provider !== "hermes" || !isAcpSessionNotFound(error))
+                        throw error;
+                    const session = await nextContext.request(methods.agent.session.new, {
                         cwd: process.cwd(),
                         mcpServers: [],
                     });
+                    sessionId = session.sessionId;
+                    configOptions = session.configOptions;
                 }
-                else {
-                    throw new Error("Kimi ACP does not advertise session resume support");
-                }
-                sessionId = options.sessionId;
             }
             else {
                 const session = await nextContext.request(methods.agent.session.new, {
@@ -241,15 +319,10 @@ export async function runKimiAcp(options) {
                     mcpServers: [],
                 });
                 sessionId = session.sessionId;
+                configOptions = session.configOptions;
             }
             await jsonLine({ type: "thread.started", thread_id: sessionId });
-            if (options.model) {
-                await nextContext.request(methods.agent.session.setConfigOption, {
-                    sessionId,
-                    configId: "model",
-                    value: options.model,
-                });
-            }
+            await applySessionConfig(nextContext, provider, sessionId, configOptions, options);
             firstProgress = startFirstProgressWatchdog(() => {
                 progressTimedOut = true;
                 void cancel();
@@ -261,7 +334,7 @@ export async function runKimiAcp(options) {
         });
         firstProgress.stop();
         if (progressTimedOut) {
-            process.stderr.write("Kimi produced no semantic progress within the startup window\n");
+            process.stderr.write(`${displayName} produced no semantic progress within the startup window\n`);
             return 1;
         }
         const usage = result.usage;
@@ -281,10 +354,10 @@ export async function runKimiAcp(options) {
     }
     catch (error) {
         if (progressTimedOut) {
-            process.stderr.write("Kimi produced no semantic progress within the startup window\n");
+            process.stderr.write(`${displayName} produced no semantic progress within the startup window\n`);
             return 1;
         }
-        if (!acpSemanticProgress && isKimiAuthenticationRequired(error)) {
+        if (provider === "kimi" && !acpSemanticProgress && isKimiAuthenticationRequired(error)) {
             firstProgress.stop();
             await stopChild(child);
             process.stderr.write("Kimi ACP requires account login; falling back to configured CLI provider transport\n");
@@ -323,7 +396,7 @@ export async function runKimiAcp(options) {
             }
             return code;
         }
-        process.stderr.write(`Kimi ACP execution failed: ${safeErrorMessage(error, prompt)}\n`);
+        process.stderr.write(`${displayName} ACP execution failed: ${safeErrorMessage(error, prompt)}\n`);
         return 1;
     }
     finally {
@@ -337,19 +410,26 @@ function optionsFromArgv(argv) {
     const { values } = parseArgs({
         args: [...argv],
         options: {
+            provider: { type: "string", default: "kimi" },
             bin: { type: "string" },
             model: { type: "string" },
+            reasoning: { type: "string" },
             session: { type: "string" },
             resume: { type: "boolean", default: false },
         },
     });
     if (!values.bin)
         throw new Error("--bin is required");
+    if (values.provider !== "kimi" && values.provider !== "hermes") {
+        throw new Error("--provider must be kimi or hermes");
+    }
     if (values.resume && !values.session)
         throw new Error("--resume requires --session");
     return {
+        provider: values.provider,
         bin: values.bin,
         ...(values.model ? { model: values.model } : {}),
+        ...(values.reasoning ? { reasoning: values.reasoning } : {}),
         ...(values.session ? { sessionId: values.session } : {}),
         ...(values.resume ? { resume: true } : {}),
     };
@@ -358,7 +438,7 @@ if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.a
     runKimiAcp(optionsFromArgv(process.argv.slice(2)))
         .then((code) => { process.exitCode = code; })
         .catch((error) => {
-        process.stderr.write(`Kimi ACP runner failed: ${safeErrorMessage(error, "")}\n`);
+        process.stderr.write(`ACP runner failed: ${safeErrorMessage(error, "")}\n`);
         process.exitCode = 1;
     });
 }

package/dist/runtimes/opencode-runner.js

@@ -0,0 +1,122 @@
+import { once } from "node:events";
+import { createInterface } from "node:readline";
+import { parseArgs } from "node:util";
+import { pathToFileURL } from "node:url";
+import spawn from "cross-spawn";
+import { augmentedPath } from "../runtime-path.js";
+import { buildOpenCodeArgs, createOpenCodeEventDecoder } from "./opencode.js";
+const ERROR_CAP = 2_000;
+async function readPrompt() {
+    process.stdin.setEncoding("utf8");
+    let prompt = "";
+    for await (const chunk of process.stdin)
+        prompt += String(chunk);
+    if (!prompt)
+        throw new Error("OpenCode prompt is empty");
+    return prompt;
+}
+async function jsonLine(event) {
+    if (process.stdout.write(`${JSON.stringify(event)}\n`))
+        return;
+    await once(process.stdout, "drain");
+}
+export function isOpenCodeSessionNotFound(message) {
+    return /(?:session|conversation).*(?:not found|does not exist|unknown|invalid)|(?:not found|unknown|invalid).*(?:session|conversation)/iu
+        .test(message);
+}
+async function runAttempt(options, prompt) {
+    const cwd = process.cwd();
+    const child = spawn(options.bin, buildOpenCodeArgs({ cwd, ...options }), {
+        cwd,
+        env: { ...process.env, PATH: augmentedPath(), PWD: cwd },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (!child.stdin || !child.stdout || !child.stderr) {
+        throw new Error("OpenCode process did not expose stdio");
+    }
+    child.stderr.pipe(process.stderr, { end: false });
+    const childExit = once(child, "close");
+    child.stdin.end(prompt);
+    const decoder = createOpenCodeEventDecoder();
+    const lines = createInterface({ input: child.stdout });
+    const pending = [];
+    let emittedSemanticOutput = false;
+    for await (const line of lines) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        for (const normalized of decoder.push(event)) {
+            const type = normalized.type;
+            const semantic = type === "opencode.text_delta"
+                || type === "opencode.tool_call"
+                || type === "opencode.tool_result";
+            if (!emittedSemanticOutput && !semantic) {
+                pending.push(normalized);
+                continue;
+            }
+            if (!emittedSemanticOutput) {
+                emittedSemanticOutput = true;
+                for (const buffered of pending.splice(0))
+                    await jsonLine(buffered);
+            }
+            await jsonLine(normalized);
+        }
+    }
+    const [exitCode, signal] = await childExit;
+    const result = decoder.finish();
+    const staleSession = options.sessionId !== undefined
+        && !emittedSemanticOutput
+        && result.error !== undefined
+        && isOpenCodeSessionNotFound(result.error);
+    if (staleSession)
+        return { code: 1, staleSession: true };
+    for (const buffered of pending)
+        await jsonLine(buffered);
+    if (!result.ok) {
+        process.stderr.write(`${result.error?.slice(0, ERROR_CAP)}\n`);
+        return { code: 1, staleSession: false };
+    }
+    if (exitCode !== 0)
+        return { code: exitCode ?? (signal ? 128 : 1), staleSession: false };
+    await jsonLine({ type: "turn.completed", ...(result.usage ? { usage: result.usage } : {}) });
+    return { code: 0, staleSession: false };
+}
+export async function runOpenCode(options) {
+    const prompt = await readPrompt();
+    const first = await runAttempt(options, prompt);
+    if (!first.staleSession)
+        return first.code;
+    const { sessionId: _staleSessionId, ...freshOptions } = options;
+    return (await runAttempt(freshOptions, prompt)).code;
+}
+function optionsFromArgv(argv) {
+    const { values } = parseArgs({
+        args: [...argv],
+        options: {
+            bin: { type: "string" },
+            model: { type: "string" },
+            reasoning: { type: "string" },
+            session: { type: "string" },
+        },
+    });
+    if (!values.bin)
+        throw new Error("--bin is required");
+    return {
+        bin: values.bin,
+        ...(values.model ? { model: values.model } : {}),
+        ...(values.reasoning ? { reasoning: values.reasoning } : {}),
+        ...(values.session ? { sessionId: values.session } : {}),
+    };
+}
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    runOpenCode(optionsFromArgv(process.argv.slice(2)))
+        .then((code) => { process.exitCode = code; })
+        .catch((error) => {
+        process.stderr.write(`OpenCode runner failed: ${String(error).slice(0, ERROR_CAP)}\n`);
+        process.exitCode = 1;
+    });
+}