@nowcrew/daemon 0.6.88-beta.3 → 0.6.88-beta.31

package/dist/computer-setup.js

@@ -0,0 +1,244 @@
+import { parseArgs } from "node:util";
+import { z } from "zod";
+import { DEFAULT_SERVER_URL } from "./config.js";
+import { installDaemonAutomatically, } from "./automatic-daemon-installer.js";
+import { createComputerSetupClient, openSetupBrowser, redactSetupSecrets, } from "./computer-setup-client.js";
+import { runComputerSetupOrchestration, } from "./computer-setup-orchestration.js";
+import { detectDaemonLang, formatDaemonText } from "./i18n.js";
+import { systemCommandRunner } from "./computer-service.js";
+const WorkspaceSlugSchema = z.string()
+    .min(2)
+    .max(40)
+    .regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/u);
+const WorkspaceIdSchema = z.string().uuid();
+const MachineIdSchema = z.string().uuid();
+const ServerUrlSchema = z.string().url().refine((value) => {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:")
+        && url.username.length === 0
+        && url.password.length === 0
+        && (url.pathname === "" || url.pathname === "/")
+        && url.search.length === 0
+        && url.hash.length === 0;
+}, "server URL must be an HTTP(S) origin without embedded credentials");
+function stringValue(values, key) {
+    const value = values[key];
+    return typeof value === "string" ? value : undefined;
+}
+function booleanValue(values, key) {
+    return values[key] === true;
+}
+function optionOccurrences(argv, name) {
+    const prefix = `--${name}`;
+    const values = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === prefix) {
+            const next = argv[index + 1];
+            if (next !== undefined && !next.startsWith("--"))
+                values.push(next);
+            index += 1;
+            continue;
+        }
+        if (value?.startsWith(`${prefix}=`))
+            values.push(value.slice(prefix.length + 1));
+    }
+    return values;
+}
+function assertRepeatedOptionValuesAgree(argv, name, normalize) {
+    const normalized = optionOccurrences(argv, name).map(normalize);
+    if (new Set(normalized).size > 1) {
+        throw new Error(`Repeated --${name} values conflict`);
+    }
+}
+function normalizedServerOrigin(value) {
+    const parsed = new URL(ServerUrlSchema.parse(value));
+    return `${parsed.protocol}//${parsed.host}`;
+}
+function workspaceFromSlug(value) {
+    if (!value.startsWith("/") || value.startsWith("//")) {
+        throw new Error("Workspace slug must use exactly one leading slash, for example /nowcoder-app");
+    }
+    return WorkspaceSlugSchema.parse(value.slice(1));
+}
+function workspaceFromAlias(value) {
+    return value.startsWith("/") ? workspaceFromSlug(value) : WorkspaceSlugSchema.parse(value);
+}
+export function parseSetupArgs(argv) {
+    assertRepeatedOptionValuesAgree(argv, "workspace", (value) => workspaceFromAlias(value));
+    assertRepeatedOptionValuesAgree(argv, "workspace-id", (value) => WorkspaceIdSchema.parse(value).toLowerCase());
+    assertRepeatedOptionValuesAgree(argv, "machine", (value) => MachineIdSchema.parse(value).toLowerCase());
+    assertRepeatedOptionValuesAgree(argv, "machine-id", (value) => MachineIdSchema.parse(value).toLowerCase());
+    assertRepeatedOptionValuesAgree(argv, "server-url", normalizedServerOrigin);
+    const parsed = parseArgs({
+        args: [...argv],
+        allowPositionals: true,
+        strict: true,
+        options: {
+            workspace: { type: "string" },
+            "workspace-id": { type: "string" },
+            machine: { type: "string" },
+            "machine-id": { type: "string" },
+            "server-url": { type: "string" },
+            json: { type: "boolean", default: false },
+            "no-browser": { type: "boolean", default: false },
+            help: { type: "boolean", short: "h", default: false },
+        },
+    });
+    const values = parsed.values;
+    const [command, ...positionals] = parsed.positionals;
+    if (command !== "setup")
+        throw new Error("Expected 'setup'");
+    if (booleanValue(values, "help"))
+        throw new Error(setupUsage());
+    if (positionals.length > 1)
+        throw new Error("Setup accepts one Workspace argument");
+    const workspaceAlias = stringValue(values, "workspace");
+    const workspaceIdAlias = stringValue(values, "workspace-id");
+    if (workspaceAlias !== undefined && workspaceIdAlias !== undefined) {
+        throw new Error("Choose one Workspace source: positional, --workspace, or --workspace-id");
+    }
+    const positionalWorkspace = positionals[0] === undefined ? undefined : workspaceFromSlug(positionals[0]);
+    const aliasWorkspace = workspaceAlias === undefined ? undefined : workspaceFromAlias(workspaceAlias);
+    if (positionalWorkspace !== undefined && workspaceIdAlias !== undefined) {
+        throw new Error("A positional Workspace slug cannot be combined with --workspace-id");
+    }
+    if (positionalWorkspace !== undefined && aliasWorkspace !== undefined && positionalWorkspace !== aliasWorkspace) {
+        throw new Error("Positional Workspace conflicts with --workspace");
+    }
+    const workspace = positionalWorkspace !== undefined
+        ? Object.freeze({ kind: "slug", value: positionalWorkspace })
+        : aliasWorkspace !== undefined
+            ? Object.freeze({ kind: "slug", value: aliasWorkspace })
+            : workspaceIdAlias === undefined
+                ? (() => { throw new Error("Missing Workspace; use /<slug> or --workspace-id <uuid>"); })()
+                : Object.freeze({ kind: "id", value: WorkspaceIdSchema.parse(workspaceIdAlias).toLowerCase() });
+    const machineAlias = stringValue(values, "machine");
+    const machineIdAlias = stringValue(values, "machine-id");
+    const parsedMachine = MachineIdSchema.parse(machineAlias ?? machineIdAlias ?? (() => {
+        throw new Error("Missing --machine <uuid>");
+    })()).toLowerCase();
+    if (machineAlias !== undefined && machineIdAlias !== undefined
+        && parsedMachine !== MachineIdSchema.parse(machineIdAlias).toLowerCase()) {
+        throw new Error("--machine conflicts with --machine-id");
+    }
+    const machineId = parsedMachine;
+    const serverUrl = stringValue(values, "server-url");
+    return Object.freeze({
+        command: "setup",
+        workspace,
+        machineId,
+        ...(serverUrl === undefined ? {} : { serverUrl: ServerUrlSchema.parse(serverUrl) }),
+        ...(booleanValue(values, "json") ? { json: true } : {}),
+        ...(booleanValue(values, "no-browser") ? { noBrowser: true } : {}),
+    });
+}
+function resolveSetupServerUrl(args, env) {
+    const configured = args.serverUrl ?? env.CREW_SERVER_URL?.trim();
+    if (configured !== undefined && configured.length > 0)
+        return normalizedServerOrigin(configured);
+    if (env.NODE_ENV === "development" || env.NODE_ENV === "test")
+        return DEFAULT_SERVER_URL;
+    throw new Error("server URL is required; pass --server-url or set CREW_SERVER_URL");
+}
+export function setupUsage(td = (message) => message) {
+    return [
+        td("Usage:"),
+        "  nowwork-computer setup /workspace --machine <uuid>",
+        "  nowwork-computer setup --workspace /workspace --machine <uuid>",
+        "  nowwork-computer setup --workspace-id <uuid> --machine-id <uuid>",
+        "",
+        "Options: --server-url <url> --json --no-browser",
+    ].join("\n") + "\n";
+}
+function defaults() {
+    return {
+        env: process.env,
+        platform: process.platform,
+        fetch: globalThis.fetch,
+        stdout: (text) => process.stdout.write(text),
+        stderr: (text) => process.stderr.write(text),
+        createClient: (serverUrl) => createComputerSetupClient({ serverUrl }),
+        installAutomatically: installDaemonAutomatically,
+        openBrowser: (url) => openSetupBrowser(url, process.platform, systemCommandRunner),
+        sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+        now: Date.now,
+    };
+}
+function humanSummary(result, td) {
+    return [
+        td("Workspace: {{value}}", { value: result.workspaceId }),
+        td("Machine:   {{value}}", { value: result.machineId }),
+        td("Environment: {{value}}", { value: result.environment }),
+        td("Daemon:    profile {{profile}} / v{{version}} / {{status}}", {
+            profile: result.profile, version: result.daemonVersion, status: result.serviceStatus,
+        }),
+        td("Local:     {{value}}", { value: result.localNowworkHome }),
+        td("Config:    {{value}}", { value: result.daemonHome }),
+        td("Agents:    {{value}}", { value: result.agentsRoot }),
+        ...(result.storageId === undefined ? [] : [td("Storage ID: {{value}}", { value: result.storageId })]),
+        td(result.helloConfirmed ? "Status:    connected and ready" : "Status:    not ready"),
+    ].join("\n") + "\n";
+}
+function localizedPairingMessage(lang, message) {
+    if (message.startsWith("Open ")) {
+        return formatDaemonText(lang, "Open {{url}}", { url: message.slice("Open ".length) });
+    }
+    if (message.startsWith("Code ")) {
+        return formatDaemonText(lang, "Code {{code}}", { code: message.slice("Code ".length) });
+    }
+    if (message.startsWith("Browser open skipped: ")) {
+        return formatDaemonText(lang, "Browser open skipped: {{reason}}", {
+            reason: message.slice("Browser open skipped: ".length),
+        });
+    }
+    return formatDaemonText(lang, message);
+}
+export async function runComputerSetupCommand(argv, overrides = {}) {
+    if (argv.length === 1 && (argv[0] === "--help" || argv[0] === "-h")) {
+        const deps = { ...defaults(), ...overrides };
+        const lang = detectDaemonLang(deps.env);
+        deps.stdout(setupUsage((message, values) => formatDaemonText(lang, message, values)));
+        return 0;
+    }
+    if (argv[0] !== "setup")
+        return null;
+    const deps = { ...defaults(), ...overrides };
+    const lang = detectDaemonLang(deps.env);
+    try {
+        if (argv.includes("--help") || argv.includes("-h")) {
+            deps.stdout(setupUsage((message, values) => formatDaemonText(lang, message, values)));
+            return 0;
+        }
+        let args;
+        try {
+            args = parseSetupArgs(argv);
+        }
+        catch (error) {
+            deps.stderr(`nowwork-computer: ${redactSetupSecrets(error.message)}\n`);
+            return 2;
+        }
+        if (args.json === true) {
+            deps.stderr(`${formatDaemonText(lang, "Starting computer setup pairing...")}\n`);
+        }
+        const serverUrl = resolveSetupServerUrl(args, deps.env);
+        const createClient = overrides.createClient
+            ?? ((value) => createComputerSetupClient({ serverUrl: value, fetch: deps.fetch }));
+        const result = await runComputerSetupOrchestration({ args, serverUrl }, {
+            client: createClient(serverUrl),
+            installAutomatically: deps.installAutomatically,
+            openBrowser: args.noBrowser === true ? async () => { } : deps.openBrowser,
+            sleep: deps.sleep,
+            reportPairing: (message) => deps[args.json === true ? "stderr" : "stdout"](`${localizedPairingMessage(lang, message)}\n`),
+            now: deps.now,
+        });
+        deps.stdout(args.json === true
+            ? `${JSON.stringify(result)}\n`
+            : humanSummary(result, (message, values) => formatDaemonText(lang, message, values)));
+        return 0;
+    }
+    catch (error) {
+        deps.stderr(`nowwork-computer: ${redactSetupSecrets(error.message)}\n`);
+        return 1;
+    }
+}

