@nowcrew/daemon 0.6.89 → 0.6.90

package/dist/pre-admission-rejection.js

@@ -0,0 +1,64 @@
+import { ExecutionCompletedSchema, ExecutionRejectedSchema } from "./execution-protocol.js";
+import { hashExecutionSpec } from "./execution-runner.js";
+import { dslog } from "./slog.js";
+/** Queue rejection is admission work too: own the ID before any asynchronous journal write. */
+export async function rejectQueuedAdmission(context, spec, executionClass, facts) {
+    const id = spec.executionId;
+    const hash = hashExecutionSpec(spec);
+    if (context.knownExecutionHashes.has(id) || context.executionRuns.has(id)) {
+        // A same-ID request won while the caller awaited journal.get. Its journal may
+        // still be pending; silence lets its real result arrive instead of rejecting it.
+        const existing = await context.journal.get(id);
+        if (existing?.specHash === hash)
+            context.replay(existing);
+        return;
+    }
+    context.knownExecutionHashes.set(id, hash);
+    const rejected = ExecutionRejectedSchema.parse({
+        type: "execution:rejected", protocolVersion: 1, executionId: id,
+        reason: "resource_limit", message: "Local machine execution queue is full", at: new Date().toISOString(),
+    });
+    dslog("execution.machine_queue_rejected", "机器执行队列已满", {
+        level: "WARN", execution_id: id, agent_handle: spec.agent.handle, execution_class: executionClass, ...facts,
+    });
+    const rejecting = persistPreAdmissionRejection(context.journal, spec, rejected)
+        .then(async (entry) => {
+        if (entry)
+            await context.report({ ...rejected, preAdmissionProof: { specHash: hash } });
+        else {
+            const existing = await context.journal.get(id);
+            if (existing?.specHash === hash)
+                context.replay(existing);
+        }
+    })
+        .catch(error => {
+        // A failed durable write has no safe rejection proof; a restart/sync will
+        // reconcile an accepted tombstone if this admission created one.
+        dslog("execution.admission_rejection_failed", "准入拒绝未取得持久停止证明", {
+            level: "ERROR", execution_id: id, error_message: String(error),
+        });
+    })
+        .finally(() => {
+        if (context.executionRuns.get(id) === rejecting) {
+            context.executionRuns.delete(id);
+            context.knownExecutionHashes.delete(id);
+        }
+    });
+    context.executionRuns.set(id, rejecting);
+    await rejecting;
+}
+/** The caller synchronously owns this admission ID. Never complete somebody else's record. */
+export async function persistPreAdmissionRejection(journal, spec, rejection) {
+    const accepted = await journal.accept(spec.executionId, hashExecutionSpec(spec), {
+        runtime: spec.runtime.name, ...(spec.runtime.model ? { model: spec.runtime.model } : {}), resumed: false,
+    });
+    if (accepted.kind !== "created")
+        return null;
+    return journal.complete(spec.executionId, ExecutionCompletedSchema.parse({
+        type: "execution:completed", protocolVersion: 1, executionId: spec.executionId,
+        outcome: "failed", errorCode: rejection.reason, errorMessage: rejection.message ?? "Admission rejected before runtime start",
+        runtime: spec.runtime.name, ...(spec.runtime.model ? { model: spec.runtime.model } : {}), resumed: false,
+        startedAt: accepted.acceptedAt,
+        finishedAt: new Date(Math.max(Date.now(), Date.parse(accepted.acceptedAt))).toISOString(),
+    }));
+}

package/dist/project-skills/execution-adapter.js

@@ -9,10 +9,11 @@ export function projectSkillExecutionProjection(bindings, generation) {
         });
 }
 /**
- * 投影门控与 ownership 判定的唯一谓词:只有绑定了 Project Skills 且运行时是 codex/claude 的执行
+ * 投影门控与 ownership 判定的唯一谓词:只有绑定了 Project Skills 且运行时支持受控目录的执行
  * 才会有投影目录,也才需要在停止无法证明时保留它。两处判定分开写过一次,结果 kimi + projectSkills
  * 会在取消路径上错抛 ownership 未确认。
  */
 export const projectSkillProjectionApplies = (spec) => spec.agent.projectSkills !== undefined
