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

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/cloud-report-upload.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir, hostname, platform } from "node:os";
+import { join } from "node:path";
 const ALIYUN_MARKER = /alibaba|aliyun|alicloud/iu;
 function readMarker(path) {
     try {
@@ -28,7 +29,15 @@ export function detectCloudProvider(env = process.env, platformName = platform()
 }
 export function findOssUploadScript(env = process.env, exists = existsSync) {
     const explicit = env.CREW_OSS_UPLOAD_SCRIPT?.trim();
-    return explicit && exists(explicit) ? explicit : undefined;
+    if (explicit)
+        return exists(explicit) ? explicit : undefined;
+    const home = env.HOME?.trim() || homedir();
+    const candidates = [
+        join(home, ".claude", "skills", "oss-upload", "scripts", "oss_upload.py"),
+        join(home, ".codex", "skills", "oss-upload", "scripts", "oss_upload.py"),
+        join(home, ".agents", "skills", "oss-upload", "scripts", "oss_upload.py"),
+    ];
+    return candidates.find(exists);
 }
 export function cloudReportUploadFacts(env = process.env, platformName = platform(), hostName = hostname(), readMarkerValue, exists) {
     const provider = detectCloudProvider(env, platformName, hostName, readMarkerValue);

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/execution-journal.js

@@ -8,7 +8,7 @@ import { provePosixProcessGroupStopped } from "./execution-posix-stop-proof.js";
 export { JournalLockedError, JournalLockCorruptionError } from "./execution-journal-lock.js";
 const ExecutionIdSchema = z.string().uuid();
 const TimestampSchema = z.string().datetime({ offset: true });
-const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness", "memory_migration", "pi"]);
+const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness", "pi"]);
 const RUNTIME_READY_SUFFIX = ".runtime-ready";
 const RawJournalEntrySchema = z.object({
     executionId: ExecutionIdSchema,
@@ -523,8 +523,6 @@ export function createExecutionJournal(agentsRoot, options = {}) {
         }
     };
     const pruneInternal = async () => {
-        if (options.retainCompleted)
-            return;
         const protectedExecutionIds = new Set(options.protectedExecutionIds?.() ?? []);
         const entries = await readAll();
         const acknowledged = entries

package/dist/execution-protocol.js

@@ -319,7 +319,7 @@ const RawExecutionCompletedSchema = z.object({
     providerErrorCategory: ProviderErrorCategorySchema.optional(),
     providerHttpStatus: ProviderHttpStatusSchema.optional(),
     providerErrorCode: ProviderErrorCodeSchema.optional(),
-    runtime: z.union([RuntimeSchema, z.literal("memory_migration")]),
+    runtime: RuntimeSchema,
     model: z.string().optional(),
     resumed: z.boolean(),
     finalText: z.string().optional(),

package/dist/execution-runner.js

@@ -1,7 +1,6 @@
 import { createHash } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
 import { isLocalMemoryV2Enabled, localMemoryV2Environment, resolveReposRoot } from "./config.js";
-import { detectLocalMemoryStorageVersion } from "./local-memory/storage-format.js";
 import { DaemonToServerExecutionFrameSchema, ExecutionCompletedSchema, ExecutionRejectedSchema, ExecutionStartSchema, } from "./execution-protocol.js";
 import { JournalConflictError } from "./execution-journal.js";
 import { boundExecutionFrame } from "./execution-event-limit.js";
@@ -839,9 +838,8 @@ export async function runExecution(config, input, dependencies) {
         const localMemoryGuardInBase = localMemoryV2Environment(config.serverUrl) === "custom";
         const boundedSystemPrompt = (context) => {
             const enabled = context.workspace.localMemoryV2Enabled ?? localMemoryV2Enabled;
-            const systemPromptWithLocalFacts = withLocalExecutionFacts(`${spec.instructions.systemPrompt}${enabled && localMemoryGuardInBase && detectLocalMemoryStorageVersion(context.workspace.memory) !== 2 ? renderLocalMemoryV2WriteGuard() : ""}`, baseSystemPromptBudget, {
+            const systemPromptWithLocalFacts = withLocalExecutionFacts(`${spec.instructions.systemPrompt}${enabled && localMemoryGuardInBase ? renderLocalMemoryV2WriteGuard() : ""}`, baseSystemPromptBudget, {
                 ...(selfTraining ? { isolateLocalMemory: true } : {}),
-                memoryQuery: spec.instructions.wakePrompt,
                 collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex",
             });
             const base = typeof systemPromptWithLocalFacts === "string"
@@ -881,7 +879,6 @@ export async function runExecution(config, input, dependencies) {
                 serverUrl: config.serverUrl,
                 token: credential.token,
                 agentId: credential.agentId,
-                ...(dependencies.controlIdentity === undefined ? {} : dependencies.controlIdentity),
                 agentsRoot: config.agentsRoot,
                 reposRoot: resolveReposRoot(config.agentsRoot, config.reposRoot),
                 ...(config.qaReportRoot === undefined ? {} : { qaReportRoot: config.qaReportRoot }),

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/local-execution-prompt.js

@@ -2,9 +2,8 @@
  * 本机执行提示词的合成与预算裁剪。
  *
  * server 提示词是权威部分,绝不裁剪;项目工作区提示词是绑定执行的强制部分,放不下就直接失败;
- * 本机事实与旧格式预览可按预算省略；schema2身份和置顶规则必须保留，放不下则拒绝执行。
+ * 只有本机事实(CREW_HOME / work-log / MEMORY 注入)是可选增强,按整段丢弃或按字节截断。
  */
-import { detectLocalMemoryStorageVersion } from "./local-memory/storage-format.js";
 import { buildCollaborationToolsPrompt, buildRuntimeWorkspacePrompt, capMemoryForInject, capWorkLogForInject, } from "./prompt.js";
 const trainingProjectJson = (project) => JSON.stringify({
     repositoryKey: project.repositoryKey,
@@ -58,14 +57,10 @@ export function withLocalExecutionFacts(serverPrompt, maxBytes, options = {}) {
         }
         const remaining = maxBytes - requiredBytes - Math.max(0, reservedPromptBytes);
         const factsBytes = Buffer.byteLength(localFacts, "utf8");
-        if (factsBytes > remaining) {
-            if (!options.isolateLocalMemory && detectLocalMemoryStorageVersion(workspace.memory) === 2) {
-                throw new Error("local_memory_identity_budget_exceeded");
-            }
+        if (factsBytes > remaining)
             return `${serverPrompt}${collaborationPrompt}${mandatoryWorkspacePrompt}`;
-        }
         const memoryHeading = "\n\n## Injected MEMORY.md (bounded local context)\n";
-        const memory = options.isolateLocalMemory ? "" : capMemoryForInject(workspace.memory, undefined, remaining - factsBytes - Buffer.byteLength(memoryHeading, "utf8"), options.memoryQuery);
+        const memory = options.isolateLocalMemory ? "" : capMemoryForInject(workspace.memory, undefined, remaining - factsBytes - Buffer.byteLength(memoryHeading, "utf8"));
         const memorySection = memory === "" ? "" : memoryHeading + memory;
         const workLogSection = workLog === "" ? "" : `\n\n## Injected work-log (bounded local context)\n${workLog}`;
         const workLogBudget = remaining - factsBytes - Buffer.byteLength(memorySection, "utf8");