@nowcrew/daemon 0.6.89 → 0.6.91-beta.1

package/dist/runtime-probe.js

@@ -1,3 +1,5 @@
+import { randomUUID } from "node:crypto";
+import { dslog } from "./slog.js";
 import { executableRuntimes } from "./runtime-capabilities.js";
 export function conservativeExecutionRuntimes(installed) {
     return executableRuntimes(installed)
@@ -7,16 +9,43 @@ export function createRuntimeProbeCoordinator() {
     const abort = new AbortController();
     const flights = new Map();
     return {
-        detect(installed, detector) {
-            const key = [...installed].sort().join("\0");
+        detect(installed, detector, connectionId, environmentGeneration = "") {
+            const key = JSON.stringify([environmentGeneration, [...installed].sort()]);
             const existing = flights.get(key);
-            if (existing)
-                return existing;
-            const pending = detector(installed, abort.signal).catch((error) => {
+            const probeId = existing?.probeId ?? randomUUID();
+            const fields = { probe_id: probeId, connection_id: connectionId, installed_runtimes: JSON.stringify(installed) };
+            dslog("runtime_probe.request", "请求 runtime 执行能力探测", fields);
+            if (existing) {
+                dslog("runtime_probe.cache_hit", "复用 runtime 探测结果", { ...fields, cache_state: existing.state });
+                return existing.promise;
+            }
+            const startedAt = Date.now();
+            const complete = (outcome, executionRuntimes) => {
+                dslog("runtime_probe.complete", "runtime 探测聚合结束", {
+                    ...fields, outcome, duration_ms: Date.now() - startedAt, aborted: abort.signal.aborted,
+                    ...(executionRuntimes === undefined ? {} : { execution_runtimes: JSON.stringify(executionRuntimes) }),
+                });
+            };
+            let detection;
+            try {
+                detection = detector(installed, abort.signal, probeId);
+            }
+            catch (error) {
+                complete("threw");
+                throw error;
+            }
+            const pending = detection.then((result) => {
+                const flight = flights.get(key);
+                if (flight)
+                    flights.set(key, { ...flight, state: "resolved" });
+                complete("resolved", result);
+                return result;
+            }, (error) => {
                 flights.delete(key);
+                complete("threw");
                 throw error;
             });
-            flights.set(key, pending);
+            flights.set(key, { promise: pending, probeId, state: "pending" });
             return pending;
         },
         stop() {

package/dist/runtimes/acp-probe-transport.js

@@ -0,0 +1,69 @@
+import { Readable as NodeReadable } from "node:stream";
+import { ReadableStream, WritableStream } from "node:stream/web";
+/** Probe-only counters. Never retain/log chunks, JSON-RPC params, stderr or env values. */
+export class AcpProbeTransport {
+    elapsed;
+    initializeRequestedMs;
+    initializeResponseMs;
+    firstStdinWriteMs;
+    firstStdoutMs;
+    stdinBytesWritten = 0;
+    stdoutBytes = 0;
+    stdoutEnded = false;
+    constructor(elapsed) {
+        this.elapsed = elapsed;
+    }
+    initializeRequested() { this.initializeRequestedMs = this.elapsed(); }
+    initializeResponse() { this.initializeResponseMs = this.elapsed(); }
+    fields() {
+        return {
+            initialize_requested_ms: this.initializeRequestedMs,
+            initialize_response_ms: this.initializeResponseMs,
+            first_stdin_write_ms: this.firstStdinWriteMs,
+            first_stdout_ms: this.firstStdoutMs,
+            stdin_bytes_written: this.stdinBytesWritten,
+            stdout_bytes: this.stdoutBytes,
+            stdout_ended: this.stdoutEnded,
+        };
+    }
+    /** A write callback confirms acceptance by the pipe, NOT receipt by the agent. */
+    writable(stdin) {
+        return new WritableStream({
+            start: (controller) => { stdin.once("error", (error) => controller.error(error)); },
+            write: (chunk) => new Promise((resolve, reject) => {
+                stdin.write(chunk, (error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    this.firstStdinWriteMs ??= this.elapsed();
+                    this.stdinBytesWritten += chunk.byteLength;
+                    resolve();
+                });
+            }),
+            close: () => new Promise((resolve, reject) => {
+                stdin.end((error) => error ? reject(error) : resolve());
+            }),
+            abort: () => { stdin.destroy(); },
+        });
+    }
+    /** Observe before NDJSON decoding, without adding a competing 'data' listener. */
+    readable(stdout) {
+        const reader = NodeReadable.toWeb(stdout).getReader();
+        return new ReadableStream({
+            pull: async (controller) => {
+                const item = await reader.read();
+                if (item.done) {
+                    this.stdoutEnded = true;
+                    controller.close();
+                    return;
+                }
+                const chunk = item.value;
+                this.firstStdoutMs ??= this.elapsed();
+                this.stdoutBytes += chunk.byteLength;
+                controller.enqueue(chunk);
+            },
+            cancel: (reason) => reader.cancel(reason),
+        });
+    }
+}

package/dist/runtimes/claude-models.js

@@ -14,6 +14,7 @@ import { tmpdir } from "node:os";
 import { createInterface } from "node:readline";
 import { promisify } from "node:util";
 import { isWin } from "../platform.js";
+import { augmentedPath } from "../runtime-path.js";
 const execFileP = promisify(execFile);
 const PROBE_TIMEOUT_MS = 8_000;
 // 本机丢弃端口:连不上也无所谓,init 事件在任何网络请求之前就已输出。
@@ -26,18 +27,27 @@ const CLAUDE_ALIASES = [
 ];
 const DEFAULT_ALIAS = "sonnet";
 const cacheByVersion = new Map();
+let cacheByEnvironment = new WeakMap();
 /** "2.1.258 (Claude Code)" → "2.1.258";空/异常输出 → ""。 */
 export function normalizeClaudeVersion(raw) {
     return raw.replace(/\s*\(Claude Code\)\s*$/, "").trim();
 }
-export async function listClaudeModels(deps = defaultDeps) {
-    const version = normalizeClaudeVersion(await deps.probeVersion());
-    const cached = version ? cacheByVersion.get(version) : undefined;
+export async function listClaudeModels(deps, env, environmentGeneration = "") {
+    const probes = deps ?? { probeVersion: () => probeVersion(env), resolveAlias: (alias) => resolveAlias(alias, env) };
+    let cache = env ? cacheByEnvironment.get(env) : cacheByVersion;
+    if (!cache) {
+        cache = new Map();
+        if (env)
+            cacheByEnvironment.set(env, cache);
+    }
+    const version = normalizeClaudeVersion(await probes.probeVersion());
+    const cacheKey = JSON.stringify([environmentGeneration, version]);
+    const cached = version ? cache.get(cacheKey) : undefined;
     if (cached)
         return cached;
     const resolved = await Promise.all(CLAUDE_ALIASES.map(async ([alias]) => {
         try {
-            return await deps.resolveAlias(alias);
+            return await probes.resolveAlias(alias);
         }
         catch {
             return null;
@@ -53,22 +63,24 @@ export async function listClaudeModels(deps = defaultDeps) {
         };
     });
     if (version && resolved.every((model) => model !== null))
-        cacheByVersion.set(version, models);
+        cache.set(cacheKey, models);
     return models;
 }
 /** 仅测试用:清空版本缓存。 */
 export function resetClaudeModelCache() {
     cacheByVersion.clear();
+    cacheByEnvironment = new WeakMap();
 }
-async function probeVersion() {
+async function probeVersion(env = { ...process.env, PATH: augmentedPath() }) {
     const { stdout } = await execFileP("claude", ["--version"], {
         shell: isWin(),
         timeout: PROBE_TIMEOUT_MS,
         killSignal: "SIGKILL",
+        env,
     });
     return stdout;
 }
-function resolveAlias(alias) {
+function resolveAlias(alias, env = { ...process.env, PATH: augmentedPath() }) {
     return new Promise((resolve) => {
         const child = spawn("claude", [
             "--model", alias,
@@ -78,7 +90,7 @@ function resolveAlias(alias) {
         ], {
             cwd: tmpdir(),
             env: {
-                ...process.env,
+                ...env,
                 ANTHROPIC_BASE_URL: UNROUTABLE_API_BASE,
                 CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
             },
@@ -120,4 +132,3 @@ export function initModelOf(line) {
         return null;
     }
 }
-const defaultDeps = { probeVersion, resolveAlias };

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

@@ -0,0 +1,10 @@
+/**
+ * launchd Background policy can stall dsh's synchronous startup reads before ACP.
+ * Apply application resource policy to this short-lived child, never the daemon.
+ * taskpolicy execs the target; no shell, alternate PATH, or protocol bypass.
+ */
+export function deepSeekHarnessLaunch(bin, args, platform = process.platform) {
+    return platform === "darwin"
+        ? { bin: "/usr/sbin/taskpolicy", args: ["-a", "--", bin, ...args] }
+        : { bin, args: [...args] };
+}

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

@@ -0,0 +1,92 @@
+/** 短命执行配置:不读取全局 Harness home,不新增 daemon 状态。 */
+import { mkdtemp, mkdir, writeFile, access } from "node:fs/promises";
+import { join, isAbsolute } from "node:path";
+import { stringify } from "yaml";
+export const harnessPermissionMode = (permission) => permission === "sandboxed"
+    ? "read-only"
+    : permission === "workspace_write"
+        ? "workspace-write"
+        : "danger-full-access";
+// A variable's returned value is interpolated once: literal {{...}} in NowWork
+// instructions must not become unknown Harness template variables.
+const instructionsPlugin = `export const name = 'nowwork-instructions';
+export const inject = ['systemPrompt'];
+export function apply(ctx, config) {
+  ctx.systemPrompt.variable('nowwork_instructions', () => config.text);
+  ctx.systemPrompt.section({name: 'nowwork-instructions', order: 100000, text: '{{nowwork_instructions}}'});
+}
+`;
+export async function prepareHarnessProfile(input) {
+    if (![input.stateRoot, input.cwd, ...input.skillRoots].every(isAbsolute)) {
+        throw new Error("DeepSeek Harness execution paths must be absolute");
+    }
+    if (input.patchPath !== undefined) {
+        if (!isAbsolute(input.patchPath))
+            throw new Error("DeepSeek Harness patch must be absolute");
+        await access(input.patchPath);
+    }
+    await mkdir(input.stateRoot, { recursive: true, mode: 0o700 });
+    const home = await mkdtemp(join(input.stateRoot, ".deepseek-harness-"));
+    const pluginPath = join(home, "nowwork-instructions.mjs");
+    const policyPath = join(home, "nowwork-policy.yml");
+    const mode = harnessPermissionMode(input.effectivePermission);
+    await writeFile(pluginPath, instructionsPlugin, { mode: 0o600 });
+    await writeFile(policyPath, stringify([
+        {
+            id: "sandbox-policy",
+            disabled: false,
+            config: { mode, workspaceRoot: input.cwd },
+        },
+        { id: "approval", disabled: false, config: { policy: "never" } },
+        {
+            id: "permission",
+            disabled: false,
+            config: {
+                defaultPreset: "nowwork",
+                presets: { nowwork: { sandbox: mode, approval: "never" } },
+            },
+        },
+        {
+            id: "skill-filesystem",
+            disabled: false,
+            config: {
+                includeDefaultRoots: false,
+                customSkillDirs: [...input.skillRoots],
+                watch: false,
+            },
+        },
+        {
+            id: "session-persistence-jsonl",
+            disabled: false,
+            config: { root: join(home, "sessions") },
+        },
+        {
+            insert: [
+                {
+                    id: "nowwork-instructions",
+                    name: pluginPath,
+                    config: { text: input.systemPrompt },
+                },
+            ],
+        },
+    ]), { mode: 0o600 });
+    const env = Object.fromEntries(Object.entries(input.env).filter(([key]) => !key.toUpperCase().startsWith("DSH_")));
+    return {
+        home,
+        policyPath,
+        args: [
+            "--profile",
+            "acp",
+            ...(input.patchPath ? ["--patch", input.patchPath] : []),
+            "--patch",
+            policyPath,
+        ],
+        env: {
+            ...env,
+            DSH_HOME: home,
+            DSH_AGENTS_HOME: join(home, "agents-home"),
+            DSH_PERMISSION_MODE: mode,
+            DSH_TELEMETRY_DISABLED: "1",
+        },
+    };
+}

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;
+}