@nowcrew/daemon 0.6.88-beta.28 → 0.6.88-beta.29

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.js

@@ -1,19 +1,21 @@
 import spawn from "cross-spawn";
-import { isAbsolute } from "node:path";
+import { isAbsolute, win32, join } from "node:path";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
 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 const DEEPSEEK_HARNESS_PATCH_ENV = "NOWCREW_DEEPSEEK_HARNESS_PATCH";
-export function deepSeekHarnessLauncher(env = process.env) {
-    const configPath = env[DEEPSEEK_HARNESS_CONFIG_ENV]?.trim();
-    const patchPath = env[DEEPSEEK_HARNESS_PATCH_ENV]?.trim();
-    if (configPath && !isAbsolute(configPath))
+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 && !isAbsolute(patchPath))
+    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");
@@ -21,24 +23,27 @@ export function deepSeekHarnessLauncher(env = process.env) {
         ? { kind: "legacy", bin: "dsh-acp-demo", configPath }
         : { kind: "profile", bin: "dsh", ...(patchPath ? { patchPath } : {}) };
 }
-export function deepSeekHarnessConfigPath(env = process.env) {
-    const path = env[DEEPSEEK_HARNESS_CONFIG_ENV]?.trim();
-    return path && isAbsolute(path) ? path : null;
+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 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()
+            ? 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",
@@ -50,7 +55,7 @@ export async function probeDeepSeekHarnessAcp(options, spawnProcess = spawn) {
             systemPrompt: "",
             skillRoots: [],
             effectivePermission: "sandboxed",
-            env: process.env,
+            env: sourceEnv,
             ...(launcher.patchPath ? { patchPath: launcher.patchPath } : {}),
         });
         const launch = deepSeekHarnessLaunch(options.bin, profile.args);

package/dist/runtimes/hermes-models.js

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

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

@@ -136,10 +136,10 @@ function deepSeekPermissionMode(permission) {
         return "workspace-write";
     return "danger-full-access";
 }
-function providerEnv(provider, permission) {
+function providerEnv(provider, permission, env = process.env) {
     return provider === "deepseek-harness"
-        ? { ...process.env, DSH_PERMISSION_MODE: deepSeekPermissionMode(permission) }
-        : process.env;
+        ? { ...env, DSH_PERMISSION_MODE: deepSeekPermissionMode(permission) }
+        : env;
 }
 function providerDisplayName(provider) {
     if (provider === "deepseek-harness")
@@ -220,11 +220,12 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
         ...transport.fields(), spawn_confirmed_ms: spawnConfirmedMs, child_pid: child.pid,
         reason, protocol_version: protocolVersion, stderr_seen: stderrSeen, aborted: options.signal?.aborted ?? false });
     dslog("execution.acp_probe_started", "ACP 探测开始", { probe_id: probeId, runtime: provider, node_version: process.version });
-    const launchEnv = options.launchEnv ?? providerEnv(provider, permission);
+    const sourceEnv = options.env ?? { ...process.env, PATH: augmentedPath() };
+    const launchEnv = options.launchEnv ?? providerEnv(provider, permission, sourceEnv);
     const child = spawnProcess(options.bin, options.launchArgs ?? providerArgs(provider, options.configPath), {
         cwd: options.launchCwd ?? process.cwd(),
-        // 显式 launchEnv 也决定 PATH/HOME;不能把它与父进程 PATH 混用。
-        env: { ...launchEnv, PATH: augmentedPath(launchEnv) },
+        // 显式 launchEnv 已准备好 PATH/HOME，不能二次补 PATH 或混入父进程环境。
+        env: launchEnv,
         stdio: ["pipe", "pipe", "pipe"],
     });
     // spawn errors are emitted by ChildProcess, not its stdio streams. A missing

package/dist/runtimes/opencode.js

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

package/dist/serve.js

@@ -1,7 +1,7 @@
-/**
- * 常驻模式 (M3c):连接 server 控制面 WS,注册机器,监听 agent:start 自动唤醒 agent。
- * 断线指数退避重连。一个 agent:start 进来就跑一次现有的 runAgent。
- */
+/** 常驻控制面桥接；按请求拉起本地 runtime。 */
+import { handleAgentEnvironmentFrame } from "./agent-environment-control.js";
+import { handleMachineEnvironmentFrame } from "./machine-environment-control.js";
+import { createMachineRuntimeEnvironment } from "./machine-runtime-environment.js";
 import { WebSocket } from "ws";
 import { persistPreAdmissionRejection, rejectQueuedAdmission } from "./pre-admission-rejection.js";
 import { join } from "node:path";
