@nowcrew/daemon 0.6.88 → 0.6.90

package/dist/local-runtime-environment.js

@@ -0,0 +1,50 @@
+import { delimiter, join } from "node:path";
+import { environmentForExecution } from "./agent-environments.js";
+import { augmentedPath } from "./runtime-path.js";
+import { sanitizeEnvVars } from "./runtime-env.js";
+import { machinePackageManagerEnv } from "./package-manager-env.js";
+import { KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
+import { mergeRuntimeEnvironments } from "./runtime-environment-merge.js";
+/** 机器、目录与受控运行字段分层合并，Windows 不依赖对象中键名的偶然顺序。 */
+export function buildLocalRuntimeEnvironment(context) {
+    const { input, workspace, executionWorkspace, inheritedEnv, providerConfig, crewHome, contextThreadId, nativeThreadContextPath, reportContext, runtime } = context;
+    const agentEnvironment = sanitizeEnvVars(providerConfig.environmentPlan === undefined ? providerConfig.envVars
+        : environmentForExecution(providerConfig.environmentPlan, workspace.dir, input.projectContext?.primary?.root ?? executionWorkspace.runDir, input.projectContext?.primary?.projectId));
+    return mergeRuntimeEnvironments([
+        inheritedEnv, agentEnvironment,
+        input.trainingProjectContext === undefined ? {} : machinePackageManagerEnv(inheritedEnv),
+        input.launch.systemEnv ?? {}, {
+            PATH: `${workspace.crewDir}${delimiter}${augmentedPath(inheritedEnv, {}, process.platform, "append")}`,
+            CREW_SERVER_URL: input.launch.serverUrl,
+            CREW_TOKEN: input.launch.token,
+            CREW_CHANNEL: input.channelId,
+            CREW_HOME: crewHome,
+            // Empty values override any stale inherited hints from an enclosing runtime.
+            CREW_THREAD_ROOT: contextThreadId ?? "",
+            CREW_THREAD_CONTEXT_FILE: nativeThreadContextPath ?? "",
+            // Keep the daemon-selected storage root authoritative for runtimes.
+            // In profile-backed NowWork sessions the daemon config may differ from
+            // the daemon process environment, so inheriting CREW_AGENTS_ROOT is not
+            // sufficient for QA/project diagnostics.
+            CREW_AGENTS_ROOT: input.launch.agentsRoot,
+            ...(input.launch.reposRoot === undefined ? {} : { NOWWORK_REPOS_ROOT: input.launch.reposRoot }),
+            ...(input.launch.qaReportRoot === undefined ? {} : { QA_REPORT_HUB: input.launch.qaReportRoot }),
+            // Expose only the training root; ability-specific workspace layout stays
+            // owned by the training package rather than the NowWork daemon.
+            QA_RUNTIME_ROOT: join(crewHome, "training"),
+            QA_REPORT_DELIVERY_CONTEXT: JSON.stringify(reportContext),
+            CREW_TASK_DIR: executionWorkspace.runDir,
+            CREW_TASK_LOG: executionWorkspace.workLogPath,
+            ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
+            XDG_CONFIG_HOME: join(workspace.homeDir, ".config"),
+            XDG_DATA_HOME: join(workspace.homeDir, ".local", "share"),
+            XDG_CACHE_HOME: join(workspace.homeDir, ".cache"),
+            GH_CONFIG_DIR: join(workspace.homeDir, ".config", "gh"),
+            CLOUDSDK_CONFIG: join(workspace.homeDir, ".config", "gcloud"),
+            ...(runtime.name === "kimi" && runtime.reasoning
+                && KIMI_EFFORT_LEVELS.includes(runtime.reasoning)
+                ? { KIMI_MODEL_THINKING_EFFORT: runtime.reasoning }
+                : {}),
+        },
+    ]);
+}

package/dist/machine-environment-cache.js

@@ -0,0 +1,147 @@
+import { randomUUID } from "node:crypto";
+import { MachineEnvironmentCaptureError } from "./machine-environment-contract.js";
+import { copyMachineEnvironment, machineCaptureStartupEnvironment, resolveMachineAccount, restoreMachineEnvironmentOwnership, selectMachineEnvironmentSource, validateMachineEnvironment } from "./machine-environment-policy.js";
+import { captureShellMachineEnvironment, machineEnvironmentSourceFingerprint, machineShellSourceLocations } from "./machine-shell-environment-capture.js";
+function frozenStatus(status) {
+    return Object.freeze({ ...status, sourceLocations: Object.freeze([...new Set(status.sourceLocations)].slice(0, 8)) });
+}
+/** 测试或明确关闭机器环境时使用；永远不会启动 shell，也不读取真实用户 rc。 */
+export function createStaticMachineEnvironmentProvider(startupEnv = {}) {
+    const snapshot = Object.freeze({ env: copyMachineEnvironment(startupEnv), status: frozenStatus({ bootId: randomUUID(), generation: 0, state: "disabled", source: null, sourceLocations: [], capturedAt: null, attemptedAt: null, errorCode: null }) });
+    return { acquire: async () => snapshot, status: () => snapshot.status, stop: async () => { } };
+}
+const sameEnvironment = (left, right) => {
+    const keys = Object.keys(left);
+    return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && left[key] === right[key]);
+};
+export function createMachineEnvironmentProvider(options = {}) {
+    const startup = copyMachineEnvironment(options.startupEnv ?? process.env);
+    const mode = options.mode ?? "auto";
+    const platform = options.platform ?? process.platform;
+    const now = options.now ?? Date.now;
+    let account = Object.freeze({ ...(options.account ?? resolveMachineAccount()) });
+    const selected = selectMachineEnvironmentSource(mode, account, startup, platform);
+    const baseline = startup;
+    const captureStartup = machineCaptureStartupEnvironment(startup, account, platform);
+    let watchedLocations = machineShellSourceLocations({ source: selected.source ?? "windows-registry", account, startupEnv: captureStartup });
+    let sourceFingerprint = null;
+    let snapshot = Object.freeze({ env: baseline, status: frozenStatus({ bootId: randomUUID(), generation: 0, state: mode === "off" ? "disabled" : selected.source === null ? "unsupported" : "loading", source: selected.source, sourceLocations: watchedLocations, capturedAt: null, attemptedAt: null, errorCode: null }) });
+    let lastGood = null;
+    let lastSuccessTime = -Infinity;
+    let lastFailureTime = -Infinity;
+    let stopped = false;
+    let unsafeCleanup = false;
+    let flight;
+    let controller;
+    let captureEpoch = 0;
+    let capturing = false;
+    let forcedFollowup;
+    const sourceOwnedKeys = new Set();
+    const publish = (env, patch) => {
+        snapshot = Object.freeze({ env, status: frozenStatus({ ...snapshot.status, ...patch }) });
+        try {
+            options.onChange?.(snapshot);
+        }
+        catch { /* 观察者失败不能污染已获取的机器环境。 */ }
+        return snapshot;
+    };
+    const captureWindows = options.captureWindows ?? (async (request) => {
+        const module = await import("./machine-windows-environment-capture.js");
+        return module.captureWindowsMachineEnvironment(request);
+    });
+    const refresh = async (force, signal) => {
+        if (!selected.source || stopped || unsafeCleanup)
+            return snapshot;
+        if (!force && now() - lastFailureTime < (options.backoffMs ?? 30_000))
+            return snapshot;
+        const attemptedAt = new Date(now()).toISOString();
+        try {
+            if (!force && lastGood && now() - lastSuccessTime < (options.ttlMs ?? 60_000)) {
+                if (selected.source === "windows-registry" || sourceFingerprint === await machineEnvironmentSourceFingerprint(watchedLocations))
+                    return snapshot;
+            }
+            if (stopped || signal.aborted)
+                return snapshot;
+            publish(snapshot.env, { state: "loading", attemptedAt, errorCode: null });
+            capturing = true;
+            const deadline = Date.now() + (options.captureTimeoutMs ?? (selected.source === "windows-registry" ? 8_000 : 5_000));
+            const capture = selected.source === "windows-registry" ? captureWindows : options.captureShell ?? captureShellMachineEnvironment;
+            for (let attempt = 0; attempt < 2; attempt++) {
+                try {
+                    const before = selected.source === "windows-registry" ? null : await machineEnvironmentSourceFingerprint(watchedLocations);
+                    captureEpoch++;
+                    const captured = await capture({ startupEnv: captureStartup, account, source: selected.source, ...(selected.shellPath ? { shellPath: selected.shellPath } : {}), signal, deadline });
+                    if (signal.aborted)
+                        throw new MachineEnvironmentCaptureError("shell_capture_timeout");
+                    if (before !== null && before !== await machineEnvironmentSourceFingerprint(watchedLocations))
+                        throw new MachineEnvironmentCaptureError("shell_files_changed");
+                    let env = validateMachineEnvironment(captured.env);
+                    let currentOwned;
+                    if (selected.source === "windows-registry") {
+                        currentOwned = new Set((captured.sourceOwnedKeys ?? []).map((key) => key.toUpperCase()));
+                        const merged = new Map();
+                        for (const [key, value] of [...Object.entries(startup), ...Object.entries(env)]) {
+                            if (!sourceOwnedKeys.has(key.toUpperCase()) || currentOwned.has(key.toUpperCase()))
+                                merged.set(key.toUpperCase(), [key, value]);
+                        }
+                        env = Object.fromEntries(merged.values());
+                    }
+                    env = validateMachineEnvironment(restoreMachineEnvironmentOwnership(env, startup, account, platform));
+                    const unchanged = lastGood !== null && sameEnvironment(lastGood.env, env);
+                    const generation = unchanged && lastGood ? lastGood.status.generation : (lastGood?.status.generation ?? 0) + 1;
+                    const locations = [...new Set(captured.sourceLocations)].slice(0, 8);
+                    watchedLocations = locations;
+                    sourceFingerprint = selected.source === "windows-registry" ? null : await machineEnvironmentSourceFingerprint(locations);
+                    for (const key of currentOwned ?? [])
+                        sourceOwnedKeys.add(key);
+                    if (selected.source === "windows-registry" && captured.accountSid)
+                        account = Object.freeze({ ...account, sid: captured.accountSid });
+                    lastSuccessTime = now();
+                    lastFailureTime = -Infinity;
+                    lastGood = publish(unchanged && lastGood ? lastGood.env : env, { state: "ready", generation, sourceLocations: locations, capturedAt: new Date(lastSuccessTime).toISOString(), errorCode: null });
+                    return lastGood;
+                }
+                catch (error) {
+                    if (error instanceof MachineEnvironmentCaptureError && error.code === "shell_files_changed" && attempt === 0 && Date.now() < deadline && !signal.aborted)
+                        continue;
+                    throw error;
+                }
+            }
+            throw new MachineEnvironmentCaptureError("shell_files_changed");
+        }
+        catch (error) {
+            const errorCode = error instanceof MachineEnvironmentCaptureError ? error.code : selected.source === "windows-registry" ? "windows_environment_unavailable" : "shell_capture_failed";
+            if (errorCode === "shell_cleanup_failed")
+                unsafeCleanup = true;
+            lastFailureTime = now();
+            return publish(lastGood?.env ?? baseline, { state: lastGood ? "stale" : "fallback", errorCode, attemptedAt });
+        }
+        finally {
+            capturing = false;
+        }
+    };
+    const acquire = (acquireOptions) => {
+        if (flight) {
+            if (acquireOptions?.force && !capturing) {
+                const requestedEpoch = captureEpoch;
+                forcedFollowup ??= flight.then((value) => captureEpoch > requestedEpoch ? value : acquire({ force: true })).finally(() => { forcedFollowup = undefined; });
+                return forcedFollowup;
+            }
+            return flight;
+        }
+        if (stopped || unsafeCleanup || selected.source === null)
+            return Promise.resolve(snapshot);
+        controller = new AbortController();
+        flight = refresh(acquireOptions?.force === true, controller.signal).finally(() => { flight = undefined; controller = undefined; });
+        return flight;
+    };
+    return {
+        acquire,
+        status: () => snapshot.status,
+        async stop() {
+            stopped = true;
+            controller?.abort();
+            await flight;
+        },
+    };
+}

