@nowcrew/daemon 0.5.50 → 0.5.52

package/README.md

@@ -222,7 +222,7 @@ the global compatible-machine pool.
 
 The daemon intersects requested permission with local policy, checks advertised resource limits, prepares
 the local workspace/environment, and launches only a built-in runtime adapter (`claude`, `codex`, `kimi`,
-`hermes`, or `opencode`). It does not decide collaboration rules, scheduled output policy, fallback delivery, or thread
+`hermes`, `opencode`, or `deepseek-harness`). It does not decide collaboration rules, scheduled output policy, fallback delivery, or thread
 behavior. Those are server responsibilities.
 
 The stable adapters keep prompts out of provider argv wherever the provider protocol allows it:
@@ -234,6 +234,7 @@ The stable adapters keep prompts out of provider argv wherever the provider prot
 | Kimi | ACP over stdio | `session/prompt` | `session/resume` (`session/load` compatibility fallback) |
 | Hermes | ACP over stdio | `session/prompt` | `session/resume` (`session/load` compatibility fallback) |
 | OpenCode | `run --format json` | stdin | `--session` |
+| DeepSeek Harness | ACP over stdio | `session/prompt` | none (fresh session per execution) |
 
 Kimi ACP currently requires a Kimi account even when the CLI has a working custom provider. Only for
 the explicit `Authentication required` response, the adapter retries once through Kimi's stream-json
