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

package/dist/agent-environments.js

@@ -0,0 +1,275 @@
+/** Server 决策生效计划；本模块只做受控文件物化与当前执行目录选择。 */
+import { chmod, lstat, mkdir, open, readFile, readdir, realpath, rename, unlink } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { z } from "zod";
+import { acquireProfileSaveLock } from "./computer-profile-lock.js";
+import { AgentEnvironmentPlanSchema } from "./agent-environment-contract.js";
+const STATE_DIRECTORY = ".nowwork-environments";
+const FileHashes = z.record(z.string().regex(/^[a-f0-9]{64}$/u));
+const StateSchema = z.object({
+    revision: z.number().int().nonnegative(), digest: z.string(), files: FileHashes,
+    pending: z.object({ revision: z.number().int().nonnegative(), digest: z.string(), files: FileHashes }).optional(),
+}).strict();
+const digest = (content) => createHash("sha256").update(content).digest("hex");
+const codeOf = (error) => error.code;
+async function safeDirectory(root, path) {
+    let current = root;
+    for (const segment of path.split("/").filter(Boolean)) {
+        if (segment === "." || segment === ".." || segment.includes("\\"))
+            throw new Error("environment_path_invalid");
+        current = join(current, segment);
+        await mkdir(current, { mode: 0o700 }).catch(error => { if (codeOf(error) !== "EEXIST")
+            throw error; });
+        const info = await lstat(current);
+        if (info.isSymbolicLink())
+            throw new Error("environment_path_symlink");
+        if (!info.isDirectory())
+            throw new Error("environment_path_invalid");
+    }
+    return current;
+}
+async function regularFileContent(path) {
+    const info = await lstat(path).catch(error => { if (codeOf(error) === "ENOENT")
+        return null; throw error; });
+    if (!info)
+        return null;
+    if (!info.isFile() || info.isSymbolicLink() || info.nlink > 1)
+        throw new Error("environment_file_unsafe");
+    if (info.size > 8 * 1024 * 1024)
+        throw new Error("environment_file_too_large");
+    return readFile(path, "utf8");
+}
+async function atomicWrite(path, content, beforeCommit) {
+    const temporary = join(dirname(path), `.env-write-${randomUUID()}`);
+    try {
+        const handle = await open(temporary, "wx", 0o600);
+        try {
+            await handle.writeFile(content, "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        // stage 的慢 IO 完成后重验归属；最终校验 + rename 不是针对外部编辑器的系统级 CAS。
+        await beforeCommit?.();
+        await rename(temporary, path);
+        await chmod(path, 0o600);
+    }
+    finally {
+        await unlink(temporary).catch(error => { if (codeOf(error) !== "ENOENT")
+            throw error; });
+    }
+}
+async function requireUnchangedFile(path, expectedHash, relativePath) {
+    const current = await regularFileContent(path);
+    if ((current === null ? null : digest(current)) !== expectedHash)
+        throw new Error(`environment_file_conflict:${relativePath}`);
+}
+const relativeFileValid = (path) => /^(?:(?:training|repos\/[A-Za-z0-9][A-Za-z0-9._-]{0,127})\/)?\.env(?:\.[a-z][a-z0-9_-]{0,47})?$/u.test(path);
+export async function withEnvironmentFilesLock(agentRoot, operation) {
+    await mkdir(agentRoot, { recursive: true, mode: 0o700 });
+    const rootInfo = await lstat(agentRoot);
+    if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink())
+        throw new Error("environment_path_symlink");
+    const stateRoot = await safeDirectory(await realpath(agentRoot), STATE_DIRECTORY);
+    const release = await acquireProfileSaveLock(stateRoot);
+    try {
+        return await operation();
+    }
+    finally {
+        await release();
+    }
+}
+const TRAINING_FILE_MARKER = ".nowwork-environment-files.json";
+const trainingFileName = (name) => /^\.env(?:\.[a-z][a-z0-9_-]{0,47})?$/u.test(name);
+const TrainingFileOwnershipSchema = z.object({ files: FileHashes, pending: FileHashes.optional() }).strict();
+const trainingFileHashes = (files) => Object.fromEntries(Object.entries(files).map(([name, content]) => [name, digest(content)]));
+async function trainingFileOwnership(directory) {
+    const text = await regularFileContent(join(directory, TRAINING_FILE_MARKER));
+    if (text === null)
+        return null;
+    try {
+        const ownership = TrainingFileOwnershipSchema.parse(JSON.parse(text));
+        if (Object.keys({ ...ownership.files, ...ownership.pending }).some(name => !trainingFileName(name)))
+            throw new Error();
+        return ownership;
+    }
+    catch {
+        throw new Error("environment_training_state_invalid");
+    }
+}
+/** 训练包安装前，仅接受由环境管理器创建、没有其他用户文件的占位目录。 */
+export async function isEnvironmentOnlyTrainingDirectory(directory) {
+    const ownership = await trainingFileOwnership(directory);
+    const stateText = ownership === null ? await regularFileContent(join(dirname(directory), STATE_DIRECTORY, "state.json")) : null;
+    const state = stateText === null ? null : StateSchema.parse(JSON.parse(stateText));
+    if (ownership === null && state === null)
+        return false;
+    const names = await readdir(directory);
+    for (const name of names) {
+        if (name === TRAINING_FILE_MARKER && ownership !== null)
+            continue;
+        if (!trainingFileName(name))
+            return false;
+        const content = await regularFileContent(join(directory, name));
+        const hash = content === null ? null : digest(content);
+        const owned = ownership === null
+            ? hash !== null && (hash === state?.files[`training/${name}`] || hash === state?.pending?.files[`training/${name}`])
+            : hash !== null && (hash === ownership.files[name] || hash === ownership.pending?.[name]);
+        if (!owned)
+            return false;
+    }
+    return true;
+}
+/** 保存当前全局状态已确认的文件，并给即将移入 rollback 的目录留下独立归属证明。 */
+export async function captureTrainingEnvironmentFiles(agentRoot) {
+    const stateText = await regularFileContent(join(agentRoot, STATE_DIRECTORY, "state.json"));
+    if (!stateText)
+        return {};
+    const state = StateSchema.parse(JSON.parse(stateText));
+    const directory = join(agentRoot, "training");
+    const info = await lstat(directory).catch(error => { if (codeOf(error) === "ENOENT")
+        return null; throw error; });
+    if (info === null)
+        return {};
+    if (!info.isDirectory() || info.isSymbolicLink())
+        throw new Error("environment_path_symlink");
+    await trainingFileOwnership(directory); // 损坏的归属记录不能被静默覆盖。
+    const result = {};
+    for (const name of await readdir(directory)) {
+        if (!trainingFileName(name))
+            continue;
+        const path = `training/${name}`;
+        const content = await regularFileContent(join(directory, name));
+        if (content === null)
+            continue;
+        if (digest(content) !== state.files[path] && digest(content) !== state.pending?.files[path])
+            throw new Error(`environment_file_conflict:${path}`);
+        result[name] = content;
+    }
+    if ((info.mode & 0o200) === 0)
+        await chmod(directory, info.mode | 0o200);
+    await atomicWrite(join(directory, TRAINING_FILE_MARKER), JSON.stringify({ files: trainingFileHashes(result) }));
+    return result;
+}
+/** 发布前收敛完整文件集合；只移除目录自身归属记录确认的旧文件，支持中途失败后重试。 */
+export async function restoreTrainingEnvironmentFiles(directory, files) {
+    const info = await lstat(directory);
+    if (!info.isDirectory() || info.isSymbolicLink())
+        throw new Error("environment_path_symlink");
+    const ownership = await trainingFileOwnership(directory);
+    const names = [...new Set([
+            ...(await readdir(directory)).filter(trainingFileName),
+            ...Object.keys(ownership?.files ?? {}), ...Object.keys(ownership?.pending ?? {}), ...Object.keys(files),
+        ])].sort();
+    const assertOwned = async (name) => {
+        if (!trainingFileName(name))
+            throw new Error("environment_state_path_invalid");
+        const current = await regularFileContent(join(directory, name));
+        if (current !== null && digest(current) !== ownership?.files[name] && digest(current) !== ownership?.pending?.[name]) {
+            throw new Error(`environment_file_conflict:training/${name}`);
+        }
+        return current;
+    };
+    const currentHashes = {};
+    for (const name of names) {
+        const current = await assertOwned(name);
+        if (current !== null)
+            currentHashes[name] = digest(current);
+    }
+    const nextHashes = trainingFileHashes(files);
+    if ((info.mode & 0o200) === 0)
+        await chmod(directory, info.mode | 0o200);
+    await atomicWrite(join(directory, TRAINING_FILE_MARKER), JSON.stringify({ files: currentHashes, pending: nextHashes }));
+    for (const name of names) {
+        const target = join(directory, name);
+        const current = await regularFileContent(target);
+        if (current !== null && digest(current) !== currentHashes[name])
+            throw new Error(`environment_file_conflict:training/${name}`);
+        const content = files[name];
+        if (content === undefined)
+            await unlink(target).catch(error => { if (codeOf(error) !== "ENOENT")
+                throw error; });
+        else {
+            const expectedHash = current === null ? null : digest(current);
+            await atomicWrite(target, content, () => requireUnchangedFile(target, expectedHash, `training/${name}`));
+        }
+    }
+    await atomicWrite(join(directory, TRAINING_FILE_MARKER), JSON.stringify({ files: nextHashes }));
+}
+export async function applyAgentEnvironmentPlan(agentRoot, input) {
+    const parsed = AgentEnvironmentPlanSchema.safeParse(input);
+    // 不让 Zod 的输入值或上游凭据出现在 RPC / console 错误中。
+    if (!parsed.success)
+        throw new Error("environment_plan_invalid");
+    const plan = parsed.data;
+    await mkdir(agentRoot, { recursive: true, mode: 0o700 });
+    const rootInfo = await lstat(agentRoot);
+    if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink())
+        throw new Error("environment_path_symlink");
+    const root = await realpath(agentRoot);
+    const stateRoot = await safeDirectory(root, STATE_DIRECTORY);
+    const release = await acquireProfileSaveLock(stateRoot);
+    try {
+        const statePath = join(stateRoot, "state.json");
+        const stateText = await regularFileContent(statePath);
+        const previous = stateText === null ? null : StateSchema.parse(JSON.parse(stateText));
+        const hash = digest(JSON.stringify(plan));
+        const latest = previous?.pending ?? previous;
+        if (latest && plan.revision < latest.revision)
+            throw new Error("environment_revision_stale");
+        if (latest && plan.revision === latest.revision && hash !== latest.digest)
+            throw new Error("environment_revision_conflict");
+        const nextContents = Object.fromEntries(plan.scopes.flatMap(scope => scope.files.map(file => [
+            scope.path ? `${scope.path}/${file.name}` : file.name, file.content,
+        ])));
+        const nextHashes = Object.fromEntries(Object.entries(nextContents).map(([path, text]) => [path, digest(text)]));
+        const paths = [...new Set([...Object.keys(previous?.files ?? {}), ...Object.keys(previous?.pending?.files ?? {}), ...Object.keys(nextContents)])].sort();
+        // 所有候选先预检，再开始写入，避免可预见的冲突造成半套配置。
+        const currentHashes = {};
+        for (const path of paths) {
+            if (!relativeFileValid(path))
+                throw new Error("environment_state_path_invalid");
+            await safeDirectory(root, path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "");
+            const current = await regularFileContent(join(root, path));
+            if (current !== null && digest(current) !== previous?.files[path] && digest(current) !== previous?.pending?.files[path]) {
+                throw new Error(`environment_file_conflict:${path}`);
+            }
+            if (current !== null)
+                currentHashes[path] = digest(current);
+        }
+        const pending = { revision: plan.revision, digest: hash, files: nextHashes };
+        await atomicWrite(statePath, JSON.stringify({ revision: previous?.revision ?? 0, digest: previous?.digest ?? "", files: currentHashes, pending }));
+        for (const path of paths) {
+            // 重检目录和文件，确保写入前仍处于托管边界。
+            await safeDirectory(root, path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "");
+            const target = join(root, path);
+            const current = await regularFileContent(target);
+            if (current !== null && digest(current) !== currentHashes[path]) {
+                throw new Error(`environment_file_conflict:${path}`);
+            }
+            const content = nextContents[path];
+            if (content === undefined)
+                await unlink(target).catch(error => { if (codeOf(error) !== "ENOENT")
+                    throw error; });
+            else {
+                const expectedHash = current === null ? null : digest(current);
+                await atomicWrite(target, content, () => requireUnchangedFile(target, expectedHash, path));
+            }
+        }
+        await atomicWrite(statePath, JSON.stringify(pending));
+        return { revision: plan.revision, files: Object.keys(nextContents).sort() };
+    }
+    finally {
+        await release();
+    }
+}
+/** 按工作目录/绑定项目选择唯一分支；绝不把多个兄弟 Repo 的变量混成进程全局值。 */
+export function environmentForExecution(plan, agentRoot, cwd, projectId) {
+    const selected = projectId === undefined ? undefined : plan.scopes.find(scope => scope.id === `repo:${projectId}`);
+    const path = relative(resolve(agentRoot), resolve(cwd)).split(sep).join("/");
+    const nearest = selected ?? [...plan.scopes].sort((a, b) => b.path.length - a.path.length)
+        .find(scope => scope.path !== "" && (path === scope.path || path.startsWith(`${scope.path}/`)));
+    return { ...(nearest ?? plan.scopes.find(scope => scope.path === ""))?.effective };
+}