package/dist/machine-environment-contract.js

@@ -0,0 +1,10 @@
+export class MachineEnvironmentCaptureError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "MachineEnvironmentCaptureError";
+    }
+}
+export const MACHINE_ENVIRONMENT_MAX_BYTES = 1024 * 1024;
+export const MACHINE_ENVIRONMENT_MAX_ENTRIES = 4096;

package/dist/machine-environment-control.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+const Request = z.object({ type: z.enum(["machine:environment:get", "machine:environment:refresh"]), reqId: z.string().min(1).max(200) }).strict();
+/** 发送回调由连接持有，刷新完成后不得把旧请求回复到新 socket。 */
+export async function handleMachineEnvironmentFrame(decoded, provider, send) {
+    if (typeof decoded !== "object" || decoded === null || !("type" in decoded)
+        || (decoded.type !== "machine:environment:get" && decoded.type !== "machine:environment:refresh"))
+        return false;
+    const reqId = "reqId" in decoded && typeof decoded.reqId === "string" ? decoded.reqId.slice(0, 200) : "invalid";
+    const reply = (result) => { try {
+        send({ type: "fs:result", reqId, ...result });
+    }
+    catch { /* 连接失效由服务端超时处理。 */ } };
+    const parsed = Request.safeParse(decoded);
+    if (!parsed.success) {
+        reply({ ok: false, error: "machine_environment_request_invalid" });
+        return true;
+    }
+    try {
+        if (parsed.data.type === "machine:environment:refresh")
+            await provider.acquire({ force: true });
+        reply({ ok: true, data: provider.status() });
+    }
+    catch {
+        reply({ ok: false, error: "machine_environment_request_failed" });
+    }
+    return true;
+}

