@nowcrew/daemon 0.6.98-beta.2 → 0.6.98-beta.4

package/README.md

@@ -40,7 +40,40 @@ This compatibility form stays resident in the current terminal and reconnects wi
 `pnpm --filter @nowcrew/daemon daemon`. `crew-daemon run --agent <handle> --channel <id>` is the legacy
 manual one-shot entry.
 
-## Browser-Approved Computer Setup
+## Single-Command Computer Setup
+
+After the deployment enables Token setup, an owner/admin opens **Add Computer**, copies the complete
+command, and pastes it into the target computer's terminal. The same steps apply on macOS, Linux/SSH,
+and Windows. Node.js 22+ and npm must already be installed. The command launches the installer with npx;
+no separate global installation, browser confirmation, or verification code is needed during execution.
+
+The generated command pins an exact published installer version and includes a `--setup-token`.
+This is an already-approved one-time connection request, valid for ten minutes. The program exchanges
+it for the machine credential only when executed, then reuses native service installation, new-hello
+verification, credential finalization and rollback. Merely generating or copying a command does not
+rotate the existing credential. An expired or consumed command must be regenerated in the Web UI.
+
+For a machine credential you already hold, the same setup entry accepts `--api-key` or
+`CREW_MACHINE_TOKEN` without browser pairing:
+
+```bash
+nowwork-computer setup --server-url https://nowwork.nowcoder.com /nowcoder-app \
+  --machine <machine-uuid> --api-key <existing-machine-token>
+```
+
+The machine Token must match the specified Workspace and Computer. This path never rotates the
+credential or creates an approval request; it confirms a new control-plane connection with the expected
+profile and paths before reporting success. Token sources cannot be combined. JSON output puts progress
+on stderr and the final result on stdout. On Windows shells that block npm.ps1/npx.ps1, use npx.cmd as
+the package entry; the setup arguments and workflow are unchanged.
+
+Deployment requires `CREW_PUBLIC_URL` (or `CREW_SERVER_URL`) and
+`CREW_COMPUTER_TOKEN_SETUP_VERSION` set to an exact, published version known to support the Token flags.
+The server checks its published release catalog and channel before issuing a Token command. Leave the
+version unset until that installer has been released; it returns `computer_token_setup_unavailable`
+instead of generating a command for an unsupported package. Existing clients retain browser setup.
+
+## Browser-Approved Computer Setup (Compatibility)
 
 The Web UI generates a token-free command for a specific Workspace and Machine:
 
@@ -413,6 +446,13 @@ discovery is unchanged: Claude may still load `~/.claude/skills`, and Codex may
 and `~/.agents/skills`. The DeepSeek Codex variant keeps its Agent-private `.codex-deepseek` Home for
 provider credentials. Project bindings do not hide or rewrite any of those sources.
 
+Both Codex launchers disable host automatic memories and inherit the execution's prepared environment,
+overriding host `core`, default exclusions, `exclude` and `include_only` filters. These are process-local
+settings: authentication, providers and Skills retain the configured Home, and no other environment
+scope is merged. The policy version in Codex's session fingerprint cold-starts older native sessions
+once, then subsequent runs can resume normally. Explicit `shell_environment_policy.set` entries, shell
+startup scripts and Agent notes remain separate configuration; this change does not correct them.
+
 Binding changes reconcile immediately when the Computer is online. On reconnect the server sends the
 complete binding set for every Agent assigned to that Computer, including empty sets that clear stale
 links left by offline unbinds. Every non-empty execution snapshot is also reconciled immediately before

package/dist/computer-setup-client.js

@@ -39,6 +39,19 @@ const SetupBootstrapSchema = z.object({
     expiresAt: z.string().datetime({ offset: true }).optional(),
     machineToken: MachineTokenSchema,
 }).strict();