package/dist/config.js

@@ -76,12 +76,32 @@ function defaultCliPath() {
         return resolve(here, "../../cli/dist/main.js");
     }
 }
-// 临时 dev 验收名单。这里必须填写 Server 生成的 Agent handle，而不是显示名称或频道 ID。
-// 测试完成后删除此常量，恢复未配置时默认关闭的行为。
+// 保留本地开发的原默认名单；远端 dev 全量不再依赖该集合。
 const TEMP_LOCAL_MEMORY_V2_TEST_HANDLES = [
-    "94533bf3-b5b7-4a1e-9c41-6a1ab0a0e1ea", // memory-v2-test-a
-    "967ab9ce-724c-4f22-a664-2f855cd798af", // memory-v2-test-b
+    "94533bf3-b5b7-4a1e-9c41-6a1ab0a0e1ea", // memory-v2-test-b
+    "967ab9ce-724c-4f22-a664-2f855cd798af", // memory-v2-test-a
 ];
+export function localMemoryV2Environment(serverUrl) {
+    try {
+        const url = new URL(serverUrl);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            return "custom";
+        const hostname = url.hostname.toLowerCase().replace(/\.$/u, "");
+        if (hostname === "nowwork-dev.nowcoder.com")
+            return "dev";
+        if (hostname === "nowwork-in.nowcoder.com" || hostname === "nowwork.nowcoder.com")
+            return "production";
+    }
+    catch { /* 其它地址保留原配置行为。 */ }
+    return "custom";
+}
+/** 环境资格不代表旧格式已兼容；实际格式由本轮工作区准备阶段核对。 */
+export function isLocalMemoryV2Enabled(config, handle) {
+    const environment = localMemoryV2Environment(config.serverUrl);
+    if (environment !== "custom")
+        return environment === "dev";
+    return config.localMemoryV2Handles?.has(handle) === true;
+}
 function isTemporaryDevServer(serverUrl) {
     try {
         const hostname = new URL(serverUrl).hostname.toLowerCase();
@@ -111,13 +131,11 @@ function localMemoryV2Handles(env, serverUrl) {
     return new Set(handles);
 }
 export const DEFAULT_SERVER_URL = "http://127.0.0.1:3001";
-function codexHomeModeEnv(env) {
-    const value = env.CREW_CODEX_HOME_MODE;
-    if (value === undefined || value === "shared")
-        return "shared";
-    if (value === "private")
-        return "private";
-    throw new ConfigError("CREW_CODEX_HOME_MODE must be shared or private");
+function machineEnvironmentModeEnv(env) {
+    const value = env.NOWWORK_MACHINE_ENV_MODE ?? "auto";
+    if (value === "auto" || value === "zsh" || value === "bash" || value === "windows" || value === "off")
+        return value;
+    throw new ConfigError("NOWWORK_MACHINE_ENV_MODE must be auto, zsh, bash, windows, or off");
 }
 function codexCollaborationToolsEnv(env) {
     const value = (env.CREW_CODEX_COLLABORATION_TOOLS ?? "").trim().toLowerCase();
@@ -168,7 +186,7 @@ export function loadConfig(env = process.env) {
             : defaultQaReportRoot,
         cliPath: env.CREW_CLI_PATH ?? defaultCliPath(),
         runtimeBin: env.CREW_RUNTIME ?? "claude",
-        codexHomeMode: codexHomeModeEnv(env),
+        machineEnvironmentMode: machineEnvironmentModeEnv(env),
         codexCollaborationTools: codexCollaborationToolsEnv(env),
         dangerous: env.CREW_RUNTIME_SAFE !== "1", // 默认开启 (headless agent 在自有 workspace 内运行)
         resume: env.CREW_RESUME !== "off" && env.CREW_RESUME !== "0", // 默认开启;一键回退现状用 CREW_RESUME=off

package/dist/console-formatter.js

@@ -22,7 +22,7 @@ const clip = (text) => text.length > TOOL_RESULT_CAP
     ? `${text.slice(0, TOOL_RESULT_CAP)}… (+${text.length - TOOL_RESULT_CAP})`
     : text;
 const SCRIPT_TOOLS = new Set(["Bash", "PowerShell", "Shell"]);
-export function createConsoleFormatter() {
+export function createConsoleFormatter(runtime) {
     const pending = new Map();
     // listId → 上一条 todos 快照的指纹;仅用于丢弃「连续两次完全相同」的重复事件(无损去重)。
     // 只比对相邻快照,不做跨快照合并——进度推进的中间态必须逐条下发,否则前端进度条会停在旧值。
@@ -86,7 +86,7 @@ export function createConsoleFormatter() {
                     const filler = consumePendingThinking();
                     if (filler) {
                         const content = message.content.map((block) => block.type === "thinking" && !block.thinking?.trim() ? { ...block, thinking: filler } : block);
-                        return dedupeTodos(toConsoleLines({ ...rec, message: { ...message, content } }));
+                        return dedupeTodos(toConsoleLines({ ...rec, message: { ...message, content } }, runtime));
                     }
                 }
             }
@@ -146,7 +146,7 @@ export function createConsoleFormatter() {
                 }
                 return out;
             }
-            return dedupeTodos(toConsoleLines(event));
+            return dedupeTodos(toConsoleLines(event, runtime));
         },
     };
 }

package/dist/console.js

@@ -263,7 +263,7 @@ function codexItemChunks(item, td) {
     return [];
 }
 /** 把一个 stream-json 事件转成 0..N 条 console 行(完全透传)。 */
-export function toConsoleLines(event) {
+export function toConsoleLines(event, runtime) {
     const e = (event ?? {});
     const lang = detectDaemonLang();
     const td = (message) => translateDaemon(lang, message);
@@ -284,7 +284,20 @@ export function toConsoleLines(event) {
         return [{ stream: "system", text: `● ${td("Claude session started")}` }];
     }
     if (e.type === "thread.started") {
-        return [{ stream: "system", text: `● ${td("Codex session started")}` }];
+        // thread.started is shared by Codex and ACP adapters; its shape does not
+        // identify the runtime. Use the executor-owned selection, not event fields.
+        const messages = {
+            claude: "Claude session started",
+            codex: "Codex session started",
+            kimi: "Kimi session started",
+            hermes: "Hermes session started",
+            opencode: "OpenCode session started",
+            "deepseek-harness": "DeepSeek Harness session started",
+        };
+        const message = runtime && Object.hasOwn(messages, runtime)
+            ? messages[runtime]
+            : "Session started";
+        return [{ stream: "system", text: `● ${td(message)}` }];
     }
     if (e.type === "turn.plan.updated") {
         const plan = boundedCodexPlan(e.plan);

package/dist/daemon-update-eligibility.js

@@ -14,7 +14,7 @@ import { assertRegistryCoversDescriptors, listManagedServiceDescriptorPaths, man
 export async function managedDaemonCapabilities(eligibility) {
     try {
         return (await eligibility()).eligible
-            ? ["daemon_update_v1", "daemon_restart_v1", "daemon_update_registry_v1", "daemon_layout_migration_v1"]
+            ? ["daemon_update_v1", "daemon_restart_v1", "daemon_update_registry_v1"]
             : [];
     }
     catch {

package/dist/execution-journal.js

@@ -878,23 +878,26 @@ export function createExecutionJournal(agentsRoot, options = {}) {
         },
         acknowledgeCompletion: async (executionId) => {
             validateExecutionId(executionId);
-            const updated = await serializedExecution(executionId, "acknowledge_completion", async () => {
+            const result = await serializedExecution(executionId, "acknowledge_completion", async () => {
                 const entry = await requireRecord(executionId);
                 if (entry.state !== "completed" && entry.state !== "interrupted") {
                     throw new JournalTransitionError(`Cannot acknowledge ${entry.state} execution`);
                 }
-                if (entry.completionAcknowledged)
-                    return confirmDurable(entry);
+                if (entry.completionAcknowledged) {
+                    return { entry: await confirmDurable(entry), newlyAcknowledged: false };
+                }
                 const updated = JournalEntrySchema.parse({
                     ...entry,
                     completionAcknowledged: true,
                     updatedAt: now().toISOString(),
                 });
                 await writeRecord(updated);
-                return updated;
+                return { entry: updated, newlyAcknowledged: true };
             });
-            await serializedDirectory(pruneInternal);
-            return updated;
+            // 重复 ACK 仍确认持久化，但不能反复全目录清理并阻塞后续控制帧。
+            if (result.newlyAcknowledged)
+                await serializedDirectory(pruneInternal);
+            return result.entry;
         },
         get: async (executionId) => {
             validateExecutionId(executionId);

package/dist/execution-protocol.js

@@ -200,7 +200,7 @@ export const ExecutionStartSchema = z.object({
         language: z.enum(["zh", "en"]),
         systemPrompt: z.string(),
         wakePrompt: z.string(),
-        maintenancePurpose: z.literal("self_training").optional(),
+        maintenancePurpose: z.enum(["self_training", "memory_prune"]).optional(),
     }).strict(),
     runtime: z.object({
         name: RuntimeSchema,
@@ -264,6 +264,7 @@ export const ExecutionRejectedSchema = z.object({
     reason: RejectionReasonSchema,
     message: z.string().optional(),
     at: TimestampSchema,
+    preAdmissionProof: z.object({ specHash: z.string().regex(/^[a-f0-9]{64}$/u) }).strict().optional(),
 }).strict();
 export const ExecutionStartedSchema = z.object({
     type: z.literal("execution:started"),

package/dist/execution-runner.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
-import { resolveReposRoot } from "./config.js";
+import { isLocalMemoryV2Enabled, localMemoryV2Environment, resolveReposRoot } from "./config.js";
 import { DaemonToServerExecutionFrameSchema, ExecutionCompletedSchema, ExecutionRejectedSchema, ExecutionStartSchema, } from "./execution-protocol.js";
 import { JournalConflictError } from "./execution-journal.js";
 import { boundExecutionFrame } from "./execution-event-limit.js";
@@ -210,6 +210,7 @@ function launchProviderConfig(config) {
             ? {}
             : { providerSmallFastModel: config.providerSmallFastModel }),
         ...(config.envVars === undefined ? {} : { envVars: config.envVars }),
+        ...(config.environmentPlan === undefined ? {} : { environmentPlan: config.environmentPlan }),
         ...(config.description === undefined ? {} : { description: config.description }),
     };
 }
@@ -408,7 +409,8 @@ export async function runExecution(config, input, dependencies) {
         ? { permission: effectivePermission(spec, config) }
         : admission(spec, config, dependencies, initialAt);
     if ("rejected" in checked) {
-        const frame = ExecutionRejectedSchema.parse(boundExecutionFrame(checked.rejected, config.executionLimits.maxEventBytes));
+        const proof = await dependencies.confirmPreAdmission?.(checked.rejected).catch(() => false);
+        const frame = ExecutionRejectedSchema.parse(boundExecutionFrame({ ...checked.rejected, ...(proof ? { preAdmissionProof: { specHash } } : {}) }, config.executionLimits.maxEventBytes));
         await dependencies.report(frame);
         return { kind: "rejected", frame };
     }
@@ -745,6 +747,7 @@ export async function runExecution(config, input, dependencies) {
             },
         });
         const localDependencies = {
+            ...(dependencies.machineEnvironment === undefined ? {} : { machineEnvironment: dependencies.machineEnvironment }),
             ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
             ...(dependencies.startupGate === undefined ? {} : { startupGate: dependencies.startupGate }),
             ...(dependencies.startupTimeoutMs === undefined
@@ -829,12 +832,15 @@ export async function runExecution(config, input, dependencies) {
         const baseSystemPromptBudget = spec.agent.abilityRelease === undefined
             ? systemPromptBudget
             : Math.max(0, Math.min(systemPromptBudget, Math.max(32 * 1024, systemPromptBudget - 168 * 1024)));
-        const localMemoryV2Enabled = config.localMemoryV2Handles?.has(spec.agent.handle) === true;
-        const systemPromptWithLocalFacts = withLocalExecutionFacts(`${spec.instructions.systemPrompt}${localMemoryV2Enabled ? renderLocalMemoryV2WriteGuard() : ""}`, baseSystemPromptBudget, {
-            ...(selfTraining ? { isolateLocalMemory: true } : {}),
-            collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex",
-        });
+        const localMemoryV2Enabled = !selfTraining && isLocalMemoryV2Enabled(config, spec.agent.handle);
+        // 开发环境的系统/当前轮写保护由 prepareLocalMemoryPrompt 统一注入并预留预算。
+        const localMemoryGuardInBase = localMemoryV2Environment(config.serverUrl) === "custom";
         const boundedSystemPrompt = (context) => {
+            const enabled = context.workspace.localMemoryV2Enabled ?? localMemoryV2Enabled;
+            const systemPromptWithLocalFacts = withLocalExecutionFacts(`${spec.instructions.systemPrompt}${enabled && localMemoryGuardInBase ? renderLocalMemoryV2WriteGuard() : ""}`, baseSystemPromptBudget, {
+                ...(selfTraining ? { isolateLocalMemory: true } : {}),
+                collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex",
+            });
             const base = typeof systemPromptWithLocalFacts === "string"
                 ? systemPromptWithLocalFacts
                 : systemPromptWithLocalFacts(context);
@@ -844,6 +850,7 @@ export async function runExecution(config, input, dependencies) {
             executionId: spec.executionId,
             handle: spec.agent.handle,
             channelId: spec.context.channelId,
+            ...(spec.context.threadId === undefined ? {} : { threadId: spec.context.threadId }),
             keyMode: "opaque",
             taskKey: spec.workspace.taskKey,
             ...(spec.workspace.resumeKey === undefined ? {} : { resumeKey: spec.workspace.resumeKey }),
@@ -876,7 +883,6 @@ export async function runExecution(config, input, dependencies) {
                 ...(config.qaReportRoot === undefined ? {} : { qaReportRoot: config.qaReportRoot }),
                 cliPath: config.cliPath,
                 providerConfig,
-                codexHomeMode: config.codexHomeMode,
                 ...(providerConfig.description ? { description: providerConfig.description } : {}),
                 ...(spec.reporting.allowBoundImDecision ? {
                     systemEnv: {
@@ -885,13 +891,13 @@ export async function runExecution(config, input, dependencies) {
                 } : {}),
             },
             session: {
-                enabled: selfTraining ? false : config.resume,
+                enabled: spec.instructions.maintenancePurpose !== undefined ? false : config.resume,
                 warmMs: config.resumeWarmMs,
                 budgetTokens: config.sessionBudgetTokens,
                 softTokens: config.sessionSoftTokens,
                 maxTurns: config.sessionMaxTurns,
             },
-            ...(selfTraining ? { maintenancePurpose: "self_training" } : {}),
+            ...(spec.instructions.maintenancePurpose === undefined ? {} : { maintenancePurpose: spec.instructions.maintenancePurpose }),
             localMemoryV2Enabled,
         };
         const result = await Promise.race([

package/dist/i18n.js

@@ -18,6 +18,11 @@ export function detectDaemonLang(env = process.env) {
 const zh = {
     "Claude session started": "Claude 会话启动",
     "Codex session started": "Codex 会话启动",
+    "Kimi session started": "Kimi 会话启动",
+    "Hermes session started": "Hermes 会话启动",
+    "OpenCode session started": "OpenCode 会话启动",
+    "DeepSeek Harness session started": "DeepSeek Harness 会话启动",
+    "Session started": "会话启动",
     "Plan updated": "计划更新",
     "Thinking (~{{tokens}} tokens, content not streamed by Claude Code)": "思考（约 {{tokens}} tokens，Claude Code 未输出思考正文）",
     "Thinking (content not streamed by Claude Code)": "思考（Claude Code 未输出思考正文）",
@@ -26,6 +31,20 @@ const zh = {
     "Run finished": "本轮结束",
     "Missing CREW_MACHINE_TOKEN (sk_machine_*, printed by seed)": "缺少 CREW_MACHINE_TOKEN（sk_machine_*，由 seed 打印）",
     "Usage:": "用法：",
+    "Open {{url}}": "打开 {{url}}",
+    "Code {{code}}": "验证码 {{code}}",
+    "Browser open skipped: {{reason}}": "未能自动打开浏览器：{{reason}}",
+    "Starting computer setup pairing...": "正在发起电脑接入授权…",
+    "Workspace: {{value}}": "工作区：{{value}}",
+    "Machine:   {{value}}": "机器：   {{value}}",
+    "Environment: {{value}}": "环境：{{value}}",
+    "Daemon:    profile {{profile}} / v{{version}} / {{status}}": "Daemon：配置 {{profile}} / v{{version}} / {{status}}",
+    "Local:     {{value}}": "本地目录：{{value}}",
+    "Config:    {{value}}": "配置目录：{{value}}",
+    "Agents:    {{value}}": "Agent 目录：{{value}}",
+    "Storage ID: {{value}}": "存储标识：{{value}}",
+    "Status:    connected and ready": "状态：已连接并就绪",
+    "Status:    not ready": "状态：尚未就绪",
     "connect and stay resident": "连接并常驻",
     "run once manually": "手动运行一次",
     "resident, connecting to": "常驻，连接到",

package/dist/list-models.js

@@ -1,13 +1,15 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { isWin } from "./platform.js";
+import { augmentedPath } from "./runtime-path.js";
 import { listClaudeModels } from "./runtimes/claude-models.js";
 import { listHermesModels } from "./runtimes/hermes-models.js";
 const execFileRaw = promisify(execFile);
 const MODEL_PROBE_TIMEOUT_MS = 8_000;
 const MODEL_PROBE_MAX_BUFFER_BYTES = 1024 * 1024;
 // win32 上 npm CLI 是 .cmd shim,execFile 需 shell 才能执行;参数全是固定字面量,无注入面。
-const execFileP = (bin, args) => execFileRaw(bin, args, {
+const execFileP = (bin, args, env = { ...process.env, PATH: augmentedPath() }) => execFileRaw(bin, args, {
+    env,
     shell: isWin(),
     timeout: MODEL_PROBE_TIMEOUT_MS,
     killSignal: "SIGKILL",
@@ -16,17 +18,17 @@ const execFileP = (bin, args) => execFileRaw(bin, args, {
 export async function listRuntimeModels(runtime, options = {}) {
     switch (runtime) {
         case "claude":
-            return listClaudeModels();
+            return listClaudeModels(undefined, options.env, options.environmentGeneration);
         case "codex":
-            return parseCodexModels((await execFileP("codex", ["debug", "models"])).stdout);
+            return parseCodexModels((await execFileP("codex", ["debug", "models"], options.env)).stdout);
         case "cursor":
-            return parseCursorModels((await execFileP("cursor-agent", ["--list-models"])).stdout);
+            return parseCursorModels((await execFileP("cursor-agent", ["--list-models"], options.env)).stdout);
         case "hermes":
             return listHermesModels(options);
         case "opencode":
-            return listOpencodeModels();
+            return listOpencodeModels(options.env);
         case "pi":
-            return parsePiModels((await execFileP("pi", ["--list-models"])).stdout);
+            return parsePiModels((await execFileP("pi", ["--list-models"], options.env)).stdout);
         default:
             return null;
     }
@@ -82,9 +84,9 @@ function parseCursorModels(stdout) {
         return { id: id.trim(), label: (label || id).trim(), ...(index === 0 ? { default: true } : {}) };
     });
 }
-async function outputEvenOnFailure(bin, args) {
+async function outputEvenOnFailure(bin, args, env) {
     try {
-        return (await execFileP(bin, args)).stdout;
+        return (await execFileP(bin, args, env)).stdout;
     }
     catch (error) {
         const stdout = error.stdout;
@@ -95,11 +97,11 @@ async function outputEvenOnFailure(bin, args) {
         return "";
     }
 }
-async function listOpencodeModels() {
-    const verbose = parseOpencodeModels(await outputEvenOnFailure("opencode", ["models", "--verbose"]));
+async function listOpencodeModels(env) {
+    const verbose = parseOpencodeModels(await outputEvenOnFailure("opencode", ["models", "--verbose"], env));
     if (verbose.length > 0)
         return verbose;
-    return parseOpencodeModels(await outputEvenOnFailure("opencode", ["models"]));
+    return parseOpencodeModels(await outputEvenOnFailure("opencode", ["models"], env));
 }
 const VARIANT_ORDER = new Map([
     ["none", 0], ["minimal", 1], ["low", 2], ["medium", 3],

package/dist/local-execution-lease.js

@@ -0,0 +1,22 @@
+import { awaitWithCancellation } from "./runtime-cancellation.js";
+const leaseTails = new Map();
+/** 同一进程内的短操作或原生会话排队；等待取消也不会越过前一位持有者。 */
+export async function withKeyedLease(key, operation, cancellation) {
+    const predecessor = leaseTails.get(key) ?? Promise.resolve();
+    // 解锁函数在等待 predecessor 前可用，保留取消等待时的队列顺序。
+    let unlock;
+    const current = new Promise(resolve => { unlock = resolve; });
+    const queued = predecessor.then(() => current);
+    leaseTails.set(key, queued);
+    try {
+        await awaitWithCancellation(predecessor, cancellation);
+        return await operation();
+    }
+    finally {
+        unlock();
+        void queued.then(() => {
+            if (leaseTails.get(key) === queued)
+                leaseTails.delete(key);
+        });
+    }
+}