@nowcrew/daemon 0.6.88-beta.3 → 0.6.88-beta.31

package/dist/runtimes/deepseek-harness-runner.js

@@ -0,0 +1,226 @@
+/** 新版 Harness 的短命 ACP 桥:产品状态与重试仍属于 server。 */
+import { once } from "node:events";
+import { Readable, Writable } from "node:stream";
+import { parseArgs } from "node:util";
+import { pathToFileURL } from "node:url";
+import { isAbsolute } from "node:path";
+import spawn from "cross-spawn";
+import { z } from "zod";
+import { client, methods, ndJsonStream, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
+import { deepSeekHarnessLaunch } from "./deepseek-harness-launch.js";
+import { prepareHarnessProfile } from "./deepseek-harness-profile.js";
+import { mapAcpUpdate } from "./kimi-acp-runner.js";
+import { prepareThreadDelivery } from "../thread-input-delivery.js";
+const absolutePath = z.string().refine(isAbsolute, "must be an absolute path");
+export const HarnessInputSchema = z
+    .object({
+    systemPrompt: z.string(),
+    wakePrompt: z.string().min(1),
+    stateRoot: absolutePath,
+    skillRoots: z.array(absolutePath).default([]),
+    effectivePermission: z.enum([
+        "sandboxed",
+        "workspace_write",
+        "full_access",
+    ]),
+})
+    .strict();
+const emit = async (event) => {
+    if (!process.stdout.write(`${JSON.stringify(event)}\n`))
+        await once(process.stdout, "drain");
+};
+async function settleWithin(promise, ms) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(undefined), ms);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+export async function runHarness(input, bin, patchPath) {
+    const delivery = await prepareThreadDelivery({
+        env: process.env,
+        resumed: false,
+        sessionId: "cold-harness",
+        wakePrompt: input.wakePrompt,
+    });
+    const profile = await prepareHarnessProfile({
+        ...input,
+        cwd: process.cwd(),
+        env: process.env,
+        ...(patchPath ? { patchPath } : {}),
+    });
+    const launch = deepSeekHarnessLaunch(bin, profile.args);
+    const child = spawn(launch.bin, launch.args, {
+        cwd: profile.home,
+        env: profile.env,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    // Boot away from the repository: the CLI must not load a project's .env into
+    // trusted process credentials. ACP session/new carries the real workspace.
+    let spawnError;
+    const closed = new Promise((resolve) => {
+        child.once("error", (error) => {
+            spawnError = error;
+            resolve();
+        });
+        child.once("close", () => resolve());
+    });
+    if (!child.stdin || !child.stdout || !child.stderr)
+        throw new Error("DeepSeek Harness stdio unavailable");
+    // Provider diagnostics may include secrets or prompts; do not stream raw stderr.
+    child.stderr.resume();
+    let context;
+    let sessionId;
+    let cancelled = false;
+    let stage = "initialize";
+    let exitCode = 1;
+    let stopping;
+    const stop = () => (stopping ??= (async () => {
+        child.stdin?.end();
+        if (await settleWithin(closed.then(() => true), 2000))
+            return;
+        child.kill("SIGTERM");
+        if (await settleWithin(closed.then(() => true), 1000))
+            return;
+        child.kill("SIGKILL");
+        if (!(await settleWithin(closed.then(() => true), 2000)))
+            throw new Error("DeepSeek Harness process stop unconfirmed");
+    })());
+    const cancel = () => {
+        cancelled = true;
+        void (async () => {
+            if (context && sessionId)
+                await settleWithin(context
+                    .notify(methods.agent.session.cancel, { sessionId })
+                    .catch(() => undefined), 1000);
+            await stop();
+        })().catch(() => {
+            /* finally reports stop failure; supervisor owns process tree */
+        });
+    };
+    process.once("SIGTERM", cancel);
+    process.once("SIGINT", cancel);
+    const app = client({ name: "nowwork-harness" })
+        .onRequest(methods.client.session.requestPermission, () => ({
+        outcome: { outcome: "cancelled" },
+    }))
+        .onNotification(methods.client.session.update, async ({ params }) => {
+        if (params.sessionId !== sessionId)
+            return;
+        for (const event of mapAcpUpdate("deepseek-harness", params.update))
+            await emit(event);
+    });
+    try {
+        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const result = await app.connectWith(stream, async (ctx) => {
+            context = ctx;
+            const initialized = await ctx.request(methods.agent.initialize, {
+                protocolVersion: PROTOCOL_VERSION,
+                clientCapabilities: {},
+                clientInfo: { name: "nowwork", version: "1" },
+            });
+            if (initialized.protocolVersion !== PROTOCOL_VERSION)
+                throw new Error("Incompatible ACP protocol");
+            if (cancelled)
+                throw new Error("cancelled");
+            stage = "session_new";
+            const session = await ctx.request(methods.agent.session.new, {
+                cwd: process.cwd(),
+                mcpServers: [],
+            });
+            sessionId = session.sessionId;
+            if (!sessionId || cancelled)
+                throw new Error("Harness session unavailable");
+            await emit({ type: "thread.started", thread_id: sessionId });
+            stage = "prompt";
+            const response = await ctx.request(methods.agent.session.prompt, {
+                sessionId,
+                prompt: [{ type: "text", text: delivery.prompt }],
+            });
+            if (initialized.agentCapabilities?.sessionCapabilities?.close != null) {
+                stage = "session_close";
+                const close = await settleWithin(ctx
+                    .request(methods.agent.session.close, { sessionId })
+                    .then(() => true), 5000);
+                if (!close)
+                    throw new Error("Harness session close timed out");
+            }
+            return response;
+        });
+        const usage = result.usage;
+        if (!cancelled)
+            await emit({
+                type: "turn.completed",
+                stop_reason: result.stopReason,
+                ...(usage
+                    ? {
+                        usage: {
+                            input_tokens: usage.inputTokens,
+                            output_tokens: usage.outputTokens,
+                            cache_read_input_tokens: usage.cachedReadTokens ?? 0,
+                            cache_creation_input_tokens: usage.cachedWriteTokens ?? 0,
+                        },
+                    }
+                    : {}),
+            });
+        exitCode =
+            result.stopReason === "end_turn"
+                ? 0
+                : result.stopReason === "cancelled"
+                    ? 130
+                    : 1;
+    }
+    catch {
+        if (!cancelled)
+            process.stderr.write(spawnError
+                ? "DeepSeek Harness launch failed; verify the installed dsh executable.\n"
+                : `DeepSeek Harness ACP execution failed at ${stage}; verify DEEPSEEK_API_KEY, model access, the pinned version and profile patch.\n`);
+    }
+    finally {
+        try {
+            await stop();
+        }
+        finally {
+            process.off("SIGTERM", cancel);
+            process.off("SIGINT", cancel);
+        }
+    }
+    if (cancelled)
+        return 130;
+    return child.exitCode !== 0 ? 1 : exitCode;
+}
+async function main() {
+    const { values } = parseArgs({
+        options: { bin: { type: "string" }, patch: { type: "string" } },
+    });
+    if (!values.bin)
+        throw new Error("DeepSeek Harness --bin is required");
+    process.stdin.setEncoding("utf8");
+    let text = "";
+    for await (const chunk of process.stdin) {
+        text += String(chunk);
+        if (Buffer.byteLength(text) > 16 * 1024 * 1024)
+            throw new Error("Harness input exceeds 16 MiB");
+    }
+    const input = HarnessInputSchema.parse(JSON.parse(text));
+    return runHarness(input, values.bin, values.patch);
+}
+if (process.argv[1] &&
+    import.meta.url === pathToFileURL(process.argv[1]).href) {
+    main()
+        .then((code) => {
+        process.exitCode = code;
+    })
+        .catch(() => {
+        process.stderr.write("DeepSeek Harness configuration or cleanup failed; check execution paths and machine patch.\n");
+        process.exitCode = 1;
+    });
+}

package/dist/runtimes/deepseek-harness.js

@@ -1,20 +1,81 @@
 import spawn from "cross-spawn";
-import { isAbsolute } from "node:path";
-import { probeKimiAcp } from "./kimi-acp-runner.js";
+import { isAbsolute, win32, join } from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { deepSeekHarnessLaunch } from "./deepseek-harness-launch.js";
+import { prepareHarnessProfile } from "./deepseek-harness-profile.js";
+import { probeKimiAcp, AcpProbeCleanupError } from "./kimi-acp-runner.js";
+import { runtimeEnvironmentValue } from "../runtime-environment-merge.js";
+import { augmentedPath } from "../runtime-path.js";
 export const DEEPSEEK_HARNESS_CONFIG_ENV = "NOWCREW_DEEPSEEK_HARNESS_CONFIG";
-export function deepSeekHarnessConfigPath(env = process.env) {
-    const path = env[DEEPSEEK_HARNESS_CONFIG_ENV]?.trim();
-    return path && isAbsolute(path) ? path : null;
+export const DEEPSEEK_HARNESS_PATCH_ENV = "NOWCREW_DEEPSEEK_HARNESS_PATCH";
+export function deepSeekHarnessLauncher(env = process.env, platform = process.platform) {
+    const configPath = runtimeEnvironmentValue(env, DEEPSEEK_HARNESS_CONFIG_ENV, platform)?.trim();
+    const patchPath = runtimeEnvironmentValue(env, DEEPSEEK_HARNESS_PATCH_ENV, platform)?.trim();
+    const absolute = platform === "win32" ? win32.isAbsolute : isAbsolute;
+    if (configPath && !absolute(configPath))
+        throw new Error(`${DEEPSEEK_HARNESS_CONFIG_ENV} must be an absolute path`);
+    if (patchPath && !absolute(patchPath))
+        throw new Error(`${DEEPSEEK_HARNESS_PATCH_ENV} must be an absolute path`);
+    if (configPath && patchPath)
+        throw new Error("DeepSeek Harness legacy config and profile patch are mutually exclusive");
+    return configPath
+        ? { kind: "legacy", bin: "dsh-acp-demo", configPath }
+        : { kind: "profile", bin: "dsh", ...(patchPath ? { patchPath } : {}) };
+}
+export function deepSeekHarnessConfigPath(env = process.env, platform = process.platform) {
+    const path = runtimeEnvironmentValue(env, DEEPSEEK_HARNESS_CONFIG_ENV, platform)?.trim();
+    return path && (platform === "win32" ? win32.isAbsolute(path) : isAbsolute(path)) ? path : null;
 }
 /** The published DeepSeek Harness ACP executable speaks JSON-RPC directly on stdio. */
-export function probeDeepSeekHarnessAcp(options, spawnProcess = spawn) {
-    const configPath = options.configPath ?? deepSeekHarnessConfigPath();
-    if (!configPath || !isAbsolute(configPath))
-        return Promise.resolve(false);
-    return probeKimiAcp({
-        ...options,
-        provider: "deepseek-harness",
-        configPath,
-        effectivePermission: "sandboxed",
-    }, spawnProcess);
+export async function probeDeepSeekHarnessAcp(options, spawnProcess = spawn) {
+    if (options.signal?.aborted)
+        return false;
+    const sourceEnv = options.env ?? { ...process.env, PATH: augmentedPath() };
+    let root;
+    try {
+        const launcher = options.configPath === undefined
+            ? deepSeekHarnessLauncher(sourceEnv)
+            : deepSeekHarnessLauncher({
+                ...sourceEnv,
+                [DEEPSEEK_HARNESS_CONFIG_ENV]: options.configPath,
+            });
+        if (launcher.kind === "legacy")
+            return await probeKimiAcp({
+                ...options,
+                env: sourceEnv,
+                provider: "deepseek-harness",
+                configPath: launcher.configPath,
+                effectivePermission: "sandboxed",
+            }, spawnProcess);
+        root = await mkdtemp(join(tmpdir(), "nowwork-dsh-probe-"));
+        const profile = await prepareHarnessProfile({
+            stateRoot: root,
+            cwd: root,
+            systemPrompt: "",
+            skillRoots: [],
+            effectivePermission: "sandboxed",
+            env: sourceEnv,
+            ...(launcher.patchPath ? { patchPath: launcher.patchPath } : {}),
+        });
+        const launch = deepSeekHarnessLaunch(options.bin, profile.args);
+        return await probeKimiAcp({
+            ...options,
+            bin: launch.bin,
+            provider: "deepseek-harness",
+            effectivePermission: "sandboxed",
+            launchArgs: launch.args,
+            launchEnv: profile.env,
+            launchCwd: root,
+        }, spawnProcess);
+    }
+    catch (error) {
+        if (error instanceof AcpProbeCleanupError)
+            throw error;
+        return false;
+    }
+    finally {
+        if (root)
+            await rm(root, { recursive: true, force: true }).catch(() => undefined);
+    }
 }

package/dist/runtimes/harness-probe-retry.js

@@ -0,0 +1,42 @@
+import { dslog } from "../slog.js";
+const RETRY_DELAYS_MS = [1_000, 2_000];
+/** 只延迟当前启动探测,不设后台定时任务;stop 立即清除等待。 */
+function waitForRetry(ms, signal) {
+    if (signal?.aborted)
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const finish = (ready) => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            resolve(ready);
+        };
+        const onAbort = () => finish(false);
+        const timer = setTimeout(() => finish(true), ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+/** 成功才公布能力;每次 probe 返回前已完成进程清理,异常保持原有传播。 */
+export async function retryHarnessProbe(probe, signal, probeId) {
+    for (let attempt = 1; attempt <= RETRY_DELAYS_MS.length + 1; attempt++) {
+        if (signal?.aborted)
+            return false;
+        const ready = await probe();
+        dslog("runtime_probe.harness_attempt", "Harness 启动探测尝试结束", {
+            probe_id: probeId, runtime: "deepseek-harness", attempt, ready,
+            aborted: signal?.aborted ?? false,
+        });
+        if (signal?.aborted)
+            return false;
+        if (ready)
+            return true;
+        const delayMs = RETRY_DELAYS_MS[attempt - 1];
+        if (delayMs === undefined)
+            return false;
+        dslog("runtime_probe.harness_retry", "延迟重试 Harness 启动探测", {
+            probe_id: probeId, runtime: "deepseek-harness", next_attempt: attempt + 1, delay_ms: delayMs,
+        });
+        if (!await waitForRetry(delayMs, signal))
+            return false;
+    }
+    return false;
+}

package/dist/runtimes/hermes-models.js

@@ -71,9 +71,10 @@ async function stopChild(child) {
 }
 export async function listHermesModels(options = {}) {
     const spawnProcess = options.spawnProcess ?? spawn;
+    const env = options.env ?? { ...process.env, PATH: augmentedPath() };
     const child = spawnProcess("hermes", ["acp"], {
         cwd: process.cwd(),
-        env: { ...process.env, PATH: augmentedPath() },
+        env,
         stdio: ["pipe", "pipe", "pipe"],
     });
     if (child.stdin === null || child.stdout === null || child.stderr === null)

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

@@ -1,3 +1,6 @@
+import { AcpProbeTransport } from "./acp-probe-transport.js";
+import { randomUUID } from "node:crypto";
+import { dslog } from "../slog.js";
 import { once } from "node:events";
 import { isAbsolute } from "node:path";
 import { parseArgs } from "node:util";
@@ -6,10 +9,16 @@ import { pathToFileURL } from "node:url";
 import spawn from "cross-spawn";
 import { PROTOCOL_VERSION, RequestError, client, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
 import { augmentedPath } from "../runtime-path.js";
+import { prepareThreadDelivery } from "../thread-input-delivery.js";
 import { startFirstProgressWatchdog } from "./progress-watchdog.js";
 import { assertKimiLegacyPromptFits, buildKimiArgs } from "./kimi.js";
 const ERROR_MESSAGE_CAP = 2_000;
-const PROBE_TIMEOUT_MS = 5_000;
+// macOS launchd cold-starts ACP runtimes materially slower than an interactive
+// shell. DeepSeek Harness was measured at ~4.4s before returning initialize
+// under launchd, while the daemon also creates an isolated profile. Keep this
+// bounded below the control-plane request budget, with the existing 1s/2s
+// Harness retries providing the outer bound.
+export const ACP_PROBE_TIMEOUT_MS = 10_000;
 function jsonLine(event) {
     if (process.stdout.write(`${JSON.stringify(event)}\n`))
         return Promise.resolve();
@@ -127,10 +136,10 @@ function deepSeekPermissionMode(permission) {
         return "workspace-write";
     return "danger-full-access";
 }
-function providerEnv(provider, permission) {
+function providerEnv(provider, permission, env = process.env) {
     return provider === "deepseek-harness"
-        ? { ...process.env, DSH_PERMISSION_MODE: deepSeekPermissionMode(permission) }
-        : process.env;
+        ? { ...env, DSH_PERMISSION_MODE: deepSeekPermissionMode(permission) }
+        : env;
 }
 function providerDisplayName(provider) {
     if (provider === "deepseek-harness")
@@ -193,18 +202,48 @@ async function stopChild(child) {
         await closed;
     }
 }
+export class AcpProbeCleanupError extends Error {
+    constructor() { super("ACP probe process cleanup unconfirmed"); this.name = "AcpProbeCleanupError"; }
+}
 /** 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 permission = options.effectivePermission ?? "sandboxed";
-    const child = spawnProcess(options.bin, providerArgs(provider, options.configPath), {
-        cwd: process.cwd(),
-        // probe 在 daemon 自身 PATH 下运行,补上用户级 CLI 目录,与 which 探测保持一致。
-        env: { ...providerEnv(provider, permission), PATH: augmentedPath() },
+    const probeId = options.probeId ?? randomUUID();
+    const started = performance.now();
+    const elapsed = () => Math.round(performance.now() - started);
+    const transport = new AcpProbeTransport(elapsed);
+    let spawnConfirmedMs;
+    let reason = "initializing", protocolVersion;
+    let stderrSeen = false;
+    const fields = () => ({ probe_id: probeId, runtime: provider, duration_ms: elapsed(),
+        ...transport.fields(), spawn_confirmed_ms: spawnConfirmedMs, child_pid: child.pid,
+        reason, protocol_version: protocolVersion, stderr_seen: stderrSeen, aborted: options.signal?.aborted ?? false });
+    dslog("execution.acp_probe_started", "ACP 探测开始", { probe_id: probeId, runtime: provider, node_version: process.version });
+    const sourceEnv = options.env ?? { ...process.env, PATH: augmentedPath() };
+    const launchEnv = options.launchEnv ?? providerEnv(provider, permission, sourceEnv);
+    const child = spawnProcess(options.bin, options.launchArgs ?? providerArgs(provider, options.configPath), {
+        cwd: options.launchCwd ?? process.cwd(),
+        // 显式 launchEnv 已准备好 PATH/HOME，不能二次补 PATH 或混入父进程环境。
+        env: launchEnv,
         stdio: ["pipe", "pipe", "pipe"],
     });
+    // spawn errors are emitted by ChildProcess, not its stdio streams. A missing
+    // launcher must fail admission, not become an uncaught daemon exception.
+    const spawnFailed = new Promise((resolve) => {
+        child.once("error", () => {
+            if (reason === "initializing")
+                reason = "spawn_error";
+            resolve(false);
+        });
+    });
+    child.once("spawn", () => {
+        spawnConfirmedMs = elapsed();
+        dslog("execution.acp_probe_spawned", "ACP 探测子进程已启动", fields());
+    });
     if (child.stdin === null || child.stdout === null || child.stderr === null)
         return false;
+    child.stderr.on("data", () => { stderrSeen = true; });
     child.stderr.resume();
     const app = client({ name: `nowcrew-daemon-${provider}-probe` })
         .onRequest(methods.client.session.requestPermission, () => ({
@@ -214,25 +253,37 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
     let timeout;
     let onAbort;
     try {
-        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const stream = ndJsonStream(transport.writable(child.stdin), transport.readable(child.stdout));
         const connected = app.connectWith(stream, async (context) => {
-            await context.request(methods.agent.initialize, {
+            transport.initializeRequested();
+            const initialized = await context.request(methods.agent.initialize, {
                 protocolVersion: PROTOCOL_VERSION,
                 clientCapabilities: {},
                 clientInfo: { name: "nowcrew-daemon", version: "1" },
             });
-            return true;
+            transport.initializeResponse();
+            protocolVersion = initialized.protocolVersion;
+            const ready = protocolVersion === PROTOCOL_VERSION;
+            if (reason === "initializing")
+                reason = ready ? "ready" : "protocol_mismatch";
+            dslog("execution.acp_probe_handshake", "ACP 握手结果", { ...fields(), ready });
+            return ready;
         });
         const result = await Promise.race([
             connected,
+            spawnFailed,
             new Promise((resolve) => {
                 timeout = setTimeout(() => {
+                    if (reason === "initializing")
+                        reason = "timeout";
                     void stopChild(child);
                     resolve(false);
-                }, PROBE_TIMEOUT_MS);
+                }, ACP_PROBE_TIMEOUT_MS);
             }),
             new Promise((resolve) => {
                 onAbort = () => {
+                    if (reason === "initializing")
+                        reason = "aborted";
                     void stopChild(child);
                     resolve(false);
                 };
@@ -245,6 +296,8 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
         return result;
     }
     catch {
+        if (reason === "initializing")
+            reason = options.signal?.aborted ? "aborted" : "transport_error";
         return false;
     }
     finally {
@@ -252,17 +305,33 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
             clearTimeout(timeout);
         if (onAbort !== undefined)
             options.signal?.removeEventListener("abort", onAbort);
-        await stopChild(child);
+        dslog("execution.acp_probe_cleanup_started", "ACP 探测清理开始", fields());
+        let cleanupFinished = false;
+        try {
+            await stopChild(child);
+            cleanupFinished = true;
+        }
+        catch {
+            throw new AcpProbeCleanupError();
+        }
+        finally {
+            dslog("execution.acp_probe_finished", "ACP 探测结束", { ...fields(),
+                cleanup_finished: cleanupFinished, exit_code: child.exitCode, exit_signal: child.signalCode,
+                level: reason === "ready" && cleanupFinished ? "INFO" : "WARN" });
+        }
     }
 }
-export async function runKimiAcp(options) {
+export async function runKimiAcp(requestedOptions) {
+    // Until this adapter verifies native restoration, thread-bound runs are cold.
+    const options = process.env.CREW_THREAD_ROOT ? { ...requestedOptions, resume: false } : requestedOptions;
     const provider = options.provider ?? "kimi";
     const displayName = providerDisplayName(provider);
     const permission = options.effectivePermission ?? "full_access";
     if (provider === "deepseek-harness" && options.resume) {
         throw new Error("DeepSeek Harness ACP does not support session resume");
     }
-    const prompt = await readPrompt();
+    const prompt = (await prepareThreadDelivery({ env: process.env, resumed: false,
+        sessionId: "unverified-cold-acp", wakePrompt: await readPrompt() })).prompt;
     const child = spawn(options.bin, providerArgs(provider, options.configPath), {
         cwd: process.cwd(),
         env: providerEnv(provider, permission),

package/dist/runtimes/opencode-runner.js

@@ -4,6 +4,7 @@ import { parseArgs } from "node:util";
 import { pathToFileURL } from "node:url";
 import spawn from "cross-spawn";
 import { augmentedPath } from "../runtime-path.js";
+import { prepareThreadDelivery } from "../thread-input-delivery.js";
 import { buildOpenCodeArgs, createOpenCodeEventDecoder } from "./opencode.js";
 const ERROR_CAP = 2_000;
 async function readPrompt() {
@@ -86,7 +87,12 @@ async function runAttempt(options, prompt) {
     return { code: 0, staleSession: false };
 }
 export async function runOpenCode(options) {
-    const prompt = await readPrompt();
+    const prompt = (await prepareThreadDelivery({ env: process.env, resumed: false,
+        sessionId: "unverified-cold-opencode", wakePrompt: await readPrompt() })).prompt;
+    if (process.env.CREW_THREAD_ROOT) {
+        const { sessionId: _unverified, ...coldOptions } = options;
+        return (await runAttempt(coldOptions, prompt)).code;
+    }
     const first = await runAttempt(options, prompt);
     if (!first.staleSession)
         return first.code;

package/dist/runtimes/opencode.js

@@ -11,7 +11,7 @@ const REQUIRED_RUN_FLAGS = [
     "--variant",
     "--session",
 ];
-export async function probeOpenCodeRun(signal) {
+export async function probeOpenCodeRun(signal, env = { ...process.env, PATH: augmentedPath() }) {
     try {
         const { stdout, stderr } = await execFileP("opencode", ["run", "--help"], {
             shell: isWin(),
@@ -19,7 +19,7 @@ export async function probeOpenCodeRun(signal) {
             killSignal: "SIGKILL",
             maxBuffer: 1024 * 1024,
             signal,
-            env: { ...process.env, PATH: augmentedPath() },
+            env,
         });
         const help = `${stdout}\n${stderr}`;
         return REQUIRED_RUN_FLAGS.every((flag) => help.includes(flag));