@@ -9,14 +9,11 @@ import { randomUUID } from "node:crypto";
 import { dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
 import { mergeRunAgentResults, reportScheduledStartFailure, runAgent } from "./runner.js";
 import { buildOriginDecisionRetryPrompt, buildScheduledPrompt } from "./prompt.js";
-import { collectMachineHello, daemonCapabilities, daemonCapabilityBindings, detectExecutionRuntimesWithSignal, } from "./machine-info.js";
+import { daemonCapabilities, daemonCapabilityBindings, } from "./machine-info.js";
 import { reconcileExecutionJournal } from "./execution-recovery.js";
 import { initReleaseSlog, reportDaemonConnectionClose, reportReleaseError } from "./release-channel-guard.js";
-import { conservativeExecutionRuntimes, createRuntimeProbeCoordinator, } from "./runtime-probe.js";
-import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
-import { listSkills } from "./skills.js";
+import { handleWorkspaceControlRequest } from "./workspace-control-handler.js";
 import { inspectRaftWorkspace, importRaftWorkspace } from "./workspace-import.js";
-import { listRuntimeModels } from "./list-models.js";
 import { normalizeScheduledContext } from "./scheduled-report.js";
 import { formatDaemonLogLine } from "./log-format.js";
 import { reportAgentRunComplete } from "./scheduled-run-report.js";
@@ -50,7 +47,6 @@ import { createProjectSkillsReconciler, } from "./project-skills/reconciler.js";
 import { initializedProjectSkillsReconciler } from "./project-skills/initialized-reconciler.js";
 import { parseMemoryPruneTraceId } from "./memory-prune-diagnostics.js";
 import { probeRuntimeHealth } from "./runtime-health.js";
-import { handleRuntimeHealthProbeFrame } from "./runtime-health-handler.js";
 import { createServeMarketplace } from "./marketplace-serve.js";
 import { buildControlPlaneUrl } from "./control-plane-url.js";
 import { resolveDaemonLocalStateRootFromEnv } from "./daemon-local-home.js";
@@ -80,9 +76,6 @@ export function serve(config, opts = {}) {
         ?? (config.agentMemory === null ? undefined : createAgentMemoryBridge(config.agentMemory));
     const executionTelemetry = createExecutionTelemetryJournal(config.agentsRoot);
     const executeProtocol = opts.execution?.runExecution ?? runExecution;
-    let detectedExecutionRuntimes = [], executionRuntimesKnown = false;
-    let runtimeFacts = null;
-    const runtimeProbe = createRuntimeProbeCoordinator();
     const localHome = opts.localHome ?? resolveDaemonLocalStateRootFromEnv();
     const hostCoordinator = opts.execution?.hostCoordinator
         ?? createHostExecutionCoordinator({
@@ -171,6 +164,16 @@ export function serve(config, opts = {}) {
         },
         onSent: (hello) => log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · installed=[${hello.runtimes.join(",")}] · executable=[${hello.executionRuntimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`),
     });
+    const machineRuntime = createMachineRuntimeEnvironment({
+        config,
+        ...(opts.machineEnvironment === undefined ? {} : { provider: opts.machineEnvironment }),
+        ...(opts.machineInfo === undefined ? {} : { machineInfo: opts.machineInfo }),
+        ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }),
+        additionalCapabilities: async () => managedDaemonCapabilities(updateEligibility),
+        publish: machineHelloPublisher.publish,
+        onError: (code, context) => dslog("execution.runtime_detection_failed", "机器环境或 runtime 探测失败", { level: "ERROR", error_code: code, ...context }),
+    });
+    machineRuntime.prewarm();
     const initializedProjectSkills = initializedProjectSkillsReconciler(() => projectSkillsController.ensureScanned(), projectSkillsReconciler);
     const configuredCapabilities = opts.machineInfo?.capabilities ?? daemonCapabilities(process.platform);
     const prepareCapabilities = async () => daemonCapabilityBindings(process.platform, [...configuredCapabilities, ...await managedDaemonCapabilities(updateEligibility)]);
@@ -287,12 +290,20 @@ export function serve(config, opts = {}) {
         if (stopped)
             return;
         const wsUrl = (opts.buildControlPlaneUrl ?? buildControlPlaneUrl)(config.serverUrl, config.machineToken, process.platform, undefined, capabilities.controlPlaneUrl);
-        ws = createWebSocket(wsUrl);
+        const connectionSocket = createWebSocket(wsUrl);
+        ws = connectionSocket;
+        const sendToConnection = (frame) => {
+            try {
+                if (!stopped && ws === connectionSocket && connectionSocket.readyState === WebSocket.OPEN)
+                    connectionSocket.send(JSON.stringify(frame));
+            }
+            catch { /* 旧连接请求由服务端超时处理。 */ }
+        };
         let connectionEpochToken;
-        ws.on("open", () => {
+        connectionSocket.on("open", () => {
             connectionEpochToken = projectSkillsController.beginConnectionEpoch();
             storageIdentityAdmission.beginIdentityBinding();
-            const openedSocket = ws;
+            const openedSocket = connectionSocket;
             const connectionId = randomUUID();
             backoff = 1000;
             connectedAt = Date.now();
@@ -301,60 +312,7 @@ export function serve(config, opts = {}) {
             // 连上了才有机会把离线期间(断连原因/退出前)落盘的日志补传上去
             void drainSpool();
             // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
-            const { detectInstalled, detectExecutable = detectExecutionRuntimesWithSignal } = opts.machineInfo ?? {};
-            const helloPromise = (opts.machineInfo?.collect ?? collectMachineHello)(config.agentsRoot, config.executionLimits, process.platform, {
-                ...(detectInstalled ? { detectInstalled } : {}),
-                ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }),
-                // First hello must not wait for third-party handshakes; optional transports arrive in the refresh.
-                detectExecutable: async (installed) => conservativeExecutionRuntimes(installed),
-                additionalCapabilities: async () => managedDaemonCapabilities(updateEligibility),
-                capabilities: capabilities.machineHello,
-            });
-            runtimeFacts = helloPromise
-                .then(async (hello) => {
-                if (hello.executionProtocol === undefined) {
-                    executionRuntimesKnown = true;
-                    dslog("runtime_probe.hello_refresh", "runtime hello 刷新决策", {
-                        connection_id: connectionId, reason: "protocol_unavailable",
-                        current_socket: ws === openedSocket, socket_open: openedSocket.readyState === WebSocket.OPEN,
-                        socket_ready_state: openedSocket.readyState, installed_runtimes: JSON.stringify(hello.runtimes),
-                        execution_runtimes: JSON.stringify(hello.executionRuntimes),
-                    });
-                    return [];
-                }
-                const detected = await runtimeProbe.detect(hello.runtimes, detectExecutable, connectionId);
-                executionRuntimesKnown = true;
-                const currentSocket = ws === openedSocket;
-                const socketOpen = openedSocket.readyState === WebSocket.OPEN;
-                const hasNewRuntime = detected.some((runtime) => !hello.executionRuntimes.includes(runtime));
-                dslog("runtime_probe.hello_refresh", "runtime hello 刷新决策", {
-                    connection_id: connectionId, current_socket: currentSocket, socket_open: socketOpen,
-                    socket_ready_state: openedSocket.readyState, installed_runtimes: JSON.stringify(hello.runtimes),
-                    initial_execution_runtimes: JSON.stringify(hello.executionRuntimes), execution_runtimes: JSON.stringify(detected),
-                    reason: !currentSocket ? "stale_connection" : !socketOpen ? "socket_not_open" : !hasNewRuntime ? "unchanged" : "publish",
-                });
-                if (currentSocket && socketOpen && hasNewRuntime) {
-                    detectedExecutionRuntimes = detected;
-                    machineHelloPublisher.publish({ ...hello, executionRuntimes: [...detected] }, openedSocket);
-                }
-                return detected;
-            })
-                .catch(() => {
-                executionRuntimesKnown = true;
-                dslog("execution.runtime_detection_failed", "runtime 探测失败", {
-                    level: "ERROR", reason: "detection_threw", connection_id: connectionId,
-                    current_socket: ws === openedSocket, socket_open: openedSocket.readyState === WebSocket.OPEN,
-                });
-                return [];
-            });
-            void helloPromise
-                .then(async (hello) => {
-                if (ws !== openedSocket || openedSocket.readyState !== WebSocket.OPEN)
-                    return;
-                detectedExecutionRuntimes = hello.executionRuntimes;
-                machineHelloPublisher.publish(hello, openedSocket);
-            })
-                .catch(() => { });
+            machineRuntime.open(openedSocket, { capabilities: capabilities.machineHello, beforePublish: Promise.resolve(), connectionId });
             opts.onOpen?.(ws);
             void sendSnapshot(`reconnect-${randomUUID()}`);
             void executionJournal.replay()
@@ -383,8 +341,8 @@ export function serve(config, opts = {}) {
                 });
             });
         });
-        ws.on("message", async (data) => {
-            if (stopped)
+        connectionSocket.on("message", async (data) => {
+            if (stopped || ws !== connectionSocket)
                 return;
             let decoded;
             try {
@@ -396,6 +354,10 @@ export function serve(config, opts = {}) {
             if (typeof decoded !== "object" || decoded === null)
                 return;
             const rawType = "type" in decoded && typeof decoded.type === "string" ? decoded.type : "";
+            if (rawType === "machine:environment:get" || rawType === "machine:environment:refresh") {
+                await handleMachineEnvironmentFrame(decoded, machineRuntime.provider, sendToConnection);
+                return;
+            }
             if (rawType === "daemon:update" || rawType === "daemon:restart") {
                 void updateController.handle(decoded).catch((error) => {
                     dslog("daemon.control_failed", "daemon 控制操作处理失败", {
@@ -667,9 +629,7 @@ export function serve(config, opts = {}) {
                     let availableRuntimes;
                     try {
                         availableRuntimes = opts.execution?.availableRuntimes?.()
-                            ?? (detectedExecutionRuntimes.includes(spec.runtime.name)
-                                ? detectedExecutionRuntimes
-                                : await (runtimeFacts ?? Promise.resolve(detectedExecutionRuntimes)));
+                            ?? await machineRuntime.availableRuntimes(spec.runtime.name);
                     }
                     catch (error) {
                         cleanupExecutionReservation("runtime_detection_failed");
@@ -686,6 +646,7 @@ export function serve(config, opts = {}) {
                     }
                     const execution = executeProtocol(config, spec, {
                         ...opts.execution?.dependencies,
+                        machineEnvironment: machineRuntime.provider,
                         capabilities: capabilities.executionRunner,
                         projectSkills: opts.execution?.dependencies?.projectSkills ?? initializedProjectSkills,
                         abilityRelease: opts.execution?.dependencies?.abilityRelease ?? agentAbilityRuntime.materializer,
@@ -831,12 +792,9 @@ export function serve(config, opts = {}) {
                 return;
             }
             if (msg.type === "runtime-health:probe") {
-                const result = await handleRuntimeHealthProbeFrame(msg, opts.runtimeHealth?.probe, executionRuntimesKnown, detectedExecutionRuntimes);
+                const result = await machineRuntime.health(msg, opts.runtimeHealth?.probe);
                 if (result !== null) {
-                    try {
-                        ws?.send(JSON.stringify({ type: "fs:result", ...result }));
-                    }
-                    catch { /* server 会超时 */ }
+                    sendToConnection({ type: "fs:result", ...result });
                 }
                 return;
             }
@@ -870,26 +828,11 @@ export function serve(config, opts = {}) {
                 }
                 return;
             }
-            // workspace 文件浏览 / skills 枚举请求 (只读、沙箱;见 workspace-fs.ts / skills.ts)
-            if (msg.type === "fs:list" || msg.type === "fs:read" || msg.type === "skills:list" || msg.type === "probe-models") {
-                const req = msg;
-                const root = join(config.agentsRoot, req.handle);
-                const reply = (r) => {
-                    try {
-                        ws?.send(JSON.stringify({ type: "fs:result", reqId: req.reqId, ...r }));
-                    }
-                    catch { /* 忽略 */ }
-                };
-                try {
-                    const data2 = req.type === "fs:list" ? await listWorkspace(root, req.path)
-                        : req.type === "fs:read" ? await readWorkspaceFile(root, req.path)
-                            : req.type === "skills:list" ? await listSkills(req.runtime)
-                                : { models: await listRuntimeModels(req.type === "probe-models" ? (req.runtime ?? "") : "") };
-                    reply({ ok: true, data: data2 });
-                }
-                catch (e) {
-                    reply({ ok: false, error: e.message });
-                }
+            if (await handleAgentEnvironmentFrame(msg, config.agentsRoot, sendToConnection))
+                return;
+            const fileResult = await handleWorkspaceControlRequest(msg, config.agentsRoot, projectWorkspaceRegistry, machineRuntime.models);
+            if (fileResult) {
+                sendToConnection(fileResult);
                 return;
             }
             if (msg.type !== "agent:start")
@@ -1097,6 +1040,7 @@ export function serve(config, opts = {}) {
                         ...(!scheduled && msg.wake?.seq !== undefined ? { wakeContextUpToSeq: msg.wake.seq } : {}),
                         ...(attemptWake ? { wake: attemptWake } : {}),
                     }, reportActivity, reportConsole, {
+                        machineEnvironment: machineRuntime.provider,
                         cancellation: controller.cancellation,
                         startupGate: runtimeStartupGate,
                         startupTimeoutMs: config.executionLimits.startupTimeoutMs,
@@ -1259,8 +1203,9 @@ export function serve(config, opts = {}) {
                 void flushSlog(); // 每轮收尾冲一次,保证 run.end 尽快可查
             }
         });
-        ws.on("close", (code) => {
-            if (stopped)
+        connectionSocket.on("close", (code) => {
+            machineRuntime.close(connectionSocket);
+            if (stopped || ws !== connectionSocket)
                 return;
             // server 能力随连接失效;下个连接的 ready 帧重新声明(防降级重连后沿用过期能力)。
             serverCapabilities = new Set();
@@ -1284,9 +1229,9 @@ export function serve(config, opts = {}) {
             }, backoff);
             backoff = Math.min(backoff * 2, maxBackoff);
         });
-        ws.on("error", () => {
+        connectionSocket.on("error", () => {
             if (!stopped)
-                ws?.close();
+                connectionSocket.close();
         });
     }
     const ready = (async () => {
@@ -1324,7 +1269,6 @@ export function serve(config, opts = {}) {
         stopPromise = (async () => {
             stopped = true;
             concurrencyTelemetry.stop();
-            runtimeProbe.stop();
             completionRetransmitter.stop();
             const deadline = createShutdownDeadline(shutdownTimeoutMs);
             if (reconnectTimer !== null) {
@@ -1333,6 +1277,7 @@ export function serve(config, opts = {}) {
             }
             const webSocketClosed = closeWebSocketWithinDeadline(ws, deadline.signal);
             const pending = [
+                machineRuntime.stop(),
                 webSocketClosed,
                 updateController.drain(),
                 marketplace.stop(),

package/dist/token.js

@@ -1,4 +1,3 @@
-/** 用机器令牌为某 agent 换取 per-launch 的 sk_agent_*。 */
 export async function mintAgentToken(serverUrl, machineToken, handle, displayName, options = {}, fetchImpl = fetch) {
     const res = await fetchImpl(`${serverUrl}/daemon/agents/token`, {
         method: "POST",

package/dist/workspace-control-handler.js

@@ -0,0 +1,27 @@
+/** 控制面文件/技能查看的按需处理，独立于执行生命周期。 */
+import { join } from "node:path";
+import { readSharedMessageFile } from "./message-file-preview.js";
+import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
+import { listSkills } from "./skills.js";
+import { listRuntimeModels } from "./list-models.js";
+export async function handleWorkspaceControlRequest(raw, agentsRoot, registry, models = listRuntimeModels) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const request = raw;
+    if (!["fs:list", "fs:read", "fs:read-shared", "skills:list", "probe-models"].includes(request.type))
+        return null;
+    if (typeof request.reqId !== "string" || request.reqId.length > 128)
+        return null;
+    try {
+        const root = join(agentsRoot, request.handle);
+        const data = request.type === "fs:read-shared" ? await readSharedMessageFile(agentsRoot, raw, registry)
+            : request.type === "fs:list" ? await listWorkspace(root, request.path)
+                : request.type === "fs:read" ? await readWorkspaceFile(root, request.path)
+                    : request.type === "skills:list" ? await listSkills(request.runtime)
+                        : { models: await models(request.runtime ?? "") };
+        return { type: "fs:result", reqId: request.reqId, ok: true, data };
+    }
+    catch (error) {
+        return { type: "fs:result", reqId: request.reqId, ok: false, error: request.type === "probe-models" ? "runtime_model_probe_failed" : error.message };
+    }
+}