package/dist/agent-memory/policy.js

@@ -17,7 +17,9 @@ function truncateUtf8(value, maxBytes) {
     return output;
 }
 export function extractIncomingMessage(wakePrompt) {
-    const match = wakePrompt.match(/(?:^|\n)(?:Incoming message|来信):[ \t]*(.*?)(?=\n(?:Start with crew|先用 crew)|$)/su);
+    // Keep legacy wake delimiters while accepting program-delivered-context prompts.
+    // Stop before policy/history blocks; neither is the current user's message.
+    const match = wakePrompt.match(/(?:^|\n)(?:Incoming message|来信):[ \t]*(.*?)(?=\n(?:Start with crew|先用 crew|Work directly from this thread's context|直接依据程序交付的本线程上下文|No thread anchor:|没有线程锚点[，,])|$)/su);
     const content = match?.[1]?.trim();
     return content ? content : null;
 }

package/dist/automatic-daemon-installer.js

@@ -1,5 +1,6 @@
 import { homedir } from "node:os";
 import { posix, win32 } from "node:path";
+import { z } from "zod";
 import { assertProfileAgentsRootUnique, listProfiles, loadProfile, MachineTokenSchema, removeProfile, saveProfile, windowsDpapiProtector, } from "./computer-profile.js";
 import { buildServiceSpec, captureExactService, hardenWindowsProfile, replaceExactService, restoreExactService, serviceAction, serviceStatus, systemCommandRunner, uninstallService, } from "./computer-service.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
@@ -14,6 +15,8 @@ import { daemonRegistryCandidates } from "./daemon-registry.js";
 import { npmInvocation } from "./npm-command.js";
 import { discoverExactLegacyService, } from "./automatic-service-migration.js";
 import { resolveDaemonLocalStateRootFromEnv } from "./daemon-local-home.js";
+import { serverHostIdentity } from "./server-url.js";
+import { computerSetupRecoveryGuidance } from "./computer-setup-client.js";
 function profileStorage(platform, userHome, runner) {
     return {
         platform,
@@ -27,7 +30,7 @@ function profileStorage(platform, userHome, runner) {
     };
 }
 function sameHostname(left, right) {
-    return new URL(left).hostname.toLowerCase() === new URL(right).hostname.toLowerCase();
+    return serverHostIdentity(left) === serverHostIdentity(right);
 }
 function localHomeForTarget(target, platform) {
     const paths = platform === "win32" ? win32 : posix;
@@ -246,8 +249,33 @@ function recoveryError(primary, failures) {
         return original;
     return new Error(`${original.message}; recovery failed: ${failures.map((error) => error.message).join("; ")}`, { cause: original });
 }
+function setupIdentity(input) {
+    if (input.workspaceId === undefined && input.machineId === undefined)
+        return null;
+    if (input.workspaceId === undefined || input.machineId === undefined) {
+        throw new Error("Computer setup requires both Workspace and Machine identity");
+    }
+    return {
+        workspaceId: z.string().uuid().parse(input.workspaceId),
+        machineId: z.string().uuid().parse(input.machineId),
+    };
+}
+function assertExistingProfileIdentity(previous, identity) {
+    if (previous === null || identity === null)
+        return;
+    if (previous.workspaceId === undefined || previous.machineId === undefined) {
+        throw new Error(`Profile '${previous.name}' does not record its Workspace and Machine identity`);
+    }
+    if (previous.workspaceId !== identity.workspaceId) {
+        throw new Error(`Profile '${previous.name}' belongs to a different Workspace identity`);
+    }
+    if (previous.machineId !== identity.machineId) {
+        throw new Error(`Profile '${previous.name}' belongs to a different Machine identity`);
+    }
+}
 export async function installDaemonAutomatically(input, dependencies = defaultDependencies()) {
     const machineToken = MachineTokenSchema.parse(input.machineToken);
+    const identity = setupIdentity(input);
     const requestedLocalHome = input.requestedLocalHome ?? dependencies.environment.NOWWORK_LOCAL_HOME;
     const requestedLocalHomeMode = input.requestedLocalHomeMode
         ?? dependencies.environment.NOWWORK_LOCAL_HOME_MODE
@@ -280,6 +308,7 @@ export async function installDaemonAutomatically(input, dependencies = defaultDe
     });
     const previousProfile = await dependencies.captureProfile(target);
     await dependencies.assertProfileTarget(target, previousProfile);
+    assertExistingProfileIdentity(previousProfile, identity);
     const previousService = await dependencies.captureService(spec, target);
     if (previousService.installed && !previousService.exact) {
         throw new Error(`Installed service '${spec.id}' does not match the requested identity`);
@@ -330,6 +359,7 @@ export async function installDaemonAutomatically(input, dependencies = defaultDe
             name: target.profile,
             serverUrl: target.serverUrl,
             machineToken,
+            ...(identity === null ? {} : identity),
             agentsRoot: target.agentsRoot,
             releaseTag: target.releaseTag,
             ...(target.registryUrl === undefined ? {} : { registryUrl: target.registryUrl }),
@@ -341,14 +371,33 @@ export async function installDaemonAutomatically(input, dependencies = defaultDe
         const status = await dependencies.verifyService(spec);
         if (!status.running)
             throw new Error(`Service '${spec.id}' did not reach running state`);
-        return {
+        const result = {
             profile: target.profile,
             version: dependencies.version,
             serviceId: spec.id,
             running: true,
+            localHome: localHomeForTarget(target, dependencies.platform),
+            daemonHome: target.daemonHome,
+            agentsRoot: target.agentsRoot,
         };
+        await input.verifyAfterStart?.(result);
+        return result;
     }
     catch (error) {
+        try {
+            await input.beforeRollback?.();
+        }
+        catch (rollbackError) {
+            throw new Error(`${error.message}; local recovery blocked: ${rollbackError.message}. `
+                + computerSetupRecoveryGuidance({
+                    serverUrl: target.serverUrl,
+                    workspaceId: input.workspaceId ?? "unknown",
+                    machineId: input.machineId ?? "unknown",
+                    profile: target.profile,
+                    serviceId: spec.id,
+                    daemonHome: target.daemonHome,
+                }), { cause: error });
+        }
         const failures = [];
         if (profileSaved) {
             try {

package/dist/automatic-install-target.js

@@ -4,6 +4,14 @@ import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
 import { resolveDaemonLocalHome } from "./daemon-local-home.js";
 const PROFILE_NAME = /^[a-z0-9][a-z0-9_-]{0,47}$/;
 const KNOWN_TARGETS = {
+    // Canonical production hostname. Keep the internal hostname below as a
+    // compatibility alias so existing profiles and service identities continue
+    // to work when users move between the two URLs.
+    "nowwork.nowcoder.com": {
+        environment: "production",
+        daemonDirectory: "daemon",
+        agentsDirectory: "agents",
+    },
     "nowwork-in.nowcoder.com": {
         environment: "production",
         daemonDirectory: "daemon",

package/dist/computer-main.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { detectDaemonLang, formatDaemonText } from "./i18n.js";
+import { runComputerSetupCommand, setupUsage } from "./computer-setup.js";
+import { redactSetupSecrets } from "./computer-setup-client.js";
+async function main() {
+    const result = await runComputerSetupCommand(process.argv.slice(2));
+    if (result !== null) {
+        process.exitCode = result;
+        return;
+    }
+    const lang = detectDaemonLang();
+    process.stderr.write(`${formatDaemonText(lang, "Usage:")}\n${setupUsage((message, values) => formatDaemonText(lang, message, values))}`);
+    process.exitCode = 2;
+}
+main().catch((error) => {
+    process.stderr.write(`nowwork-computer: ${redactSetupSecrets(error.message)}\n`);
+    process.exitCode = 1;
+});

package/dist/computer-profile.js

@@ -21,11 +21,12 @@ const ProfileFields = z.object({
     name: z.string().regex(PROFILE_NAME),
     serverUrl: ServerUrlSchema,
     machineToken: MachineTokenSchema,
+    workspaceId: z.string().uuid().optional(),
+    machineId: z.string().uuid().optional(),
     agentsRoot: z.string().min(1).optional(),
     runtimePath: z.string().min(1).max(32768).refine((value) => !value.includes("\0") && !value.includes("\n") && !value.includes("\r"), "runtimePath must be a single line").optional(),
     releaseTag: z.enum(["latest", "beta"]).optional(),
     registryUrl: z.string().url().optional(),
-    codexHomeMode: z.enum(["shared", "private"]).optional(),
 }).strict();
 function validateProfileRegistry(value, context) {
     const fields = value;
@@ -60,7 +61,13 @@ const StoredProtectedProfileSchema = ProfileFields.omit({ machineToken: true }).
         ciphertext: z.string().min(1).max(16384),
     }).strict(),
 }).strict().superRefine(validateProfileRegistry);
-const StoredProfileSchema = z.union([StoredPlainProfileSchema, StoredProtectedProfileSchema]);
+// 旧版本可能已保存 shared 字段；读取时丢弃退休设置，其余字段仍严格校验。
+const StoredProfileSchema = z.preprocess((raw) => {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return raw;
+    const { codexHomeMode: _retiredMode, ...fields } = raw;
+    return fields;
+}, z.union([StoredPlainProfileSchema, StoredProtectedProfileSchema]));
 export const PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE = "Profile '{{profile}}' conflicts with profile '{{conflict}}': both resolve to agents root '{{agentsRoot}}'. Save it with a unique root, for example: {{command}}";
 export class ProfileAgentsRootConflictError extends Error {
     profile;
@@ -253,11 +260,12 @@ export async function saveProfile(input, home = daemonHome(), options = {}) {
                 version: 1,
                 name: profile.name,
                 serverUrl: profile.serverUrl,
+                ...(profile.workspaceId === undefined ? {} : { workspaceId: profile.workspaceId }),
+                ...(profile.machineId === undefined ? {} : { machineId: profile.machineId }),
                 ...(profile.agentsRoot ? { agentsRoot: profile.agentsRoot } : {}),
                 ...(profile.runtimePath ? { runtimePath: profile.runtimePath } : {}),
                 ...(profile.releaseTag === undefined ? {} : { releaseTag: profile.releaseTag }),
                 ...(profile.registryUrl === undefined ? {} : { registryUrl: profile.registryUrl }),
-                ...(profile.codexHomeMode === undefined ? {} : { codexHomeMode: profile.codexHomeMode }),
                 machineTokenProtected: { scheme: "dpapi-current-user", ciphertext },
             });
             await atomicPrivateWrite(profilePath(profile.name, home), `${JSON.stringify(stored, null, 2)}\n`, configured.harden);
@@ -298,6 +306,8 @@ export async function loadProfile(name, home = daemonHome(), options = {}) {
                 version: stored.version,
                 name: stored.name,
                 serverUrl: stored.serverUrl,
+                ...(stored.workspaceId === undefined ? {} : { workspaceId: stored.workspaceId }),
+                ...(stored.machineId === undefined ? {} : { machineId: stored.machineId }),
                 ...(stored.agentsRoot ? { agentsRoot: stored.agentsRoot } : {}),
                 ...(stored.runtimePath ? { runtimePath: stored.runtimePath } : {}),
                 ...(stored.releaseTag === undefined ? {} : { releaseTag: stored.releaseTag }),
@@ -384,6 +394,8 @@ export function publicProfile(profile) {
         name: profile.name,
         serverUrl: profile.serverUrl,
         machineTokenConfigured: true,
+        ...(profile.workspaceId === undefined ? {} : { workspaceId: profile.workspaceId }),
+        ...(profile.machineId === undefined ? {} : { machineId: profile.machineId }),
         ...(profile.agentsRoot ? { agentsRoot: profile.agentsRoot } : {}),
     };
 }
@@ -404,5 +416,6 @@ export function applyProfileToEnv(profile, env) {
         env.CREW_NPM_REGISTRY = profile.registryUrl;
     else
         delete env.CREW_NPM_REGISTRY;
-    env.CREW_CODEX_HOME_MODE = profile.codexHomeMode ?? "shared";
+    // 不再向运行时传播退休的模式开关；CODEX_HOME 沿用用户环境。
+    delete env.CREW_CODEX_HOME_MODE;
 }