package/dist/machine-environment-policy.js

@@ -0,0 +1,75 @@
+import { userInfo } from "node:os";
+import { basename, isAbsolute, join } from "node:path";
+import { MACHINE_ENVIRONMENT_MAX_BYTES, MACHINE_ENVIRONMENT_MAX_ENTRIES, MachineEnvironmentCaptureError } from "./machine-environment-contract.js";
+const ACCOUNT_KEYS = new Set(["HOME", "USER", "LOGNAME", "SHELL", "USERPROFILE", "USERNAME", "USERDOMAIN", "USERDOMAIN_ROAMINGPROFILE", "HOMEDRIVE", "HOMEPATH", "SYSTEMROOT", "WINDIR", "COMSPEC"]);
+const CONFIGURED_KEYS = new Set(["QA_REPORT_HUB", "QA_RUNTIME_ROOT", "QA_REPORT_DELIVERY_CONTEXT"]);
+export const isMachineControlKey = (key) => /^(CREW_|NOWWORK_)/iu.test(key);
+export const isMachineTransientKey = (key) => ["_", "SHLVL", "PWD", "OLDPWD"].includes(key) || key.startsWith("BASH_FUNC_");
+export function copyMachineEnvironment(env) {
+    return Object.freeze(Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === "string")));
+}
+export function resolveMachineAccount() {
+    const info = userInfo();
+    return Object.freeze({ home: info.homedir, username: info.username, shell: info.shell, uid: info.uid });
+}
+/** 账号来自操作系统，不受 daemon 的 profile HOME 或 rc 改写影响。 */
+export function restoreMachineEnvironmentOwnership(captured, startup, account, platform) {
+    const protectedKeys = new Set(Object.keys(startup).filter((key) => CONFIGURED_KEYS.has(key.toUpperCase())).map((key) => key.toUpperCase()));
+    const owns = (key) => isMachineControlKey(key) || ACCOUNT_KEYS.has(key.toUpperCase()) || protectedKeys.has(key.toUpperCase());
+    const entries = Object.entries(captured).filter(([key]) => !owns(key) && !isMachineTransientKey(key));
+    entries.push(...Object.entries(startup).filter(([key]) => owns(key)));
+    const env = Object.fromEntries(entries);
+    if (platform === "win32") {
+        for (const key of Object.keys(env))
+            if (["HOME", "USERPROFILE", "USERNAME"].includes(key.toUpperCase()))
+                delete env[key];
+        env.USERPROFILE = account.home;
+        env.USERNAME = account.username;
+        if (startup.HOME !== undefined)
+            env.HOME = account.home;
+    }
+    else {
+        env.HOME = account.home;
+        env.USER = account.username;
+        env.LOGNAME = account.username;
+        const shell = account.shell || startup.SHELL;
+        if (shell)
+            env.SHELL = shell;
+        else
+            delete env.SHELL;
+    }
+    return Object.freeze(env);
+}
+export function machineCaptureStartupEnvironment(startup, account, platform) {
+    const owned = restoreMachineEnvironmentOwnership(startup, startup, account, platform);
+    return Object.freeze(Object.fromEntries(Object.entries(owned).filter(([key]) => !isMachineControlKey(key) && !isMachineTransientKey(key))));
+}
+export function selectMachineEnvironmentSource(mode, account, startup, platform) {
+    if (mode === "off")
+        return { source: null };
+    if (platform === "win32")
+        return { source: mode === "auto" || mode === "windows" ? "windows-registry" : null };
+    if (mode === "windows")
+        return { source: null };
+    const loginShell = account.shell || startup.SHELL;
+    const name = mode === "auto" ? basename(loginShell ?? "") : mode;
+    if (name !== "bash" && name !== "zsh")
+        return { source: null };
+    const shellPath = loginShell && isAbsolute(loginShell) && basename(loginShell) === name ? loginShell : join("/bin", name);
+    return { source: name, shellPath };
+}
+export function validateMachineEnvironment(value, bytes) {
+    if (bytes !== undefined && bytes > MACHINE_ENVIRONMENT_MAX_BYTES)
+        throw new MachineEnvironmentCaptureError("shell_capture_too_large");
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new MachineEnvironmentCaptureError("shell_capture_failed");
+    const entries = Object.entries(value);
+    if (entries.length > MACHINE_ENVIRONMENT_MAX_ENTRIES)
+        throw new MachineEnvironmentCaptureError("shell_capture_too_large");
+    if (entries.some(([key, item]) => !key || key.includes("=") || key.includes("\0") || typeof item !== "string" || item.includes("\0"))) {
+        throw new MachineEnvironmentCaptureError("shell_capture_failed");
+    }
+    if (Buffer.byteLength(JSON.stringify(value), "utf8") > MACHINE_ENVIRONMENT_MAX_BYTES)
+        throw new MachineEnvironmentCaptureError("shell_capture_too_large");
+    return Object.freeze(Object.fromEntries(entries));
+}