-    && (spec.runtime.name === "codex" || spec.runtime.name === "claude");
+    && (spec.runtime.name === "codex" || spec.runtime.name === "claude"
+        || spec.runtime.name === "deepseek-harness");
 export const projectSkillProjectionErrorCode = (error) => error instanceof ProjectProjectionError ? error.code : null;

package/dist/project-skills/runtime-launch.js

@@ -11,12 +11,26 @@ export function projectSkillRuntimeLaunchFacts(runtime, root) {
     if (runtime === "claude") {
         return Object.freeze({ claudeAdditionalDirectory: root.claudeAdditionalDirectory });
     }
+    if (runtime === "deepseek-harness") {
+        return Object.freeze({ harnessSkillRoot: root.codexSkillRoot });
+    }
     throw new ProjectProjectionError("skill_projection_failed");
 }
 /** Builds Runtime-native arrays while keeping v1 shared roots separate from v2 exact roots. */
 export async function projectSkillRuntimeDirectories(input) {
     const trainingProjectRoots = input.trainingProjectRoots ?? [];
     const facts = projectSkillRuntimeLaunchFacts(input.runtime, input.runtimeRoot);
+    if (input.runtime === "deepseek-harness") {
+        // Harness 的 local provider 接受直接包含 Skill 子目录的受控 root,不扫描项目/用户目录。
+        return Object.freeze({
+            codexSkillRoots: Object.freeze([]),
+            claudeAdditionalDirectories: Object.freeze([]),
+            harnessSkillRoots: Object.freeze([
+                ...(facts.harnessSkillRoot === undefined ? [] : [facts.harnessSkillRoot]),
+                ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
+            ]),
+        });
+    }
     const codexSkillRoots = input.runtime === "codex"
         && (input.runtimeRoot !== undefined || input.projectContext !== undefined)
         ? Object.freeze([

package/dist/provider-env.js

@@ -10,7 +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";
+import { mergeRuntimeEnvironments } from "./runtime-environment-merge.js";
 const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const RESERVED_ENV = new Set([
     "PATH",
@@ -57,26 +57,26 @@ const CONFLICTING_CODEX_ENV = [
     DEEPSEEK_CODEX_KEY_ENV,
 ];
 /** 返回叠加了 provider 隔离的新 env(不改入参);不支持的 runtime/provider 组合原样返回。 */
-export function applyProviderEnv(base, runtime, cfg, homeDir, deepSeekHomeOverride) {
+export function applyProviderEnv(base, runtime, cfg, homeDir, deepSeekHomeOverride, platform = process.platform) {
     if (runtime === "codex" && cfg.provider === "deepseek") {
         const env = { ...base };
-        for (const key of CONFLICTING_CODEX_ENV)
-            delete env[key];
+        for (const key of Object.keys(env))
+            if (CONFLICTING_CODEX_ENV.includes(platform === "win32" ? key.toUpperCase() : key))
+                delete env[key];
         env.CODEX_HOME = deepSeekHomeOverride ?? deepSeekCodexHome(homeDir);
         if (cfg.providerApiKey)
             env[DEEPSEEK_CODEX_KEY_ENV] = cfg.providerApiKey;
         return env;
     }
     if (runtime === "codex") {
-        if (cfg.codexHomeMode === "private")
-            return { ...base, CODEX_HOME: join(homeDir, ".codex") };
         return base;
     }
     if (runtime !== "claude" || cfg.provider !== "custom")
         return base;
     const env = { ...base };
-    for (const k of CONFLICTING_ENV)
-        delete env[k];
+    for (const key of Object.keys(env))
+        if (CONFLICTING_ENV.includes(platform === "win32" ? key.toUpperCase() : key))
+            delete env[key];
     if (cfg.providerBaseUrl)
         env.ANTHROPIC_BASE_URL = cfg.providerBaseUrl;
     if (cfg.providerApiKey) {
@@ -94,20 +94,31 @@ export function applyProviderEnv(base, runtime, cfg, homeDir, deepSeekHomeOverri
         env.ANTHROPIC_SMALL_FAST_MODEL = cfg.providerSmallFastModel;
         env.ANTHROPIC_DEFAULT_HAIKU_MODEL = cfg.providerSmallFastModel;
     }
-    return env;
+    return mergeRuntimeEnvironments([env], platform);
+}
+const deepSeekHarnessMachineOwnedKey = (key, platform) => {
+    const identity = platform === "win32" ? key.toUpperCase() : key;
+    return identity.startsWith("DEEPSEEK_") || identity.startsWith("NOWCREW_DEEPSEEK_HARNESS_") || identity.startsWith("DSH_");
+};
+/** 子命令切换目录后仍必须保留 provider 的鉴权/路由边界，包括被清除的键。 */
+export function providerOwnedEnvironmentKeys(runtime, cfg, candidateKeys, platform = process.platform) {
+    if (runtime === "claude" && cfg.provider === "custom")
+        return [...CONFLICTING_ENV, "CLAUDE_CONFIG_DIR"];
+    if (runtime === "codex" && cfg.provider === "deepseek")
+        return CONFLICTING_CODEX_ENV;
+    if (runtime === "deepseek-harness")
+        return candidateKeys.filter(key => deepSeekHarnessMachineOwnedKey(key, platform));
+    return [];
 }
-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) {
+export function applyDeepSeekHarnessMachineEnv(base, machineEnv, platform = process.platform) {
     const env = { ...base };
     for (const key of Object.keys(env)) {
-        if (deepSeekHarnessMachineOwnedKey(key))
+        if (deepSeekHarnessMachineOwnedKey(key, platform))
             delete env[key];
     }
     for (const [key, value] of Object.entries(machineEnv)) {
-        if (deepSeekHarnessMachineOwnedKey(key) && value !== undefined)
+        if (deepSeekHarnessMachineOwnedKey(key, platform) && value !== undefined)
             env[key] = value;
     }
     return env;

package/dist/runner.js

@@ -1,7 +1,8 @@
+import { createMachineEnvironmentProvider } from "./machine-environment-cache.js";
 /** Legacy agent orchestration around the business-neutral local executor. */
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
-import { resolveReposRoot } from "./config.js";
+import { isLocalMemoryV2Enabled, resolveReposRoot } from "./config.js";
 import { mintAgentToken } from "./token.js";
 import { buildSystemPrompt, buildWakePrompt, capMemoryForInject, capWorkLogForInject } from "./prompt.js";
 import { deliverScheduledReport, } from "./scheduled-report.js";
@@ -24,6 +25,18 @@ function runtimeName(value) {
     throw new Error(`unsupported runtime: ${value}`);
 }
 export async function runAgent(config, input, onActivity = defaultPrint, onConsole = () => { }, dependencies = {}) {
+    const owned = dependencies.machineEnvironment === undefined;
+    const machineEnvironment = dependencies.machineEnvironment
+        ?? createMachineEnvironmentProvider({ mode: config.machineEnvironmentMode ?? "off" });
+    try {
+        return await runAgentWithMachineEnvironment(config, input, onActivity, onConsole, { ...dependencies, machineEnvironment });
+    }
+    finally {
+        if (owned)
+            await machineEnvironment.stop();
+    }
+}
+async function runAgentWithMachineEnvironment(config, input, onActivity = defaultPrint, onConsole = () => { }, dependencies = {}) {
     const threadId = input.scheduled ? undefined : input.threadId;
     const taskAnchor = threadId ?? input.wakeMessageId;
     // Old servers have no typed maintenance purpose. A legacy marker can only
@@ -36,7 +49,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
     }), dependencies.cancellation);
     const providerConfig = credential.config ?? {};
     const runtime = runtimeName(providerConfig.runtime ?? config.runtimeBin);
-    const localMemoryV2Enabled = config.localMemoryV2Handles?.has(input.handle) === true;
+    const localMemoryV2Enabled = isLocalMemoryV2Enabled(config, input.handle);
     const reasoning = ReasoningSchema.safeParse(providerConfig.reasoning);
     const baseWake = input.wake ?? buildWakePrompt(input.channelId);
     const executionId = input.runId ?? `legacy-${randomUUID()}`;
@@ -70,7 +83,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             memory: capMemoryForInject(workspace.memory),
             ...(resuming ? {} : { workLog: capWorkLogForInject(workspace.workLog) }),
             collaborationToolsEnabled: config.codexCollaborationTools && runtime === "codex",
-            localMemoryV2Enabled,
+            localMemoryV2Enabled: workspace.localMemoryV2Enabled ?? localMemoryV2Enabled,
         }),
         // Native adapters, not a launch-intent prompt, choose history versus delta.
         wakePrompt: () => baseWake,
@@ -91,7 +104,6 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             ...(config.qaReportRoot === undefined ? {} : { qaReportRoot: config.qaReportRoot }),
             cliPath: config.cliPath,
             providerConfig,
-            codexHomeMode: config.codexHomeMode,
             ...(providerConfig.description ? { description: providerConfig.description } : {}),
             systemEnv: {
                 ...(providerConfig.fastMode ? { CREW_FAST_MODE: "1" } : {}),
@@ -119,6 +131,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
         onRuntimeStarting: () => dependencies.onRuntimePhase?.("starting", runtime),
         onRuntimeRunning: () => dependencies.onRuntimePhase?.("running", runtime),
     }, {
+        ...(dependencies.machineEnvironment === undefined ? {} : { machineEnvironment: dependencies.machineEnvironment }),
         launchRuntime: dependencies.launchRuntime ?? ((request) => launchSupervisedRuntime(request, dependencies.startSupervisor, dependencies.cancellation, dependencies.platform)),
         ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
         ...(dependencies.startupGate === undefined ? {} : { startupGate: dependencies.startupGate }),

package/dist/runtime-environment-merge.js

@@ -0,0 +1,16 @@
+/** Keep layer order authoritative even when Windows keys use different casing. */
+export function mergeRuntimeEnvironments(layers, platform = process.platform) {
+    const entries = new Map();
+    for (const layer of layers) {
+        for (const [key, value] of Object.entries(layer)) {
+            if (value !== undefined)
+                entries.set(platform === "win32" ? key.toUpperCase() : key, [key, value]);
+        }
+    }
+    return Object.fromEntries(entries.values());
+}
+export function runtimeEnvironmentValue(env, key, platform = process.platform) {
+    if (platform !== "win32")
+        return env?.[key];
+    return Object.entries(env ?? {}).find(([candidate]) => candidate.toUpperCase() === key.toUpperCase())?.[1];
+}

package/dist/runtime-health-handler.js

@@ -3,3 +3,13 @@ export const runtimeHealthProbeHandler = (configuredProbe, executionRuntimesKnow
     ...(executionRuntimesKnown ? { availableRuntimes: detectedExecutionRuntimes } : {}),
 }));
 export const handleRuntimeHealthProbeFrame = (decoded, configuredProbe, executionRuntimesKnown, detectedExecutionRuntimes) => handleRuntimeProbeFrame(decoded, runtimeHealthProbeHandler(configuredProbe, executionRuntimesKnown, detectedExecutionRuntimes));
+/** 将探针结果按既有 RPC 帧返回，serve 只保留路由选择。 */
+export async function replyRuntimeHealthProbe(decoded, configuredProbe, known, runtimes, send) {
+    const result = await handleRuntimeHealthProbeFrame(decoded, configuredProbe, known, runtimes);
+    if (result !== null) {
+        try {
+            send({ type: "fs:result", ...result });
+        }
+        catch { /* Server 查询超时处理断连 */ }
+    }
+}

package/dist/runtime-health.js

@@ -123,7 +123,9 @@ export async function probeRuntimeHealth(request, dependencies = {}) {
     const now = dependencies.now ?? (() => new Date());
     const monotonicNow = dependencies.monotonicNow ?? (() => performance.now());
     const sourceEnv = dependencies.env ?? process.env;
-    const env = { ...sourceEnv, PATH: augmentedPath(sourceEnv) };
+    const env = dependencies.env === undefined
+        ? { ...sourceEnv, PATH: augmentedPath(sourceEnv) }
+        : { ...sourceEnv };
     const availableRuntimes = dependencies.availableRuntimes ?? parsed.availableRuntimes;
     const results = [];
     for (const target of parsed.runtimes) {

package/dist/runtime-path.js

@@ -8,24 +8,27 @@
  */
 import { existsSync } from "node:fs";
 import { win32, posix } from "node:path";
+import { runtimeEnvironmentValue } from "./runtime-environment-merge.js";
 const pathApi = (platform) => (platform === "win32" ? win32 : posix);
 /** 该平台常见 CLI 安装目录候选(是否真实存在稍后由 augmentedPath 校验)。 */
 export function commonBinDirs(env = process.env, platform = process.platform) {
     const p = pathApi(platform);
+    const value = (key) => runtimeEnvironmentValue(env, key, platform);
     if (platform === "win32") {
         const dirs = [];
-        if (env.USERPROFILE) {
-            dirs.push(p.join(env.USERPROFILE, ".kimi-code", "bin"), // Kimi 官方安装器默认落点
-            p.join(env.USERPROFILE, ".local", "bin"));
+        const userProfile = value("USERPROFILE"), appData = value("APPDATA"), localAppData = value("LOCALAPPDATA");
+        if (userProfile) {
+            dirs.push(p.join(userProfile, ".kimi-code", "bin"), // Kimi 官方安装器默认落点
+            p.join(userProfile, ".local", "bin"));
         }
-        if (env.APPDATA)
-            dirs.push(p.join(env.APPDATA, "npm"));
-        if (env.LOCALAPPDATA)
-            dirs.push(p.join(env.LOCALAPPDATA, "Microsoft", "WindowsApps"));
+        if (appData)
+            dirs.push(p.join(appData, "npm"));
+        if (localAppData)
+            dirs.push(p.join(localAppData, "Microsoft", "WindowsApps"));
         return dirs;
     }
     const dirs = [];
-    const home = env.HOME;
+    const home = value("HOME");
     if (home) {
         dirs.push(p.join(home, ".kimi-code", "bin"), // Kimi 官方安装器默认落点
         p.join(home, ".local", "bin"), // Claude 官方原生安装器默认落点
@@ -41,19 +44,26 @@ export function commonBinDirs(env = process.env, platform = process.platform) {
  * 在 `env.PATH` 基础上,把候选目录里「真实存在且尚未在 PATH 中」的去重后 prepend,返回新的 PATH 字符串。
  * 用户装的目录优先命中(prepend);全部已存在或都不在磁盘上时,原样返回 `env.PATH`。
  */
-export function augmentedPath(env = process.env, deps = {}, platform = process.platform) {
+export function augmentedPath(env = process.env, deps = {}, platform = process.platform, placement = "prepend") {
     const dirExists = deps.dirExists ?? existsSync;
     const sep = pathApi(platform).delimiter;
-    const current = env.PATH ?? "";
-    const existing = new Set(current.split(sep).filter((entry) => entry.length > 0));
+    const current = runtimeEnvironmentValue(env, "PATH", platform) ?? "";
+    const keyOf = (entry) => platform === "win32" ? entry.replace(/\//gu, "\\").toLowerCase() : entry;
+    const currentEntries = current.split(sep).filter((entry) => entry.length > 0);
+    const existing = new Set(currentEntries.map(keyOf));
     const extra = [];
     for (const dir of commonBinDirs(env, platform)) {
-        if (existing.has(dir) || extra.includes(dir))
+        if (existing.has(keyOf(dir)) || extra.some(entry => keyOf(entry) === keyOf(dir)))
             continue;
         if (!dirExists(dir))
             continue;
         extra.push(dir);
     }
+    if (placement === "append") {
+        const seen = new Set();
+        return [...currentEntries, ...extra].filter(entry => { const key = keyOf(entry); if (seen.has(key))
+            return false; seen.add(key); return true; }).join(sep);
+    }
     if (extra.length === 0)
         return current;
     return current.length > 0 ? `${extra.join(sep)}${sep}${current}` : extra.join(sep);

package/dist/runtime-probe.js

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

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

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

package/dist/runtimes/claude-models.js

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

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

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