+const SetupTokenTargetSchema = SetupBootstrapSchema.omit({ setupId: true, machineToken: true }).extend({
+    workspaceSlug: z.string().min(1).max(80),
+    releaseTag: z.enum(["latest", "beta"]),
+    connection: z.object({
+        status: z.enum(["online", "offline"]),
+        epoch: z.number().int().nonnegative(),
+        profile: z.string().nullable(),
+        daemonHome: z.string().nullable(),
+        agentsRoot: z.string().nullable(),
+        storageId: z.string().optional(),
+        credentialMatchesConnection: z.boolean(),
+    }).strict(),
+}).strict();
 const SetupPendingSchema = z.object({
     status: z.enum(["authorization_pending", "pending"]),
     intervalSeconds: z.number().int().positive().max(300).optional(),
@@ -237,8 +250,8 @@ export function createComputerSetupClient(options) {
         setTimeout(resolve, milliseconds);
     }));
     const now = options.now ?? Date.now;
-    let activeMachineId;
     const request = async (method, path, body, bearer) => {
+        const secretInputs = [bearer ?? "", body?.deviceCode ?? ""];
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
         try {
@@ -253,7 +266,7 @@ export function createComputerSetupClient(options) {
             });
             const payload = await response.json();
             if (!response.ok || payload?.success === false) {
-                const message = redactSetupSecrets(payload?.error?.message ?? `computer setup request failed (HTTP ${response.status})`);
+                const message = redactSetupSecrets(payload?.error?.message ?? `computer setup request failed (HTTP ${response.status})`, secretInputs);
                 throw new ComputerSetupHttpError(message, response.status, payload?.error?.code ?? `HTTP_${response.status}`);
             }
             return (payload?.success === true ? payload.data : payload);
@@ -263,15 +276,15 @@ export function createComputerSetupClient(options) {
                 throw new Error("computer setup request timed out");
             if (error instanceof ComputerSetupHttpError)
                 throw error;
-            throw new Error(redactSetupSecrets(error instanceof Error ? error.message : String(error)));
+            throw new Error(redactSetupSecrets(error instanceof Error ? error.message : String(error), secretInputs));
         }
         finally {
             clearTimeout(timeoutId);
         }
     };
     return {
+        tokenTarget: async (machineToken) => SetupTokenTargetSchema.parse(await request("GET", "/daemon/computer-setup/target", undefined, machineToken)),
         start: async (input) => {
-            activeMachineId = input.machineId;
             return parseStart(await request("POST", "/api/auth/computer-setup/start", {
                 ...(input.workspace.kind === "id"
                     ? { workspaceId: input.workspace.value }
@@ -282,8 +295,6 @@ export function createComputerSetupClient(options) {
             }));
         },
         poll: async (deviceCode) => {
-            if (activeMachineId === undefined)
-                throw new Error("computer setup polling has no active machine");
             return parsePoll(await request("POST", "/api/auth/computer-setup/poll", { deviceCode }));
         },
         waitForHello: async (input) => {

package/dist/computer-setup-orchestration.js

@@ -6,7 +6,7 @@ function safeError(error, machineToken) {
     const message = redactSetupSecrets(error instanceof Error ? error.message : String(error), machineToken === undefined ? [] : [machineToken]);
     return new Error(message, error instanceof Error ? { cause: error } : undefined);
 }
-function assertBootstrapMatches(bootstrap, input) {
+export function assertBootstrapMatches(bootstrap, input) {
     if (bootstrap.machineId !== input.args.machineId) {
         throw new Error("setup bootstrap machine does not match --machine");
     }
@@ -40,7 +40,7 @@ function secondsUntil(expiresAt, now) {
     const remaining = Date.parse(expiresAt) - now();
     return Math.max(0, Math.ceil(remaining / 1_000));
 }
-function localPathsMatch(left, right, platform) {
+export function localPathsMatch(left, right, platform) {
     const paths = platform === "win32" ? win32 : posix;
     if (!paths.isAbsolute(left) || !paths.isAbsolute(right))
         return false;
@@ -51,6 +51,14 @@ function localPathsMatch(left, right, platform) {
     return normalize(left) === normalize(right);
 }
 async function obtainBootstrap(input, deps) {
+    if (input.args.setupToken !== undefined) {
+        deps.reportPairing("Checking computer connection information...");
+        const result = await deps.client.poll(input.args.setupToken);
+        if (result.status !== "authorized") {
+            throw new Error("Setup command expired or unavailable; regenerate it in NowWork and run the new command");
+        }
+        return result.bootstrap;
+    }
     const pairing = await deps.client.start({
         workspace: input.args.workspace,
         machineId: input.args.machineId,
@@ -116,6 +124,7 @@ export async function runComputerSetupOrchestration(input, deps) {
         bootstrap = authorized;
         machineToken = token;
         assertBootstrapMatches(authorized, input);
+        deps.reportPairing("Downloading, installing, and starting the Daemon service...");
         const installation = await deps.installAutomatically({
             serverUrl: authorized.serverUrl,
             machineToken: token,
@@ -128,6 +137,7 @@ export async function runComputerSetupOrchestration(input, deps) {
             ...(authorized.registryUrl === undefined ? {} : { requestedRegistryUrl: authorized.registryUrl }),
             beforeRollback: confirmRollback,
             verifyAfterStart: async (candidate) => {
+                deps.reportPairing("Confirming the computer connection...");
                 const hello = await deps.client.waitForHello({
                     machineToken: token,
                     machineId: authorized.machineId,
@@ -174,6 +184,7 @@ export async function runComputerSetupOrchestration(input, deps) {
         });
         return {
             workspaceId: authorized.workspaceId,
+            ...(authorized.workspaceSlug === undefined ? {} : { workspaceSlug: authorized.workspaceSlug }),
             machineId: authorized.machineId,
             environment: authorized.environment,
             profile: installation.profile,

package/dist/computer-setup.js

@@ -1,11 +1,13 @@
 import { parseArgs } from "node:util";
 import { z } from "zod";
 import { DEFAULT_SERVER_URL } from "./config.js";
+import { MachineTokenSchema } from "./computer-profile.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";
+import { runMachineTokenSetup } from "./computer-token-setup.js";
 const WorkspaceSlugSchema = z.string()
     .min(2)
     .max(40)
@@ -70,6 +72,8 @@ export function parseSetupArgs(argv) {
     assertRepeatedOptionValuesAgree(argv, "machine", (value) => MachineIdSchema.parse(value).toLowerCase());
     assertRepeatedOptionValuesAgree(argv, "machine-id", (value) => MachineIdSchema.parse(value).toLowerCase());
     assertRepeatedOptionValuesAgree(argv, "server-url", normalizedServerOrigin);
+    assertRepeatedOptionValuesAgree(argv, "setup-token", (value) => value);
+    assertRepeatedOptionValuesAgree(argv, "api-key", (value) => value);
     const parsed = parseArgs({
         args: [...argv],
         allowPositionals: true,
@@ -82,6 +86,8 @@ export function parseSetupArgs(argv) {
             "server-url": { type: "string" },
             json: { type: "boolean", default: false },
             "no-browser": { type: "boolean", default: false },
+            "setup-token": { type: "string" },
+            "api-key": { type: "string" },
             help: { type: "boolean", short: "h", default: false },
         },
     });
@@ -124,6 +130,14 @@ export function parseSetupArgs(argv) {
     }
     const machineId = parsedMachine;
     const serverUrl = stringValue(values, "server-url");
+    const setupToken = stringValue(values, "setup-token");
+    const machineToken = stringValue(values, "api-key");
+    if (setupToken !== undefined && machineToken !== undefined)
+        throw new Error("Choose one setup credential source");
+    if (setupToken !== undefined && !/^[A-Za-z0-9_-]{32,512}$/u.test(setupToken))
+        throw new Error("Invalid setup Token");
+    if (machineToken !== undefined)
+        MachineTokenSchema.parse(machineToken);
     return Object.freeze({
         command: "setup",
         workspace,
@@ -131,6 +145,8 @@ export function parseSetupArgs(argv) {
         ...(serverUrl === undefined ? {} : { serverUrl: ServerUrlSchema.parse(serverUrl) }),
         ...(booleanValue(values, "json") ? { json: true } : {}),
         ...(booleanValue(values, "no-browser") ? { noBrowser: true } : {}),
+        ...(setupToken === undefined ? {} : { setupToken }),
+        ...(machineToken === undefined ? {} : { machineToken }),
     });
 }
 function resolveSetupServerUrl(args, env) {
@@ -148,7 +164,8 @@ export function setupUsage(td = (message) => message) {
         "  nowwork-computer setup --workspace /workspace --machine <uuid>",
         "  nowwork-computer setup --workspace-id <uuid> --machine-id <uuid>",
         "",
-        "Options: --server-url <url> --json --no-browser",
+        "Options: --server-url <url> --setup-token <token> --api-key <sk_machine_*> --json --no-browser",
+        td("Token setup does not require browser authorization. CREW_MACHINE_TOKEN is also supported."),
     ].join("\n") + "\n";
 }
 function defaults() {
@@ -167,6 +184,7 @@ function defaults() {
 }
 function humanSummary(result, td) {
     return [
+        td("Connected to {{workspace}}.", { workspace: result.workspaceSlug ?? result.workspaceId }),
         td("Workspace: {{value}}", { value: result.workspaceId }),
         td("Machine:   {{value}}", { value: result.machineId }),
         td("Environment: {{value}}", { value: result.environment }),
@@ -205,6 +223,7 @@ export async function runComputerSetupCommand(argv, overrides = {}) {
         return null;
     const deps = { ...defaults(), ...overrides };
     const lang = detectDaemonLang(deps.env);
+    const secrets = [...optionOccurrences(argv, "setup-token"), ...optionOccurrences(argv, "api-key"), deps.env.CREW_MACHINE_TOKEN ?? ""];
     try {
         if (argv.includes("--help") || argv.includes("-h")) {
             deps.stdout(setupUsage((message, values) => formatDaemonText(lang, message, values)));
@@ -213,32 +232,43 @@ export async function runComputerSetupCommand(argv, overrides = {}) {
         let args;
         try {
             args = parseSetupArgs(argv);
+            const envToken = deps.env.CREW_MACHINE_TOKEN?.trim();
+            if (envToken) {
+                if (args.setupToken !== undefined || (args.machineToken !== undefined && args.machineToken !== envToken)) {
+                    throw new Error("Choose one setup credential source; clear CREW_MACHINE_TOKEN when using another Token");
+                }
+                args = Object.freeze({ ...args, machineToken: MachineTokenSchema.parse(envToken) });
+            }
         }
         catch (error) {
-            deps.stderr(`nowwork-computer: ${redactSetupSecrets(error.message)}\n`);
+            deps.stderr(`nowwork-computer: ${formatDaemonText(lang, redactSetupSecrets(error.message, secrets))}\n`);
             return 2;
         }
-        if (args.json === true) {
+        if (args.json === true && args.setupToken === undefined && args.machineToken === undefined) {
             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 }, {
+        const orchestrationDeps = {
             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,
-        });
+            platform: deps.platform,
+        };
+        const result = args.machineToken === undefined
+            ? await runComputerSetupOrchestration({ args, serverUrl }, orchestrationDeps)
+            : await runMachineTokenSetup({ args, serverUrl }, orchestrationDeps, args.machineToken);
         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`);
+        deps.stderr(`nowwork-computer: ${formatDaemonText(lang, redactSetupSecrets(error.message, secrets))}\n`);
         return 1;
     }
 }

package/dist/computer-token-setup.js

@@ -0,0 +1,46 @@
+import { assertBootstrapMatches, localPathsMatch } from "./computer-setup-orchestration.js";
+import { redactSetupSecrets } from "./computer-setup-client.js";
+export async function runMachineTokenSetup(input, deps, machineToken) {
+    try {
+        deps.reportPairing("Checking computer connection information...");
+        const target = await deps.client.tokenTarget(machineToken);
+        assertBootstrapMatches(target, input);
+        deps.reportPairing("Downloading, installing, and starting the Daemon service...");
+        const installation = await deps.installAutomatically({
+            serverUrl: target.serverUrl, machineToken, workspaceId: target.workspaceId, machineId: target.machineId,
+            requestedProfile: target.profile,
+            ...(target.releaseTag === undefined ? {} : { requestedReleaseTag: target.releaseTag }),
+            ...(target.registryUrl === undefined ? {} : { requestedRegistryUrl: target.registryUrl }),
+            verifyAfterStart: async (candidate) => {
+                deps.reportPairing("Confirming the computer connection...");
+                const deadline = deps.now() + 120_000;
+                for (;;) {
+                    const current = await deps.client.tokenTarget(machineToken);
+                    assertBootstrapMatches(current, input);
+                    const connection = current.connection;
+                    const platform = deps.platform ?? process.platform;
+                    if (connection.status === "online" && connection.epoch > target.minimumConnectionEpoch
+                        && connection.credentialMatchesConnection && current.environment === target.environment
+                        && connection.profile === candidate.profile
+                        && connection.daemonHome !== null && localPathsMatch(connection.daemonHome, candidate.daemonHome, platform)
+                        && connection.agentsRoot !== null && localPathsMatch(connection.agentsRoot, candidate.agentsRoot, platform)
+                        && (target.storageId === undefined || connection.storageId === target.storageId))
+                        return;
+                    if (deps.now() >= deadline)
+                        throw new Error("Timed out confirming the new computer connection");
+                    await deps.sleep(Math.min(2_000, Math.max(0, deadline - deps.now())));
+                }
+            },
+        });
+        return {
+            workspaceId: target.workspaceId, workspaceSlug: target.workspaceSlug, machineId: target.machineId,
+            environment: target.environment, profile: installation.profile, daemonVersion: installation.version,
+            serviceId: installation.serviceId, serviceStatus: "running", helloConfirmed: true,
+            localNowworkHome: installation.localHome, daemonHome: installation.daemonHome, agentsRoot: installation.agentsRoot,
+            ...(target.storageId === undefined ? {} : { storageId: target.storageId }),
+        };
+    }
+    catch (error) {
+        throw new Error(redactSetupSecrets(error instanceof Error ? error.message : String(error), [machineToken]));
+    }
+}

package/dist/i18n.js

@@ -36,6 +36,16 @@ const zh = {
     "Code {{code}}": "验证码 {{code}}",
     "Browser open skipped: {{reason}}": "未能自动打开浏览器：{{reason}}",
     "Starting computer setup pairing...": "正在发起电脑接入授权…",
+    "Token setup does not require browser authorization. CREW_MACHINE_TOKEN is also supported.": "Token 接入无需浏览器授权，也支持 CREW_MACHINE_TOKEN。",
+    "Checking computer connection information...": "正在检查接入信息…",
+    "Downloading, installing, and starting the Daemon service...": "正在下载、安装并启动 Daemon 服务…",
+    "Confirming the computer connection...": "正在确认电脑连接…",
+    "Connected to {{workspace}}.": "已接入 {{workspace}}。",
+    "Setup command expired or unavailable; regenerate it in NowWork and run the new command": "接入命令已过期或不可用，请在 NowWork 重新生成并执行新命令。",
+    "Timed out confirming the new computer connection": "确认新连接超时，请检查网络和服务状态。",
+    "Invalid setup Token": "接入 Token 无效。",
+    "Choose one setup credential source": "请只使用一种接入凭据。",
+    "Choose one setup credential source; clear CREW_MACHINE_TOKEN when using another Token": "请只使用一种接入凭据；使用其他 Token 时请清除 CREW_MACHINE_TOKEN。",
     "Workspace: {{value}}": "工作区：{{value}}",
     "Machine:   {{value}}": "机器：   {{value}}",
     "Environment: {{value}}": "环境：{{value}}",

package/dist/provider-env.js

@@ -11,6 +11,7 @@
 import { join } from "node:path";
 import { DEEPSEEK_CODEX_KEY_ENV, deepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
 import { mergeRuntimeEnvironments } from "./runtime-environment-merge.js";
+import { CODEX_EXECUTION_POLICY_VERSION } from "./runtimes/codex-execution-policy.js";
 const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const RESERVED_ENV = new Set([
     "PATH",
@@ -125,11 +126,15 @@ export function applyDeepSeekHarnessMachineEnv(base, machineEnv, platform = proc
 }
 /**
  * provider 关键配置指纹:Claude Custom 路由和 Codex DeepSeek key 有无都会改变会话边界,
- * 供 pickResumeId 判定冷启动。default 恒为 null;不含 key 明文(同 Provider 换 key 可续)。
+ * 供 pickResumeId 判定冷启动。Codex 还包含执行策略版本,避免续用带宿主记忆的旧会话。
+ * 不含 key 明文(同 Provider 换 key 可续);其他 runtime 的 default 仍为 null。
  */
 export function providerFingerprint(runtime, cfg) {
-    if (runtime === "codex" && cfg.provider === "deepseek") {
-        return `deepseek|${cfg.providerBaseUrl ?? "default"}|${cfg.providerApiKey ? "key" : "nokey"}`;
+    if (runtime === "codex") {
+        const provider = cfg.provider === "deepseek"
+            ? `deepseek|${cfg.providerBaseUrl ?? "default"}|${cfg.providerApiKey ? "key" : "nokey"}`
+            : "default";
+        return `${CODEX_EXECUTION_POLICY_VERSION}|${provider}`;
     }
     if (runtime !== "claude" || cfg.provider !== "custom")
         return null;

package/dist/runtimes/codex-app-server-runner.js

@@ -10,6 +10,7 @@ import { assertCodexCollaborationVersion, assertCodexNativeWorkspaceVersion, ass
 import { decideTurnRetry, itemMakesTurnUnsafe } from "./codex-turn-retry.js";
 import { startFirstProgressWatchdog } from "./progress-watchdog.js";
 import { prepareThreadDelivery, ThreadDeliveryColdStartRequired } from "../thread-input-delivery.js";
+import { codexExecutionPolicyArgs } from "./codex-execution-policy.js";
 const RunnerInputSchema = z.object({
     systemPrompt: z.string().min(1),
     wakePrompt: z.string().min(1),
@@ -57,6 +58,7 @@ export function codexAppServerArgs(input) {
         // multi_agent 按开关;multi_agent_v2 无条件关,钉死已验证的 v1 契约(spec 2b)。
         "-c", `features.multi_agent=${input.collaborationTools === true}`,
         "-c", "features.multi_agent_v2=false",
+        ...codexExecutionPolicyArgs(),
         "app-server", "--listen", "stdio://",
     ];
 }

package/dist/runtimes/codex-execution-policy.js

@@ -0,0 +1,12 @@
+/** Bump when old native transcripts must not cross a changed execution boundary. */
+export const CODEX_EXECUTION_POLICY_VERSION = "nowwork-codex-context-v1";
+/** Process-local overrides: keep host auth/Skills without importing host automatic memory. */
+export function codexExecutionPolicyArgs() {
+    return [
+        "features.memories=false",
+        'shell_environment_policy.inherit="all"',
+        "shell_environment_policy.ignore_default_excludes=true",
+        "shell_environment_policy.exclude=[]",
+        "shell_environment_policy.include_only=[]",
+    ].flatMap(value => ["-c", value]);
+}

package/dist/runtimes/codex.js

@@ -3,6 +3,7 @@
  */
 // cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
 import spawn from "cross-spawn";
+import { codexExecutionPolicyArgs } from "./codex-execution-policy.js";
 /** Minimum CLI whose real app-server contract supports NowCrew native project workspaces. */
 export const CODEX_NATIVE_WORKSPACE_MIN_VERSION = "0.148.0";
 /** Minimum CLI whose `multi_agent` collaboration tool contract was empirically verified (2026-08-28). */
@@ -26,6 +27,7 @@ export function buildCodexArgs(input) {
     args.push("-c", `model_reasoning_effort=${effort}`);
     // 纵深防御:exec 启动器没有 initialize 握手、无法断言版本,协作工具恒关(spec 2b)。
     args.push("-c", "features.multi_agent=false", "-c", "features.multi_agent_v2=false");
+    args.push(...codexExecutionPolicyArgs());
     if (input.projectRootMarkers) {
         args.push("-c", `project_root_markers=${JSON.stringify(input.projectRootMarkers)}`);
     }

package/package.json

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