package/dist/machine-environment-process.js

@@ -0,0 +1,110 @@
+import { spawn } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+import { MACHINE_ENVIRONMENT_MAX_BYTES, MachineEnvironmentCaptureError } from "./machine-environment-contract.js";
+/** 只接收本模块 detached spawn 所创建的进程组，绝不复用 supervisor 的 PID 清理接口。 */
+async function cleanupOwnedGroup(pid) {
+    const exists = () => {
+        try {
+            process.kill(-pid, 0);
+            return true;
+        }
+        catch (error) {
+            if (error.code === "ESRCH")
+                return false;
+            throw new MachineEnvironmentCaptureError("shell_cleanup_failed");
+        }
+    };
+    const signal = (value) => {
+        try {
+            process.kill(-pid, value);
+        }
+        catch (error) {
+            if (error.code !== "ESRCH")
+                throw new MachineEnvironmentCaptureError("shell_cleanup_failed");
+        }
+    };
+    if (!exists())
+        return;
+    for (const value of ["SIGTERM", "SIGKILL"]) {
+        signal(value);
+        const until = Date.now() + 1_000;
+        while (exists() && Date.now() < until)
+            await delay(20);
+        if (!exists())
+            return;
+    }
+    throw new MachineEnvironmentCaptureError("shell_cleanup_failed");
+}
+export async function runMachineEnvironmentProcess(options) {
+    if (options.signal.aborted || Date.now() >= options.deadline)
+        throw new MachineEnvironmentCaptureError("shell_capture_timeout");
+    const collectFd = options.collectFd;
+    const stdio = Array.from({ length: Math.max(3, (collectFd ?? 2) + 1, (options.metadataFd ?? 2) + 1) }, () => "ignore");
+    if (collectFd !== undefined)
+        stdio[collectFd] = "pipe";
+    if (options.metadataFd !== undefined)
+        stdio[options.metadataFd] = "pipe";
+    const child = spawn(options.file, [...options.args], { cwd: options.cwd, env: options.env, detached: true, stdio });
+    const chunks = [];
+    let size = 0;
+    const metadata = [];
+    let metadataSize = 0;
+    let timer;
+    let abort;
+    let cleanup;
+    const cleanupOnce = () => cleanup ??= child.pid === undefined ? Promise.resolve() : cleanupOwnedGroup(child.pid);
+    try {
+        return await new Promise((resolve, reject) => {
+            const fail = (code) => reject(new MachineEnvironmentCaptureError(code));
+            abort = () => fail("shell_capture_timeout");
+            options.signal.addEventListener("abort", abort, { once: true });
+            timer = setTimeout(abort, Math.max(0, options.deadline - Date.now()));
+            const channel = collectFd === undefined ? undefined : child.stdio[collectFd];
+            channel?.on("data", (chunk) => {
+                size += chunk.length;
+                if (size > (options.maxBytes ?? MACHINE_ENVIRONMENT_MAX_BYTES))
+                    fail("shell_capture_too_large");
+                else
+                    chunks.push(chunk);
+            });
+            channel?.on("error", () => fail("shell_capture_failed"));
+            const metadataChannel = options.metadataFd === undefined ? undefined : child.stdio[options.metadataFd];
+            metadataChannel?.on("data", (chunk) => {
+                metadataSize += chunk.length;
+                if (metadataSize > 16_384)
+                    fail("shell_capture_too_large");
+                else
+                    metadata.push(chunk);
+            });
+            metadataChannel?.on("error", () => fail("shell_capture_failed"));
+            child.once("error", () => fail("shell_unavailable"));
+            child.once("exit", () => {
+                // rc 的后台任务会继承 fd3；主进程退出即清理，不能等所有继承者自行 close。
+                void cleanupOnce().catch(() => fail("shell_cleanup_failed"));
+            });
+            child.once("close", (code) => {
+                if (code === 0) {
+                    options.onMetadata?.(Buffer.concat(metadata));
+                    resolve(Buffer.concat(chunks));
+                }
+                else
+                    fail(options.exitErrorCode ?? "shell_capture_failed");
+            });
+            if (options.signal.aborted)
+                abort();
+        });
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (abort)
+            options.signal.removeEventListener("abort", abort);
+        try {
+            await cleanupOnce();
+        }
+        finally {
+            for (const stream of child.stdio)
+                stream?.destroy();
+        }
+    }
+}