@@ -254,16 +255,40 @@ only when `opencode run --help` exposes `--format`, `--dangerously-skip-permissi
 `--model`, `--variant`, and `--session`; older installations remain visible as detected CLIs until
 they are upgraded, rather than falling back to a permission override that user config could weaken.
 
+Install the pinned DeepSeek Harness ACP server on the daemon machine:
+
+```bash
+npm install --global @deepseek-ai/dsh-acp-demo@0.0.1-rc.1
+command -v dsh-acp-demo
+```
+
+The executable is only the ACP app loader; it does not embed a runnable `cordis.yml`. Install or build
+the plugins referenced by your DeepSeek Harness composition, then set both `DEEPSEEK_API_KEY` and an
+absolute `NOWCREW_DEEPSEEK_HARNESS_CONFIG=/path/to/cordis.yml` in the daemon service environment. The
+official repository's `examples/acp-agent/cordis.yml` is the reference composition. A missing or relative
+config path keeps the runtime out of `executionRuntimes`.
+
+`dsh-acp-demo --config <absolute-path>` is launched directly with ACP JSON-RPC on stdio; do not append
+an `acp` subcommand and do not substitute `dsh --profile headless`.
+Provider credentials and model selection remain machine-local. The daemon sets `DSH_PERMISSION_MODE`
+from the effective NowWork permission: `sandboxed` -> `read-only`, `workspace_write` ->
+`workspace-write`, and `full_access` -> `danger-full-access`. Outside full access, an ACP permission
+request is rejected once when that option is unambiguous, otherwise it is cancelled. The current adapter
+uses fresh sessions and committed text; it does not claim resume, images, MCP, reasoning, tool-progress,
+or transcript support. Agent environment variables cannot override `DEEPSEEK_*`, `DSH_*`, or
+`NOWCREW_DEEPSEEK_HARNESS_CONFIG`; those values always come from the daemon service environment.
+
 Codex, Kimi, Hermes, and OpenCode sessions use the same bounded per-task persistence and keyed lease as Claude when they
 run through protocol v1. A first-progress watchdog covers a provider that accepts a turn but remains
 semantically silent; after the first semantic event, the execution's configured total timeout remains
 authoritative so a legitimate long-running tool is not killed for quiet output.
+DeepSeek Harness is execution-v1-only and intentionally skips native session persistence.
 
 Protocol support and limits are advertised in `machine:hello`. `runtimes` reports every recognized CLI
 found on `PATH`; `executionRuntimes` separately reports the installed CLIs backed by a complete built-in
 adapter. The server must use the latter for admission and treats the former as diagnostic inventory only.
 The daemon sends a conservative first hello without waiting for third-party handshakes, then refreshes it
-after the optional Kimi/Hermes/OpenCode probes finish. Work targeting those optional runtimes waits for the
+after the optional Kimi/Hermes/OpenCode/DeepSeek Harness probes finish. Work targeting those optional runtimes waits for the
 same full probe result; reconnects share one in-flight probe, and shutdown aborts any unfinished probe and
 its child process.
 Old daemons that omit `executionRuntimes` are conservatively interpreted as the intersection of installed

package/dist/console.js

@@ -254,13 +254,16 @@ export function toConsoleLines(event) {
     const e = (event ?? {});
     const lang = detectDaemonLang();
     const td = (message) => translateDaemon(lang, message);
-    if (e.type === "kimi.acp.text_delta" && e.text) {
+    if ((e.type === "kimi.acp.text_delta" || e.type === "hermes.acp.text_delta"
+        || e.type === "deepseek-harness.acp.text_delta") && e.text) {
         return [{ stream: "text", text: e.text }];
     }
-    if (e.type === "kimi.acp.tool_call") {
-        return [{ stream: "tool", text: e.title ? `⏺ ${e.title}` : "⏺ Kimi tool" }];
+    if (e.type === "kimi.acp.tool_call" || e.type === "hermes.acp.tool_call"
+        || e.type === "deepseek-harness.acp.tool_call") {
+        return [{ stream: "tool", text: e.title ? `⏺ ${e.title}` : "⏺ ACP tool" }];
     }
-    if (e.type === "kimi.acp.tool_result") {
+    if (e.type === "kimi.acp.tool_result" || e.type === "hermes.acp.tool_result"
+        || e.type === "deepseek-harness.acp.tool_result") {
         const text = typeof e.content === "string" ? e.content.trim() : "";
         return text ? [{ stream: "tool_result", text: clip(text, TOOL_RESULT_CAP) }] : [];
     }

package/dist/control-request-types.js

@@ -0,0 +1 @@
+export {};

package/dist/execution-journal.js

@@ -7,7 +7,7 @@ import { JournalLockedError, createJournalLease, } from "./execution-journal-loc
 export { JournalLockedError, JournalLockCorruptionError } from "./execution-journal-lock.js";
 const ExecutionIdSchema = z.string().uuid();
 const TimestampSchema = z.string().datetime({ offset: true });
-const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode"]);
+const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness"]);
 const RUNTIME_READY_SUFFIX = ".runtime-ready";
 const RawJournalEntrySchema = z.object({
     executionId: ExecutionIdSchema,

package/dist/execution-protocol.js

@@ -8,7 +8,7 @@ const MIN_SIGNED_32_INTEGER = -2_147_483_648;
 const SequenceSchema = z.number().int().min(0).max(MAX_PG_INTEGER);
 const TokenCountSchema = z.number().int().min(0).max(MAX_PG_INTEGER);
 const ExitCodeSchema = z.number().int().min(MIN_SIGNED_32_INTEGER).max(MAX_PG_INTEGER);
-const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode"]);
+const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness"]);
 const UnsafePathCharacterSchema = /[\p{Cc}<>:"/\\|?*]/u;
 const WindowsReservedNameSchema = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i;
 export const AgentHandleSchema = z.string().min(1).max(64).refine((handle) => handle !== "."

package/dist/execution-runner.js

@@ -172,6 +172,8 @@ function validReasoning(spec) {
     if (spec.runtime.name === "kimi") {
         return KIMI_EFFORT_LEVELS.includes(reasoning);
     }
+    if (spec.runtime.name === "deepseek-harness")
+        return false;
     return true;
 }
 function launchProviderConfig(config) {

package/dist/external-output.js

@@ -63,6 +63,7 @@ export function decodeExternalOutputEvent(runtime, event, decoder) {
             : [];
     }
     if ((runtime === "hermes" && candidate.type === "hermes.acp.text_delta")
+        || (runtime === "deepseek-harness" && candidate.type === "deepseek-harness.acp.text_delta")
         || (runtime === "opencode" && candidate.type === "opencode.text_delta")) {
         return typeof candidate.text === "string" ? decoder.push(candidate.text) : [];
     }

package/dist/local-executor.js

@@ -6,7 +6,7 @@ import { spawnClaude } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
 import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
 import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
-import { applyProviderEnv, providerFingerprint } from "./provider-env.js";
+import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, } from "./provider-env.js";
 import { augmentedPath } from "./runtime-path.js";
 import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
@@ -115,14 +115,15 @@ export function awaitExit(child) {
 }
 export function exitActivity(runtime, exitCode, stderrTail) {
     if ((runtime === "codex" || runtime === "kimi" || runtime === "hermes"
-        || runtime === "opencode" || exitCode === -1) && exitCode !== 0) {
+        || runtime === "opencode" || runtime === "deepseek-harness" || exitCode === -1) && exitCode !== 0) {
         return {
             kind: "error",
             label: "运行出错",
             detail: `${runtime} exited with code ${exitCode}${stderrTail ? `: ${stderrTail}` : ""}`,
         };
     }
-    if ((runtime === "kimi" || runtime === "hermes" || runtime === "opencode") && exitCode === 0) {
+    if ((runtime === "kimi" || runtime === "hermes" || runtime === "opencode"
+        || runtime === "deepseek-harness") && exitCode === 0) {
         return { kind: "done", label: "本轮结束" };
     }
     return null;
@@ -136,6 +137,9 @@ function wrapChild(child) {
     };
 }
 async function launchLegacyRuntime(request) {
+    if (request.runtime === "deepseek-harness") {
+        throw new Error("DeepSeek Harness requires execution protocol v1");
+    }
     const common = {
         bin: request.bin,
         cwd: request.cwd,
@@ -463,7 +467,10 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 ? { KIMI_MODEL_THINKING_EFFORT: runtime.reasoning }
                 : {}),
         };
-        const childEnv = applyProviderEnv(baseEnv, runtime.name, providerConfig, workspace.homeDir);
+        const providerEnv = applyProviderEnv(baseEnv, runtime.name, providerConfig, workspace.homeDir);
+        const childEnv = runtime.name === "deepseek-harness"
+            ? applyDeepSeekHarnessMachineEnv(providerEnv, inheritedEnv)
+            : providerEnv;
         const launchRuntime = dependencies.launchRuntime ?? launchLegacyRuntime;
         if (dependencies.cancellation?.isRequested())
             throw new RuntimeCancelledError();
@@ -492,7 +499,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         memoryPruneFailurePhase = "runtime_launch";
         const launchRequest = {
             runtime: runtime.name,
-            bin: runtime.name,
+            bin: runtime.name === "deepseek-harness" ? "dsh-acp-demo" : runtime.name,
             cwd: executionWorkspace.runDir,
             ...(input.projectSkills === undefined ? {} : { agentRoot: workspace.dir }),
             systemPromptPath: workspace.systemPromptPath,
@@ -572,7 +579,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             if (extracted) {
                 const incremental = typeof event === "object" && event !== null
                     && "type" in event && (event.type === "kimi.acp.text_delta"
-                    || event.type === "hermes.acp.text_delta" || event.type === "opencode.text_delta");
+                    || event.type === "hermes.acp.text_delta"
+                    || event.type === "deepseek-harness.acp.text_delta"
+                    || event.type === "opencode.text_delta");
                 finalText = incremental ? `${finalText ?? ""}${extracted}` : extracted;
             }
             for (const text of decodeExternalOutputEvent(runtime.name, event, externalOutput)) {

package/dist/machine-info.js

@@ -17,6 +17,8 @@ import { executionBackendCapability } from "./execution-backend.js";
 import { probeKimiAcp } from "./runtimes/kimi-acp-runner.js";
 import { probeHermesAcp } from "./runtimes/hermes.js";
 import { probeOpenCodeRun } from "./runtimes/opencode.js";
+import { RUNTIME_HEALTH_PROBE_CAPABILITY } from "./runtime-health.js";
+import { probeDeepSeekHarnessAcp } from "./runtimes/deepseek-harness.js";
 export { executableRuntimes } from "./runtime-capabilities.js";
 const execFileP = promisify(execFile);
 export const DAEMON_CAPABILITIES = [
@@ -30,6 +32,7 @@ export const DAEMON_CAPABILITIES = [
     "execution_machine_queue_v1",
     "execution_agent_memory_policy_v1",
     "project_skills_v1",
+    RUNTIME_HEALTH_PROBE_CAPABILITY,
 ];
 export const daemonCapabilities = (runtimePlatform = process.platform) => runtimePlatform === "darwin" || runtimePlatform === "linux"
     ? DAEMON_CAPABILITIES
@@ -43,6 +46,7 @@ const RUNTIME_BINS = [
     ["gemini", "gemini"],
     ["hermes", "hermes"],
     ["opencode", "opencode"],
+    ["deepseek-harness", "dsh-acp-demo"],
     ["copilot", "copilot"],
     ["kimi", "kimi"],
     ["pi", "pi"],
@@ -71,20 +75,25 @@ async function supportsHermesAcp(signal) {
 async function supportsOpenCodeRun(signal) {
     return probeOpenCodeRun(signal);
 }
+async function supportsDeepSeekHarnessAcp(signal) {
+    return probeDeepSeekHarnessAcp({ bin: "dsh-acp-demo", ...(signal ? { signal } : {}) });
+}
 /** Runtime adapters that can satisfy the durable protocol-v1 process contract. */
-export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, signal) {
+export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, deepSeekHarnessProbe = supportsDeepSeekHarnessAcp, signal) {
     const present = await installed;
-    const [kimiReady, hermesReady, openCodeReady] = await Promise.all([
+    const [kimiReady, hermesReady, openCodeReady, deepSeekHarnessReady] = await Promise.all([
         present.includes("kimi") ? kimiAcpProbe(signal) : false,
         present.includes("hermes") ? hermesAcpProbe(signal) : false,
         present.includes("opencode") ? openCodeProbe(signal) : false,
+        present.includes("deepseek-harness") ? deepSeekHarnessProbe(signal) : false,
     ]);
     return executableRuntimes(present).filter((runtime) => (runtime === "kimi" ? kimiReady
         : runtime === "hermes" ? hermesReady
             : runtime === "opencode" ? openCodeReady
-                : true));
+                : runtime === "deepseek-harness" ? deepSeekHarnessReady
+                    : true));
 }
-export const detectExecutionRuntimesWithSignal = (installed, signal) => detectExecutionRuntimes(installed, supportsKimiAcp, supportsHermesAcp, supportsOpenCodeRun, signal);
+export const detectExecutionRuntimesWithSignal = (installed, signal) => detectExecutionRuntimes(installed, supportsKimiAcp, supportsHermesAcp, supportsOpenCodeRun, supportsDeepSeekHarnessAcp, signal);
 export function daemonVersion() {
     try {
         const here = dirname(fileURLToPath(import.meta.url));

package/dist/normalize.js

@@ -35,6 +35,7 @@ export function classifyCommand(command) {
 export function extractFinalText(event) {
     const e = (event ?? {});
     if ((e.type === "kimi.acp.text_delta" || e.type === "hermes.acp.text_delta"
+        || e.type === "deepseek-harness.acp.text_delta"
         || e.type === "opencode.text_delta") && e.text)
         return e.text;
     if (e.type === "result" && !e.is_error && e.result?.trim())
@@ -63,15 +64,16 @@ function parseKimiBashCommand(args) {
 export function normalizeEvent(event) {
     const e = (event ?? {});
     if ((e.type === "kimi.acp.text_delta" || e.type === "hermes.acp.text_delta"
+        || e.type === "deepseek-harness.acp.text_delta"
         || e.type === "opencode.text_delta") && e.text?.trim()) {
         return [{ kind: "text", label: "思考/说明", detail: e.text }];
     }
     if (e.type === "kimi.acp.tool_call" || e.type === "hermes.acp.tool_call"
-        || e.type === "opencode.tool_call") {
+        || e.type === "deepseek-harness.acp.tool_call" || e.type === "opencode.tool_call") {
         return [{ kind: "tool", label: e.title ? `工具:${e.title}` : "工具调用" }];
     }
     if (e.type === "kimi.acp.tool_result" || e.type === "hermes.acp.tool_result"
-        || e.type === "opencode.tool_result") {
+        || e.type === "deepseek-harness.acp.tool_result" || e.type === "opencode.tool_result") {
         return [{ kind: "tool_result", label: "工具返回" }];
     }
     if (e.type === "system" && e.subtype === "init") {

package/dist/provider-env.js

@@ -10,6 +10,7 @@
  */
 import { join } from "node:path";
 import { DEEPSEEK_CODEX_KEY_ENV, deepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
+import { DEEPSEEK_HARNESS_CONFIG_ENV } from "./runtimes/deepseek-harness.js";
 /** custom 模式下必须从继承 env 中剔除的全局路由/凭证变量(避免与注入值叠加或抢优先级)。 */
 const CONFLICTING_ENV = [
     "ANTHROPIC_BASE_URL",
@@ -72,6 +73,22 @@ export function applyProviderEnv(base, runtime, cfg, homeDir) {
     }
     return env;
 }
+const deepSeekHarnessMachineOwnedKey = (key) => (key.startsWith("DEEPSEEK_")
+    || key === DEEPSEEK_HARNESS_CONFIG_ENV
+    || key.startsWith("DSH_"));
+/** Agent env remains available to tools, but cannot replace Harness process policy or credentials. */
+export function applyDeepSeekHarnessMachineEnv(base, machineEnv) {
+    const env = { ...base };
+    for (const key of Object.keys(env)) {
+        if (deepSeekHarnessMachineOwnedKey(key))
+            delete env[key];
+    }
+    for (const [key, value] of Object.entries(machineEnv)) {
+        if (deepSeekHarnessMachineOwnedKey(key) && value !== undefined)
+            env[key] = value;
+    }
+    return env;
+}
 /**
  * provider 关键配置指纹:Claude Custom 路由和 Codex DeepSeek key 有无都会改变会话边界,
  * 供 pickResumeId 判定冷启动。default 恒为 null;不含 key 明文(同 Provider 换 key 可续)。

package/dist/runtime-capabilities.js

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

package/dist/runtime-health.js

@@ -0,0 +1,158 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { augmentedPath } from "./runtime-path.js";
+export const RUNTIME_HEALTH_PROBE_CAPABILITY = "runtime_health_probe_v1";
+export const RUNTIME_HEALTH_NAMES = ["claude", "codex", "opencode", "kimi"];
+const RuntimeProbeTargetSchema = z.object({
+    runtime: z.enum(RUNTIME_HEALTH_NAMES),
+    modelId: z.string().min(1).max(200).nullable(),
+    configFingerprint: z.string().min(1).max(200).nullable(),
+}).strict();
+export const RuntimeProbeRequestSchema = z.object({
+    runtimes: z.array(RuntimeProbeTargetSchema).min(1).max(RUNTIME_HEALTH_NAMES.length),
+    timeoutMs: z.number().int().min(10).max(60_000),
+}).strict().superRefine((value, context) => {
+    const seen = new Set();
+    for (let index = 0; index < value.runtimes.length; index += 1) {
+        const runtime = value.runtimes[index]?.runtime;
+        if (runtime === undefined || !seen.has(runtime)) {
+            if (runtime !== undefined)
+                seen.add(runtime);
+            continue;
+        }
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["runtimes", index, "runtime"],
+            message: "duplicate runtime",
+        });
+    }
+});
+export const RuntimeProbeFrameSchema = z.object({
+    type: z.literal("runtime-health:probe"),
+    reqId: z.string().min(1).max(128),
+    runtimes: z.array(RuntimeProbeTargetSchema).min(1).max(RUNTIME_HEALTH_NAMES.length),
+    timeoutMs: z.number().int().min(10).max(60_000),
+}).strict();
+const execFileAsync = promisify(execFile);
+const defaultExecutor = async (file, args, options) => {
+    const result = await execFileAsync(file, [...args], options);
+    return { stdout: String(result.stdout), stderr: String(result.stderr) };
+};
+const adapterOf = (_runtime) => "executable";
+function modelArgs(runtime, modelId) {
+    const model = modelId === null ? [] : ["--model", modelId];
+    if (runtime === "claude")
+        return ["--print", "--output-format", "json", ...model, "Reply only OK."];
+    if (runtime === "codex")
+        return ["exec", "--json", "--skip-git-repo-check", ...model, "Reply only OK."];
+    if (runtime === "opencode")
+        return ["run", "--format", "json", ...model, "Reply only OK."];
+    if (runtime === "kimi")
+        return ["--print", "--output-format", "json", ...model, "Reply only OK."];
+    return [];
+}
+function failureText(error) {
+    if (!error || typeof error !== "object")
+        return String(error);
+    const value = error;
+    return [value.message, value.stdout, value.stderr].filter((part) => typeof part === "string")
+        .join("\n").toLowerCase().slice(0, 32_000);
+}
+function failureCode(error) {
+    const text = failureText(error);
+    if (/quota|insufficient[_ ]quota|credit balance/.test(text))
+        return "quota_exhausted";
+    if (/\b401\b|unauthori[sz]ed|invalid api[_ -]?key|authentication failed/.test(text))
+        return "auth_failed";
+    if (/model.{0,80}(not found|does not exist|unknown)/.test(text))
+        return "model_not_found";
+    if (/model.{0,80}(mapping|alias).{0,40}(invalid|missing|failed)/.test(text))
+        return "mapping_invalid";
+    if (/\b429\b|rate.?limit|too many requests/.test(text))
+        return "rate_limited";
+    if (/\b5\d\d\b|upstream|bad gateway|service unavailable/.test(text))
+        return "upstream_error";
+    return "upstream_error";
+}
+const isMissing = (error) => typeof error === "object" && error !== null && error.code === "ENOENT";
+const isAbort = (error) => typeof error === "object" && error !== null && error.name === "AbortError";
+async function runBounded(execute, file, args, timeoutMs, env) {
+    const controller = new AbortController();
+    let timer;
+    try {
+        return await Promise.race([
+            execute(file, args, {
+                env,
+                signal: controller.signal,
+                timeout: timeoutMs,
+                maxBuffer: 64 * 1024,
+            }),
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => {
+                    controller.abort();
+                    reject(Object.assign(new Error("runtime health probe timed out"), { name: "AbortError" }));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+export async function probeRuntimeHealth(request, dependencies = {}) {
+    const parsed = RuntimeProbeRequestSchema.parse(request);
+    const execute = dependencies.execute ?? defaultExecutor;
+    const now = dependencies.now ?? (() => new Date());
+    const monotonicNow = dependencies.monotonicNow ?? (() => performance.now());
+    const sourceEnv = dependencies.env ?? process.env;
+    const env = { ...sourceEnv, PATH: augmentedPath(sourceEnv) };
+    return Promise.all(parsed.runtimes.map(async (target) => {
+        const started = monotonicNow();
+        const checkedAt = now().toISOString();
+        const base = {
+            runtime: target.runtime,
+            adapter: adapterOf(target.runtime),
+            modelId: target.modelId,
+            configFingerprint: target.configFingerprint,
+            checkedAt,
+        };
+        const latencyMs = () => Math.max(0, Math.round(monotonicNow() - started));
+        try {
+            await runBounded(execute, target.runtime, ["--version"], parsed.timeoutMs, env);
+        }
+        catch (error) {
+            return {
+                ...base,
+                installation: isMissing(error) ? "missing" : "timeout",
+                model: "not_checked",
+                latencyMs: latencyMs(),
+                detailCode: isMissing(error) ? "executable_missing" : "version_timeout",
+            };
+        }
+        if (base.adapter !== "executable") {
+            return { ...base, installation: "available", model: "not_checked", latencyMs: latencyMs(), detailCode: null };
+        }
+        try {
+            await runBounded(execute, target.runtime, modelArgs(target.runtime, target.modelId), parsed.timeoutMs, env);
+            return { ...base, installation: "available", model: "ok", latencyMs: latencyMs(), detailCode: null };
+        }
+        catch (error) {
+            const code = isAbort(error) ? "timeout" : failureCode(error);
+            return { ...base, installation: "available", model: code, latencyMs: latencyMs(), detailCode: code };
+        }
+    }));
+}
+export async function handleRuntimeProbeFrame(decoded, probe = probeRuntimeHealth) {
+    const frame = RuntimeProbeFrameSchema.safeParse(decoded);
+    if (!frame.success)
+        return null;
+    try {
+        const data = await probe({ runtimes: frame.data.runtimes, timeoutMs: frame.data.timeoutMs });
+        return { reqId: frame.data.reqId, ok: true, data };
+    }
+    catch {
+        return { reqId: frame.data.reqId, ok: false, error: "runtime_health_probe_failed" };
+    }
+}

package/dist/runtime-startup-gate.js

@@ -79,6 +79,7 @@ export function createRuntimeStartupGate(limits, now = Date.now) {
                 kimi: activeByRuntime.get("kimi") ?? 0,
                 hermes: activeByRuntime.get("hermes") ?? 0,
                 opencode: activeByRuntime.get("opencode") ?? 0,
+                "deepseek-harness": activeByRuntime.get("deepseek-harness") ?? 0,
             },
         }),
     };

package/dist/runtimes/deepseek-harness.js

@@ -0,0 +1,20 @@
+import spawn from "cross-spawn";
+import { isAbsolute } from "node:path";
+import { probeKimiAcp } from "./kimi-acp-runner.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;
+}
+/** 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);
+}

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

@@ -1,4 +1,5 @@
 import { once } from "node:events";
+import { isAbsolute } from "node:path";
 import { parseArgs } from "node:util";
 import { Readable, Writable } from "node:stream";
 import { pathToFileURL } from "node:url";
@@ -92,7 +93,13 @@ export function kimiResumeMethod(capabilities) {
     return null;
 }
 /** Full access may approve an operation, but it must never fabricate an answer to an agent question. */
-export function selectKimiPermission(params) {
+export function selectKimiPermission(params, permission = "full_access") {
+    if (permission !== "full_access") {
+        const rejected = params.options.filter((option) => option.kind === "reject_once");
+        return rejected.length === 1
+            ? { outcome: { outcome: "selected", optionId: rejected[0].optionId } }
+            : { outcome: { outcome: "cancelled" } };
+    }
     const allowOnce = params.options.filter((option) => option.kind === "allow_once");
     if (params.toolCall.title === "AskUserQuestion" || allowOnce.length > 1) {
         return { outcome: { outcome: "cancelled" } };
@@ -105,6 +112,31 @@ export function selectKimiPermission(params) {
         ? { outcome: { outcome: "cancelled" } }
         : { outcome: { outcome: "selected", optionId: allowed.optionId } };
 }
+function providerArgs(provider, configPath) {
+    if (provider !== "deepseek-harness")
+        return ["acp"];
+    if (!configPath || !isAbsolute(configPath)) {
+        throw new Error("DeepSeek Harness ACP requires an absolute config path");
+    }
+    return ["--config", configPath];
+}
+function deepSeekPermissionMode(permission) {
+    if (permission === "sandboxed")
+        return "read-only";
+    if (permission === "workspace_write")
+        return "workspace-write";
+    return "danger-full-access";
+}
+function providerEnv(provider, permission) {
+    return provider === "deepseek-harness"
+        ? { ...process.env, DSH_PERMISSION_MODE: deepSeekPermissionMode(permission) }
+        : process.env;
+}
+function providerDisplayName(provider) {
+    if (provider === "deepseek-harness")
+        return "DeepSeek Harness";
+    return provider === "kimi" ? "Kimi" : "Hermes";
+}
 function selectConfigId(options, category) {
     const normalizedNames = category === "model"
         ? new Set(["model"])
@@ -164,10 +196,11 @@ 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"], {
+    const permission = options.effectivePermission ?? "sandboxed";
+    const child = spawnProcess(options.bin, providerArgs(provider, options.configPath), {
         cwd: process.cwd(),
         // probe 在 daemon 自身 PATH 下运行,补上用户级 CLI 目录,与 which 探测保持一致。
-        env: { ...process.env, PATH: augmentedPath() },
+        env: { ...providerEnv(provider, permission), PATH: augmentedPath() },
         stdio: ["pipe", "pipe", "pipe"],
     });
     if (child.stdin === null || child.stdout === null || child.stderr === null)
@@ -224,11 +257,15 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
 }
 export async function runKimiAcp(options) {
     const provider = options.provider ?? "kimi";
-    const displayName = provider === "kimi" ? "Kimi" : "Hermes";
+    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 child = spawn(options.bin, ["acp"], {
+    const child = spawn(options.bin, providerArgs(provider, options.configPath), {
         cwd: process.cwd(),
-        env: process.env,
+        env: providerEnv(provider, permission),
         stdio: ["pipe", "pipe", "pipe"],
     });
     let runtimeChild = child;
@@ -256,7 +293,7 @@ export async function runKimiAcp(options) {
     process.once("SIGTERM", onSignal);
     process.once("SIGINT", onSignal);
     const app = client({ name: `nowcrew-daemon-${provider}` })
-        .onRequest(methods.client.session.requestPermission, ({ params }) => selectKimiPermission(params))
+        .onRequest(methods.client.session.requestPermission, ({ params }) => selectKimiPermission(params, permission))
         .onNotification(methods.client.session.update, async ({ params }) => {
         acpSemanticProgress = true;
         firstProgress.observe();
@@ -416,13 +453,19 @@ function optionsFromArgv(argv) {
             reasoning: { type: "string" },
             session: { type: "string" },
             resume: { type: "boolean", default: false },
+            permission: { type: "string", default: "full_access" },
+            config: { type: "string" },
         },
     });
     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.provider !== "kimi" && values.provider !== "hermes"
+        && values.provider !== "deepseek-harness") {
+        throw new Error("--provider must be kimi, hermes, or deepseek-harness");
     }
+    if (values.permission !== "sandboxed" && values.permission !== "workspace_write"
+        && values.permission !== "full_access")
+        throw new Error("invalid --permission");
     if (values.resume && !values.session)
         throw new Error("--resume requires --session");
     return {
@@ -432,6 +475,8 @@ function optionsFromArgv(argv) {
         ...(values.reasoning ? { reasoning: values.reasoning } : {}),
         ...(values.session ? { sessionId: values.session } : {}),
         ...(values.resume ? { resume: true } : {}),
+        effectivePermission: values.permission,
+        ...(values.config ? { configPath: values.config } : {}),
     };
 }
 if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {

package/dist/serve.js

@@ -42,6 +42,7 @@ import { PROJECT_SKILLS_CAPABILITY } from "./project-skills/types.js";
 import { createAgentProjectionCoordinator } from "./project-skills/agent-projection-coordinator.js";
 import { createProjectSkillsReconciler, ProjectProjectionError, } from "./project-skills/reconciler.js";
 import { parseMemoryPruneTraceId } from "./memory-prune-diagnostics.js";
+import { handleRuntimeProbeFrame, probeRuntimeHealth } from "./runtime-health.js";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
     init: "working", text: "thinking", reading: "reading", sending: "sending",
@@ -698,6 +699,16 @@ export function serve(config, opts = {}) {
                 catch { /* server 会按请求超时处理 */ }
                 return;
             }
+            if (msg.type === "runtime-health:probe") {
+                const result = await handleRuntimeProbeFrame(msg, opts.runtimeHealth?.probe ?? probeRuntimeHealth);
+                if (result !== null) {
+                    try {
+                        ws?.send(JSON.stringify({ type: "fs:result", ...result }));
+                    }
+                    catch { /* server 会超时 */ }
+                }
+                return;
+            }
             // 导入 raft agent 工作区:inspect 反填 name/description;import 复制用户内容
             if (msg.type === "raft:inspect" || msg.type === "raft:import") {
                 const req = msg;

package/dist/supervised-runtime.js

@@ -2,6 +2,7 @@ import { fileURLToPath } from "node:url";
 import { join } from "node:path";
 import { startDormantSupervisor, } from "./execution-supervisor.js";
 import { buildClaudeArgs } from "./runtimes/claude.js";
+import { DEEPSEEK_HARNESS_CONFIG_ENV, deepSeekHarnessConfigPath, } from "./runtimes/deepseek-harness.js";
 import { RuntimeCancelledError } from "./runtime-cancellation.js";
 export function supervisorLaunch(request) {
     const common = {
@@ -74,6 +75,27 @@ export function supervisorLaunch(request) {
             stdinText: `${request.systemPrompt}\n\n${request.wakePrompt}`,
         };
     }
+    if (request.runtime === "deepseek-harness") {
+        if (request.resume)
+            throw new Error("DeepSeek Harness ACP does not support session resume");
+        const configPath = deepSeekHarnessConfigPath();
+        if (configPath === null) {
+            throw new Error(`${DEEPSEEK_HARNESS_CONFIG_ENV} must be an absolute path`);
+        }
+        return {
+            command: process.execPath,
+            args: [
+                fileURLToPath(new URL("./runtimes/kimi-acp-runner.js", import.meta.url)),
+                "--provider", "deepseek-harness",
+                "--bin", request.bin,
+                "--config", configPath,
+                "--permission", request.effectivePermission,
+            ],
+            cwd: request.cwd,
+            env: request.env,
+            stdinText: `${request.systemPrompt}\n\n${request.wakePrompt}`,
+        };
+    }
     if (request.effectivePermission !== "full_access") {
         const displayName = request.runtime === "hermes" ? "Hermes" : "Kimi";
         throw new Error(`${displayName} ACP cannot enforce ${request.effectivePermission} permission`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.5.50",
+  "version": "0.5.52",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",