package/dist/machine-info.js

@@ -1,7 +1,11 @@
+import { retryHarnessProbe } from "./runtimes/harness-probe-retry.js";
+import { MARKETPLACE_CAPABILITY } from "./marketplace-protocol.js";
 /**
  * 采集本机信息上报给控制面 (machine:hello):hostname / os / daemon 版本 / 已装 runtimes。
  * runtimes 探测靠 `which <bin>`(win32 用 `where`),只报真实可执行的 CLI(用于展示 Detected Runtimes)。
  */
+import { randomUUID } from "node:crypto";
+import { dslog } from "./slog.js";
 import { hostname, arch, platform as osPlatform } from "node:os";
 import { lookupCmd } from "./platform.js";
 import { augmentedPath } from "./runtime-path.js";
@@ -14,11 +18,11 @@ import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 import { executableRuntimes } from "./runtime-capabilities.js";
 import { executionBackendCapability } from "./execution-backend.js";
-import { probeKimiAcp } from "./runtimes/kimi-acp-runner.js";
+import { probeKimiAcp, AcpProbeCleanupError } 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";
+import { probeDeepSeekHarnessAcp, deepSeekHarnessLauncher } from "./runtimes/deepseek-harness.js";
 import { daemonHome } from "./computer-profile.js";
 import { daemonReleaseProvenance } from "./release-provenance.js";
 export { executableRuntimes } from "./runtime-capabilities.js";
@@ -28,17 +32,20 @@ export const TRAINING_PROJECT_DEPENDENCIES_CAPABILITY = "training_project_depend
 export const SELF_TRAINING_EXECUTION_CAPABILITY = "self_training_execution_v1";
 export const EXECUTION_LARGE_ATTACHMENTS_CAPABILITY = "execution_attachments_300m_v1";
 export const PROJECT_SKILL_PROJECTION_CAPABILITY = "project_skill_projection_v2";
+export const MACHINE_ENVIRONMENT_CAPABILITY = "machine_environment_v1";
 export const NATIVE_PROJECT_WORKSPACE_READINESS = Object.freeze({
     resolverReady: true,
     nativeRuntimeAdaptersReady: true,
 });
 export const DAEMON_CAPABILITIES = Object.freeze([
+    MARKETPLACE_CAPABILITY,
     "scheduled_job_v1",
     "reply_origin_v1",
     "origin_decision_v1",
     "execution_telemetry_ack_v1",
     "execution_external_output_v1",
     "execution_attachments_v1",
+    "message_file_preview_v1",
     EXECUTION_LARGE_ATTACHMENTS_CAPABILITY,
     "execution_answer_stream_v1",
     "execution_machine_queue_v1",
@@ -53,6 +60,8 @@ export const DAEMON_CAPABILITIES = Object.freeze([
     "agent_ability_release_v1",
     "agent_ability_workspace_v1",
     "agent_ability_runtime_assets_v1",
+    "agent_environments_v1",
+    MACHINE_ENVIRONMENT_CAPABILITY,
 ]);
 /** 能力只按平台过滤,进程存活期间静态(CLAUDE.md 红线)。Windows 在 junction/copy 真机 smoke 通过前不宣告 Project Skills。 */
 export const daemonCapabilities = (runtimePlatform = process.platform, readiness = NATIVE_PROJECT_WORKSPACE_READINESS) => {
@@ -61,7 +70,9 @@ export const daemonCapabilities = (runtimePlatform = process.platform, readiness
     const nativeWorkspaceReady = nativeWorkspacePlatform
         && readiness.resolverReady
         && readiness.nativeRuntimeAdaptersReady;
-    return Object.freeze(DAEMON_CAPABILITIES.filter((capability) => ((capability !== PROJECT_WORKSPACES_CAPABILITY || nativeWorkspaceReady)
+    return Object.freeze(DAEMON_CAPABILITIES.filter((capability) => ((capability !== MARKETPLACE_CAPABILITY || nativeWorkspacePlatform)
+        && (capability !== PROJECT_WORKSPACES_CAPABILITY || nativeWorkspaceReady)
+        && (capability !== "message_file_preview_v1" || nativeWorkspacePlatform)
         && (nativeWorkspacePlatform
             || (capability !== "project_skills_v1"
                 && capability !== "project_skill_projection_v2"
@@ -90,15 +101,15 @@ const RUNTIME_BINS = [
     ["gemini", "gemini"],
     ["hermes", "hermes"],
     ["opencode", "opencode"],
-    ["deepseek-harness", "dsh-acp-demo"],
+    ["deepseek-harness", "dsh"],
     ["copilot", "copilot"],
     ["kimi", "kimi"],
     ["pi", "pi"],
 ];
-async function isInstalled(bin) {
+async function isInstalled(bin, env) {
     try {
         // 用增强 PATH 探测:daemon 继承的 PATH 可能缺 ~/.local/bin 等用户级目录(Claude 原生安装器落点)。
-        await execFileP(lookupCmd(), [bin], { env: { ...process.env, PATH: augmentedPath() } });
+        await execFileP(lookupCmd(), [bin], { env });
         return true;
     }
     catch {
@@ -106,30 +117,65 @@ async function isInstalled(bin) {
     }
 }
 /** 并发探测所有候选 runtime,返回已安装的展示名列表。 */
-export async function detectRuntimes() {
-    const checks = await Promise.all(RUNTIME_BINS.map(async ([name, bin]) => ((await isInstalled(bin)) ? name : null)));
+export async function detectRuntimes(env = { ...process.env, PATH: augmentedPath() }) {
+    const checks = await Promise.all(RUNTIME_BINS.map(async ([name, bin]) => {
+        try {
+            return await isInstalled(name === "deepseek-harness" ? deepSeekHarnessLauncher(env).bin : bin, env) ? name : null;
+        }
+        catch {
+            return null;
+        }
+    }));
     return checks.filter((x) => x !== null);
 }
-async function supportsKimiAcp(signal) {
-    return probeKimiAcp({ bin: "kimi", ...(signal ? { signal } : {}) });
+async function supportsKimiAcp(signal, probeId, env) {
+    return probeKimiAcp({ bin: "kimi", ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}), ...(env ? { env } : {}) });
 }
-async function supportsHermesAcp(signal) {
-    return probeHermesAcp({ bin: "hermes", ...(signal ? { signal } : {}) });
+async function supportsHermesAcp(signal, probeId, env) {
+    return probeHermesAcp({ bin: "hermes", ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}), ...(env ? { env } : {}) });
 }
-async function supportsOpenCodeRun(signal) {
-    return probeOpenCodeRun(signal);
+async function supportsOpenCodeRun(signal, _probeId, env) {
+    return probeOpenCodeRun(signal, env);
 }
-async function supportsDeepSeekHarnessAcp(signal) {
-    return probeDeepSeekHarnessAcp({ bin: "dsh-acp-demo", ...(signal ? { signal } : {}) });
+async function supportsDeepSeekHarnessAcp(signal, probeId, env) {
+    try {
+        return await probeDeepSeekHarnessAcp({ bin: deepSeekHarnessLauncher(env).bin, ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}), ...(env ? { env } : {}) });
+    }
+    catch (error) {
+        if (error instanceof AcpProbeCleanupError)
+            throw error;
+        return false;
+    }
 }
 /** Runtime adapters that can satisfy the durable protocol-v1 process contract. */
-export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, deepSeekHarnessProbe = supportsDeepSeekHarnessAcp, signal) {
+export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, deepSeekHarnessProbe = supportsDeepSeekHarnessAcp, signal, probeId = randomUUID()) {
     const present = await installed;
+    const probe = (runtime, detect) => {
+        const startedAt = Date.now();
+        dslog("runtime_probe.optional_start", "开始可选 runtime 探测", { probe_id: probeId, runtime, aborted: signal?.aborted ?? false });
+        const complete = (outcome, ready) => {
+            dslog("runtime_probe.optional_complete", "可选 runtime 探测结束", {
+                probe_id: probeId, runtime, outcome, duration_ms: Date.now() - startedAt,
+                aborted: signal?.aborted ?? false, ...(ready === undefined ? {} : { ready }),
+            });
+        };
+        let pending;
+        try {
+            pending = detect(signal, probeId);
+        }
+        catch (error) {
+            complete("threw");
+            throw error;
+        }
+        return pending.then((ready) => { complete("resolved", ready); return ready; }, (error) => { complete("threw"); throw error; });
+    };
     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,
+        present.includes("kimi") ? probe("kimi", kimiAcpProbe) : false,
+        present.includes("hermes") ? probe("hermes", hermesAcpProbe) : false,
+        present.includes("opencode") ? probe("opencode", openCodeProbe) : false,
+        present.includes("deepseek-harness")
+            ? retryHarnessProbe(() => probe("deepseek-harness", deepSeekHarnessProbe), signal, probeId)
+            : false,
     ]);
     return executableRuntimes(present).filter((runtime) => (runtime === "kimi" ? kimiReady
         : runtime === "hermes" ? hermesReady
@@ -137,7 +183,7 @@ export async function detectExecutionRuntimes(installed = detectRuntimes(), kimi
                 : runtime === "deepseek-harness" ? deepSeekHarnessReady
                     : true));
 }
-export const detectExecutionRuntimesWithSignal = (installed, signal) => detectExecutionRuntimes(installed, supportsKimiAcp, supportsHermesAcp, supportsOpenCodeRun, supportsDeepSeekHarnessAcp, signal);
+export const detectExecutionRuntimesWithSignal = (installed, signal, probeId, env) => detectExecutionRuntimes(installed, (probeSignal, id) => supportsKimiAcp(probeSignal, id, env), (probeSignal, id) => supportsHermesAcp(probeSignal, id, env), (probeSignal, id) => supportsOpenCodeRun(probeSignal, id, env), (probeSignal, id) => supportsDeepSeekHarnessAcp(probeSignal, id, env), signal, probeId);
 export function daemonVersion() {
     try {
         const here = dirname(fileURLToPath(import.meta.url));
@@ -174,13 +220,13 @@ async function listAgentHandles(agentsRoot) {
 }
 export async function collectMachineHello(agentsRoot, executionLimits, runtimePlatform = process.platform, dependencies = {}) {
     const [runtimes, agentHandles, additionalCapabilities] = await Promise.all([
-        (dependencies.detectInstalled ?? detectRuntimes)(),
+        (dependencies.detectInstalled ?? (() => detectRuntimes(dependencies.env)))(),
         listAgentHandles(agentsRoot),
         dependencies.additionalCapabilities?.() ?? Promise.resolve([]),
     ]);
     const backend = executionBackendCapability(runtimePlatform, dependencies.jobObjectProbe);
     const executionRuntimes = backend.supported
-        ? await (dependencies.detectExecutable ?? detectExecutionRuntimes)(runtimes)
+        ? await (dependencies.detectExecutable ?? ((installed) => detectExecutionRuntimesWithSignal(installed, undefined, undefined, dependencies.env)))(runtimes)
         : [];
     const baseCapabilities = dependencies.capabilities ?? daemonCapabilities(runtimePlatform);
     const capabilities = additionalCapabilities.length === 0 && Object.isFrozen(baseCapabilities)
@@ -203,7 +249,6 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
         runtimes,
         executionRuntimes,
         capabilities,
-        ...(dependencies.codexHomeMode === undefined ? {} : { codexHomeMode: dependencies.codexHomeMode }),
         ...(dependencies.profileName === undefined ? {} : {
             layoutVersion: 1,
             profileName: dependencies.profileName,