@nowcrew/daemon 0.6.80 → 0.6.82

package/dist/automatic-daemon-installer.js

@@ -29,6 +29,14 @@ function profileStorage(platform, userHome, runner) {
 function sameHostname(left, right) {
     return new URL(left).hostname.toLowerCase() === new URL(right).hostname.toLowerCase();
 }
+function localHomeForTarget(target, platform) {
+    const paths = platform === "win32" ? win32 : posix;
+    return localHomeForNpmPrefix(target.npmPrefix, platform);
+}
+function localHomeForNpmPrefix(npmPrefix, platform) {
+    const paths = platform === "win32" ? win32 : posix;
+    return paths.resolve(npmPrefix, "..", "..");
+}
 function defaultDependencies() {
     const platform = process.platform;
     const userHome = homedir();
@@ -61,7 +69,7 @@ function defaultDependencies() {
         },
         captureService: async (spec, target) => {
             if (platform !== "win32") {
-                managedRecords = await readManagedServiceRegistry({ userHome, localHome });
+                managedRecords = await readManagedServiceRegistry({ userHome, localHome: localHomeForTarget(target, platform) });
                 const entryPath = spec.daemonCommand[1];
                 const installation = daemonGlobalInstallation(entryPath, platform);
                 if (installation === null) {
@@ -95,7 +103,10 @@ function defaultDependencies() {
             managedServices: managedRecords,
         }),
         stopService: (spec) => serviceAction(spec, "stop", runner),
-        acquireInstallationLease: (npmPrefix) => acquireDaemonInstallationLease(npmPrefix, { userHome, localHome }),
+        acquireInstallationLease: (npmPrefix, options) => acquireDaemonInstallationLease(npmPrefix, {
+            userHome,
+            localHome: options?.localHome ?? localHome,
+        }),
         installPackage: installExactDaemonPackage,
         saveTargetProfile: async (profile, daemonHome) => {
             await saveProfile(profile, daemonHome, storage);
@@ -149,13 +160,16 @@ function defaultDependencies() {
                 await restoreExactService(spec, previous, runner);
                 return;
             }
-            const current = (await readManagedServiceRegistry({ userHome, localHome })).find((record) => record.serviceId === spec.id);
+            const restoreLocalHome = previousManagedRecord === undefined
+                ? localHome
+                : localHomeForNpmPrefix(previousManagedRecord.npmPrefix, platform);
+            const current = (await readManagedServiceRegistry({ userHome, localHome: restoreLocalHome })).find((record) => record.serviceId === spec.id);
             if (current !== undefined && JSON.stringify(current) !== JSON.stringify(previousManagedRecord)) {
                 await uninstallManagedService({
                     spec,
                     record: current,
                     runner,
-                    registry: { userHome, localHome },
+                    registry: { userHome, localHome: restoreLocalHome },
                 });
             }
             if (previousManagedRecord !== undefined) {
@@ -163,7 +177,7 @@ function defaultDependencies() {
                     spec,
                     record: previousManagedRecord,
                     runner,
-                    registry: { userHome, localHome },
+                    registry: { userHome, localHome: restoreLocalHome },
                 });
                 if (previous.running)
                     await serviceAction(spec, "start", runner);
@@ -283,7 +297,9 @@ export async function installDaemonAutomatically(input, dependencies = defaultDe
             stopped = true;
             await dependencies.stopService(spec);
         }
-        const lease = await dependencies.acquireInstallationLease(target.npmPrefix);
+        const lease = await dependencies.acquireInstallationLease(target.npmPrefix, {
+            localHome: localHomeForTarget(target, dependencies.platform),
+        });
         let installFailure;
         try {
             await dependencies.installPackage(target.npmPrefix, dependencies.version, dependencies.platform, dependencies.runner, target.registryUrl);

package/dist/computer-cli.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { posix, resolve, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { assertProfileAgentsRootUnique, daemonHome, inspectProfileAgentsRoot, listProfiles, loadProfile, PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, ProfileAgentsRootConflictError, profileIsPrivate, profilePath, publicProfile, removeProfile, resolveAgentsRoot, saveProfile, windowsDpapiProtector, } from "./computer-profile.js";
-import { buildServiceSpec, doctorService, hardenWindowsProfile, installService, readServiceDescriptor, serviceAction, serviceStatus, systemCommandRunner, uninstallService, upgradeDaemon, windowsProfileIsPrivate, } from "./computer-service.js";
+import { buildServiceSpec, doctorService, hardenWindowsProfile, installService, readServiceDescriptor, serviceAction, serviceStatus, systemCommandRunner, uninstallService, upgradeDaemon, windowsProfileIsPrivate, storageServiceEnvironment, } from "./computer-service.js";
 import { releaseTagForServerUrl, assertReleaseTagForServerUrl } from "./automatic-install-target.js";
 import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
 import { npmInvocation } from "./npm-command.js";
@@ -89,17 +89,6 @@ function translatedError(error, td) {
     }
     return td(error.message);
 }
-function storageServiceEnvironment(env) {
-    return {
-        ...(env.NOWWORK_HOME === undefined ? {} : { NOWWORK_HOME: env.NOWWORK_HOME }),
-        ...(env.NOWWORK_ENV_TAG === undefined ? {} : { NOWWORK_ENV_TAG: env.NOWWORK_ENV_TAG }),
-        ...(env.NOWWORK_STORAGE_POLICY_PATH === undefined
-            ? {} : { NOWWORK_STORAGE_POLICY_PATH: env.NOWWORK_STORAGE_POLICY_PATH }),
-        ...(env.NOWWORK_LOCAL_HOME === undefined ? {} : { NOWWORK_LOCAL_HOME: env.NOWWORK_LOCAL_HOME }),
-        ...(env.NOWWORK_LOCAL_HOME_MODE === undefined && env.NOWWORK_STORAGE_MODE === undefined
-            ? {} : { NOWWORK_LOCAL_HOME_MODE: env.NOWWORK_LOCAL_HOME_MODE ?? env.NOWWORK_STORAGE_MODE }),
-    };
-}
 export async function runComputerCommand(argv, overrides = {}) {
     const command = argv[0];
     if (!command || !COMPUTER_COMMANDS.has(command))
@@ -195,6 +184,8 @@ export async function runComputerCommand(argv, overrides = {}) {
             platform: deps.platform,
             explicit: deps.env.NOWWORK_LOCAL_HOME,
             mode: configuredLocalHomeMode,
+            ...(resolvedProfile === undefined ? {} : { profile: resolvedProfile }),
+            ...(home === undefined ? {} : { daemonHome: home }),
         });
         const profileStorage = {
             platform: deps.platform,

package/dist/computer-service.js

@@ -32,6 +32,18 @@ export const systemCommandRunner = async (command, args) => {
         };
     }
 };
+/** Build the non-secret storage environment persisted in managed services. */
+export function storageServiceEnvironment(env) {
+    return {
+        ...(env.NOWWORK_HOME === undefined ? {} : { NOWWORK_HOME: env.NOWWORK_HOME }),
+        ...(env.NOWWORK_ENV_TAG === undefined ? {} : { NOWWORK_ENV_TAG: env.NOWWORK_ENV_TAG }),
+        ...(env.NOWWORK_STORAGE_POLICY_PATH === undefined
+            ? {} : { NOWWORK_STORAGE_POLICY_PATH: env.NOWWORK_STORAGE_POLICY_PATH }),
+        ...(env.NOWWORK_LOCAL_HOME === undefined ? {} : { NOWWORK_LOCAL_HOME: env.NOWWORK_LOCAL_HOME }),
+        ...(env.NOWWORK_LOCAL_HOME_MODE === undefined && env.NOWWORK_STORAGE_MODE === undefined
+            ? {} : { NOWWORK_LOCAL_HOME_MODE: env.NOWWORK_LOCAL_HOME_MODE ?? env.NOWWORK_STORAGE_MODE }),
+    };
+}
 function serviceIdentitySuffix(profileHome, userHome) {
     if (profileHome === undefined || resolve(profileHome) === resolve(userHome, ".crew", "daemon"))
         return "";
@@ -50,6 +62,9 @@ function xml(value) {
 function systemdArg(value) {
     return `"${assertSingleLine(value, "service argument").replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%")}"`;
 }
+function systemdEnvironmentEntry(key, value) {
+    return `Environment=${systemdArg(`${key}=${value}`)}`;
+}
 export function windowsCommandArg(value) {
     const input = assertSingleLine(value, "service argument");
     return `"${input.replace(/(\\*)"/g, "$1$1\\\"").replace(/(\\*)$/g, "$1$1")}"`;
@@ -100,6 +115,14 @@ export function buildServiceSpec(input) {
     }
     if (platform === "linux") {
         const id = `nowcrew-daemon-${profile}${identitySuffix}.service`;
+        const environmentEntries = [
+            ["NOWWORK_HOME", environment.NOWWORK_HOME],
+            ["NOWWORK_ENV_TAG", environment.NOWWORK_ENV_TAG],
+            ["NOWWORK_STORAGE_POLICY_PATH", environment.NOWWORK_STORAGE_POLICY_PATH],
+            ["NOWWORK_LOCAL_HOME", environment.NOWWORK_LOCAL_HOME],
+            ["NOWWORK_LOCAL_HOME_MODE", environment.NOWWORK_LOCAL_HOME_MODE],
+        ].flatMap(([key, value]) => value === undefined ? [] : [systemdEnvironmentEntry(key, value)]);
+        const environmentBlock = environmentEntries.length === 0 ? "" : `${environmentEntries.join("\n")}\n`;
         return {
             platform,
             profile,
@@ -107,7 +130,7 @@ export function buildServiceSpec(input) {
             descriptorPath: resolve(userHome, ".config", "systemd", "user", id),
             daemonCommand,
             managerDomain: null,
-            descriptor: `[Unit]\nDescription=NowCrew daemon (${profile})\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nExecStart=${daemonCommand.map(systemdArg).join(" ")}\nRestart=on-failure\nRestartSec=5\n\n[Install]\nWantedBy=default.target\n`,
+            descriptor: `[Unit]\nDescription=NowCrew daemon (${profile})\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\n${environmentBlock}ExecStart=${daemonCommand.map(systemdArg).join(" ")}\nRestart=on-failure\nRestartSec=5\n\n[Install]\nWantedBy=default.target\n`,
         };
     }
     const id = `NowCrew Daemon (${profile}${identitySuffix})`;

package/dist/daemon-local-home.js

@@ -4,6 +4,13 @@ import { posix, win32 } from "node:path";
 const PROFILE = /^[a-z0-9][a-z0-9_-]{0,47}$/u;
 const CONTROL = /[\0\r\n]/u;
 const pathsFor = (platform) => platform === "win32" ? win32 : posix;
+function samePath(left, right, platform) {
+    const normalizedLeft = pathsFor(platform).resolve(left);
+    const normalizedRight = pathsFor(platform).resolve(right);
+    return platform === "win32"
+        ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+        : normalizedLeft === normalizedRight;
+}
 export function parseDaemonLocalHomeMode(value) {
     if (value === undefined || value.trim() === "")
         return "auto";
@@ -86,6 +93,22 @@ export function resolveDaemonLocalStateRoot(input) {
         return legacyRoot;
     if (input.explicit !== undefined || mode === "nowwork")
         return nowworkRoot;
+    // Managed service descriptors created before local-home was persisted carry
+    // only --daemon-home. Do not treat every --daemon-home as legacy: migrated
+    // services also use that argument, but point it at ~/.nowwork/config.
+    // Prefer the descriptor's exact home when it identifies either layout.
+    if (input.daemonHome !== undefined && input.profile !== undefined) {
+        const nowworkDaemonHome = resolution("nowwork", nowworkRoot, input.profile, input.platform, "auto_nowwork_existing").daemonHome;
+        const legacyDaemonHome = resolution("legacy", legacyRoot, input.profile, input.platform, "auto_legacy_existing").daemonHome;
+        if (samePath(input.daemonHome, nowworkDaemonHome, input.platform))
+            return nowworkRoot;
+        if (samePath(input.daemonHome, legacyDaemonHome, input.platform))
+            return legacyRoot;
+        // An arbitrary explicit daemon home has historically implied the legacy
+        // local state root. Preserve that behavior unless the descriptor declares
+        // a mode explicitly.
+        return legacyRoot;
+    }
     const exists = input.exists ?? existsSync;
     // Once the new root exists, shared state must follow it even while the
     // legacy root is retained as a rollback source.

package/dist/daemon-migration-controller.js

@@ -133,9 +133,9 @@ export function createDaemonMigrationController(input) {
                     requestedProfile: message.targetProfile,
                     userHome,
                     platform,
-                    // This controller migrates the legacy service layout; the new local-home
-                    // standard is handled by the storage migration controller.
-                    requestedLocalHomeMode: "legacy",
+                    // Layout migration creates the canonical service in the new local-home
+                    // root. Source registry and rollback material remain under legacy .crew.
+                    requestedLocalHomeMode: "nowwork",
                 });
                 if (!isAbsolute(message.targetDaemonHome) || !isAbsolute(message.targetAgentsRoot)
                     || resolve(message.targetDaemonHome) !== resolve(target.daemonHome)
@@ -178,6 +178,7 @@ export function createDaemonMigrationController(input) {
                     serverUrl: input.serverUrl,
                     machineToken: input.machineToken,
                     requestedProfile: message.targetProfile,
+                    requestedLocalHomeMode: "nowwork",
                     ...(currentRegistryUrl === undefined ? {} : { requestedRegistryUrl: currentRegistryUrl }),
                 });
                 if (result.profile !== message.targetProfile || result.serviceId.length === 0) {

package/dist/daemon-update-eligibility.js

@@ -4,7 +4,7 @@ import { realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { daemonHome, loadProfile, resolveAgentsRoot } from "./computer-profile.js";
 import { builtDaemonEntry } from "./computer-cli.js";
-import { buildServiceSpec, readServiceDescriptor, serviceStatus, } from "./computer-service.js";
+import { buildServiceSpec, readServiceDescriptor, storageServiceEnvironment, serviceStatus, } from "./computer-service.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { daemonInstallationLeaseHeld } from "./daemon-installation-lease.js";
 import { inspectLegacyServiceInstallation } from "./legacy-service-installation.js";
@@ -21,9 +21,9 @@ export async function managedDaemonCapabilities(eligibility) {
         return [];
     }
 }
-function defaults(profileName) {
+function defaults(profileName, selectedLocalHome) {
     const userHome = homedir();
-    const localHome = resolveDaemonLocalStateRoot({
+    const localHome = selectedLocalHome ?? resolveDaemonLocalStateRoot({
         userHome,
         platform: process.platform,
         explicit: process.env.NOWWORK_LOCAL_HOME,
@@ -31,6 +31,7 @@ function defaults(profileName) {
     });
     return {
         platform: process.platform,
+        localHome,
         profileHome: daemonHome(process.env, profileName),
         userHome,
         uid: process.getuid?.(),
@@ -65,7 +66,7 @@ async function registryCoversUpdateScope(services, descriptorPaths, targetDescri
     return true;
 }
 export async function detectDaemonUpdateEligibility(profileName, overrides = {}) {
-    const deps = { ...defaults(profileName), ...overrides };
+    const deps = { ...defaults(profileName, overrides.localHome), ...overrides };
     if (deps.platform !== "darwin" && deps.platform !== "linux" && deps.platform !== "win32") {
         return { eligible: false, reason: "unsupported_platform" };
     }
@@ -92,6 +93,7 @@ export async function detectDaemonUpdateEligibility(profileName, overrides = {})
         nodePath: deps.nodePath,
         entryPath: deps.entryPath,
         profileHome: deps.profileHome,
+        environment: storageServiceEnvironment(process.env),
     });
     if (deps.platform === "win32") {
         const scope = await deps.inspectWindowsServiceUpdateScope(spec, installation.npmPrefix)
@@ -169,6 +171,7 @@ export async function detectDaemonUpdateEligibility(profileName, overrides = {})
             entryPath: deps.entryPath,
             profileHome: deps.profileHome,
             legacyServiceId: true,
+            environment: storageServiceEnvironment(process.env),
         });
         const legacyDescriptor = await deps.readServiceDescriptor(legacySpec).catch(() => null);
         if (legacyDescriptor !== legacySpec.descriptor) {

package/dist/local-executor.js

@@ -9,7 +9,7 @@ import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepS
 import { materializeDefaultCodexHome } from "./runtimes/codex-home.js";
 import { materializePrivateCodexHome } from "./codex-home-launch.js";
 import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
-import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, sanitizeEnvVars, } from "./provider-env.js";
+import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, } from "./provider-env.js";
 import { augmentedPath } from "./runtime-path.js";
 import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
@@ -33,6 +33,8 @@ import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPr
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
 import { formatRuntimeStartupError } from "./runtime-startup-error.js";
+import { machinePackageManagerEnv, packageManagerEnvFacts } from "./package-manager-env.js";
+import { sanitizeEnvVars } from "./runtime-env.js";
 import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, renderLocalMemoryResultInstructions, } from "./local-memory/runtime.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
@@ -50,15 +52,6 @@ const MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS = 2_000;
 const LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS = 250;
 const CLAUDE_INSTRUCTION_WARNING = "claude_additional_directory_instructions_unverified";
 const CODEX_COLLABORATION_EXEC_WARNING = "codex_collaboration_disabled_on_exec";
-const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const RESERVED_ENV = new Set([
-    "PATH",
-    "XDG_CONFIG_HOME",
-    "XDG_DATA_HOME",
-    "XDG_CACHE_HOME",
-    "GH_CONFIG_DIR",
-    "CLOUDSDK_CONFIG",
-]);
 function withoutClaudeInstructionFlag(env) {
     if (!(CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV in env))
         return env;
@@ -470,6 +463,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const baseEnv = {
             ...inheritedEnv,
             ...sanitizeEnvVars(providerConfig.envVars),
+            ...(input.trainingProjectContext === undefined
+                ? {}
+                : machinePackageManagerEnv(inheritedEnv)),
             ...input.launch.systemEnv,
             PATH: `${workspace.crewDir}${delimiter}${augmentedPath()}`,
             CREW_SERVER_URL: input.launch.serverUrl,
@@ -512,6 +508,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             qa_runtime_root: childEnv.QA_RUNTIME_ROOT ?? null,
             qa_runtime_root_present: childEnv.QA_RUNTIME_ROOT !== undefined,
             inherited_qa_runtime_root_present: inheritedEnv.QA_RUNTIME_ROOT !== undefined,
+            ...packageManagerEnvFacts(childEnv),
             training_root: join(crewHome, "training"),
             project_context_present: input.projectContext !== undefined,
             project_ids: JSON.stringify(input.projectContext === undefined

package/dist/main.js

@@ -31,6 +31,7 @@ import { runStorageWorkerCommand } from "./storage-worker-command.js";
 import { probeStorageMigrationRuntime } from "./storage-runtime-readiness.js";
 import { createStorageTargetConfirmationHandler } from "./storage-target-confirmation.js";
 import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
+import { storageServiceEnvironment } from "./computer-service.js";
 async function main() {
     const workerResult = await runStorageWorkerCommand(process.argv.slice(2));
     if (workerResult !== null) {
@@ -78,9 +79,9 @@ async function main() {
         userHome: homedir(),
         platform: process.platform,
         explicit: process.env.NOWWORK_LOCAL_HOME,
-        mode: process.env.NOWWORK_LOCAL_HOME_MODE
-            ?? process.env.NOWWORK_STORAGE_MODE
-            ?? (values["daemon-home"] === undefined ? undefined : "legacy"),
+        mode: process.env.NOWWORK_LOCAL_HOME_MODE ?? process.env.NOWWORK_STORAGE_MODE,
+        ...(values.profile === undefined ? {} : { profile: values.profile }),
+        ...(values["daemon-home"] === undefined ? {} : { daemonHome: values["daemon-home"] }),
     });
     if (values.profile) {
         const home = daemonHome(process.env, values.profile);
@@ -98,15 +99,7 @@ async function main() {
                 agentsRoot: resolveAgentsRoot(profile.agentsRoot, homedir(), process.platform),
                 nodePath: process.execPath,
                 entryPath: builtDaemonEntry(),
-                environment: {
-                    ...(process.env.NOWWORK_HOME === undefined ? {} : { NOWWORK_HOME: process.env.NOWWORK_HOME }),
-                    ...(process.env.NOWWORK_ENV_TAG === undefined ? {} : { NOWWORK_ENV_TAG: process.env.NOWWORK_ENV_TAG }),
-                    ...(process.env.NOWWORK_STORAGE_POLICY_PATH === undefined
-                        ? {} : { NOWWORK_STORAGE_POLICY_PATH: process.env.NOWWORK_STORAGE_POLICY_PATH }),
-                    ...(process.env.NOWWORK_LOCAL_HOME === undefined ? {} : { NOWWORK_LOCAL_HOME: process.env.NOWWORK_LOCAL_HOME }),
-                    ...(process.env.NOWWORK_LOCAL_HOME_MODE === undefined && process.env.NOWWORK_STORAGE_MODE === undefined
-                        ? {} : { NOWWORK_LOCAL_HOME_MODE: process.env.NOWWORK_LOCAL_HOME_MODE ?? process.env.NOWWORK_STORAGE_MODE }),
-                },
+                environment: storageServiceEnvironment(process.env),
             });
         }
         applyProfileToEnv(profile, process.env);

package/dist/managed-service-lifecycle.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { acquireDaemonInstallationLease } from "./daemon-installation-lease.js";
+import { acquireDaemonInstallationLease, } from "./daemon-installation-lease.js";
 import { installService, ensureServiceEnabled, readServiceDescriptor, serviceAction, replaceInstalledServiceDescriptor, uninstallService, } from "./computer-service.js";
 import { ManagedServiceConflictError, ManagedServiceRegistryError, assertRegistryCoversDescriptors, listManagedServiceDescriptorPaths, managedServiceIdentityMatches, managedServiceConflict, normalizeManagedServiceRecord, serviceDescriptorSha256, withManagedServiceRegistryLock, } from "./managed-service-registry.js";
 function requirePortableManagedSpec(spec) {
@@ -43,7 +43,7 @@ function sameManagedResource(left, right) {
 function descriptorDiffIsStorageEnvironmentOnly(previous, next) {
     if (!next.includes("\n  <key>EnvironmentVariables</key>\n"))
         return false;
-    const strip = (descriptor) => descriptor.replace(/\n  <key>EnvironmentVariables<\/key>\n  <dict>\n(?:    <key>(?:NOWWORK_HOME|NOWWORK_ENV_TAG|NOWWORK_STORAGE_POLICY_PATH)<\/key><string>[^<]*<\/string>\n)+  <\/dict>\n/u, "\n");
+    const strip = (descriptor) => descriptor.replace(/\n  <key>EnvironmentVariables<\/key>\n  <dict>\n(?:    <key>(?:NOWWORK_HOME|NOWWORK_ENV_TAG|NOWWORK_STORAGE_POLICY_PATH|NOWWORK_LOCAL_HOME|NOWWORK_LOCAL_HOME_MODE)<\/key><string>[^<]*<\/string>\n)+  <\/dict>\n/u, "\n");
     return strip(previous) === strip(next);
 }
 function assertRecordDescribesSpec(input) {
@@ -90,6 +90,7 @@ export async function installManagedService(input) {
             }
             const lease = await acquire(input.record.npmPrefix, {
                 ...(input.registry?.userHome === undefined ? {} : { userHome: input.registry.userHome }),
+                ...(input.registry?.localHome === undefined ? {} : { localHome: input.registry.localHome }),
             });
             try {
                 await installService(input.spec, input.runner);
@@ -136,6 +137,7 @@ export async function installManagedService(input) {
         }
         const lease = await acquire(input.record.npmPrefix, {
             ...(input.registry?.userHome === undefined ? {} : { userHome: input.registry.userHome }),
+            ...(input.registry?.localHome === undefined ? {} : { localHome: input.registry.localHome }),
         });
         try {
             const descriptor = await readServiceDescriptor(input.spec);
@@ -170,6 +172,7 @@ export async function uninstallUnregisteredManagedService(input) {
         const acquire = input.acquireInstallationLease ?? acquireDaemonInstallationLease;
         const lease = await acquire(input.npmPrefix, {
             ...(input.registry?.userHome === undefined ? {} : { userHome: input.registry.userHome }),
+            ...(input.registry?.localHome === undefined ? {} : { localHome: input.registry.localHome }),
         });
         try {
             await uninstallService(input.spec, input.runner);
@@ -199,6 +202,7 @@ export async function uninstallManagedService(input) {
         }
         const lease = await acquire(input.record.npmPrefix, {
             ...(input.registry?.userHome === undefined ? {} : { userHome: input.registry.userHome }),
+            ...(input.registry?.localHome === undefined ? {} : { localHome: input.registry.localHome }),
         });
         try {
             if (descriptor !== null)

package/dist/package-manager-env.js

@@ -0,0 +1,75 @@
+import { readFileSync } from "node:fs";
+function nonEmpty(value) {
+    const normalized = value?.trim();
+    return normalized === undefined || normalized === "" ? undefined : normalized;
+}
+function registryUrl(value) {
+    const normalized = nonEmpty(value);
+    if (normalized === undefined)
+        return undefined;
+    try {
+        const protocol = new URL(normalized).protocol;
+        return protocol === "http:" || protocol === "https:" ? normalized : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function configuredPath(env) {
+    const explicit = env.CREW_PACKAGE_MANAGER_USERCONFIG?.trim();
+    if (explicit !== undefined && explicit !== "")
+        return explicit;
+    return undefined;
+}
+function registryFromNpmrc(path) {
+    if (path === undefined)
+        return undefined;
+    try {
+        const line = readFileSync(path, "utf8")
+            .split(/\r?\n/u)
+            .find((entry) => /^\s*registry\s*=/u.test(entry));
+        return registryUrl(line?.replace(/^\s*registry\s*=\s*/u, ""));
+    }
+    catch {
+        return undefined;
+    }
+}
+function npmrcHasAuth(path) {
+    if (path === undefined)
+        return false;
+    try {
+        return /^\s*(?:(?:\/\/[^=\s]+:)?_(?:auth|authToken|password))\s*=/imu.test(readFileSync(path, "utf8"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Keep machine-owned npm credentials available for explicitly authorized
+ * training dependency installs. The daemon must opt in with
+ * CREW_PACKAGE_MANAGER_USERCONFIG; Agent env cannot reach this path.
+ */
+export function machinePackageManagerEnv(env = process.env) {
+    const npmUserConfig = configuredPath(env);
+    const yarnRegistry = npmUserConfig === undefined
+        ? undefined
+        : registryUrl(env.YARN_REGISTRY) ?? registryFromNpmrc(npmUserConfig);
+    const entries = npmUserConfig === undefined
+        ? []
+        : [["NPM_CONFIG_USERCONFIG", npmUserConfig]];
+    const alwaysAuth = npmrcHasAuth(npmUserConfig) ? "true" : undefined;
+    return Object.fromEntries(yarnRegistry === undefined && alwaysAuth === undefined
+        ? entries
+        : [
+            ...entries,
+            ...(yarnRegistry === undefined ? [] : [["YARN_REGISTRY", yarnRegistry]]),
+            ...(alwaysAuth === undefined ? [] : [["NPM_CONFIG_ALWAYS_AUTH", alwaysAuth]]),
+        ]);
+}
+export function packageManagerEnvFacts(env) {
+    return {
+        npm_userconfig_present: Boolean(env.NPM_CONFIG_USERCONFIG?.trim()),
+        yarn_registry_present: Boolean(env.YARN_REGISTRY?.trim()),
+        npm_always_auth_present: Boolean(env.NPM_CONFIG_ALWAYS_AUTH?.trim()),
+    };
+}

package/dist/runner.js

@@ -12,7 +12,7 @@ import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-de
 import { launchSupervisedRuntime } from "./supervised-runtime.js";
 import { awaitWithCancellation, } from "./runtime-cancellation.js";
 export { awaitExit, exitActivity } from "./local-executor.js";
-export { sanitizeEnvVars } from "./provider-env.js";
+export { sanitizeEnvVars } from "./runtime-env.js";
 const ICON = {
     init: "🟢", text: "💬", reading: "📖", sending: "📨", checking: "🔎",
     claiming: "📌", crew: "⚙️", tool: "🛠️", tool_result: "↩️", done: "✅", error: "❌",

package/dist/runtime-env.js

@@ -0,0 +1,21 @@
+const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export const RESERVED_ENV = new Set([
+    "PATH",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "XDG_CACHE_HOME",
+    "GH_CONFIG_DIR",
+    "CLOUDSDK_CONFIG",
+    "NPM_CONFIG_USERCONFIG",
+    "YARN_REGISTRY",
+    "NPM_CONFIG_ALWAYS_AUTH",
+]);
+/** 用户自定义环境只能补充普通变量,不能覆盖 daemon 维护的运行时契约。 */
+export function sanitizeEnvVars(raw) {
+    if (!raw)
+        return {};
+    return Object.fromEntries(Object.entries(raw).filter(([key, value]) => typeof value === "string"
+        && ENV_KEY_RE.test(key)
+        && !key.toUpperCase().startsWith("CREW_")
+        && !RESERVED_ENV.has(key.toUpperCase())));
+}

package/dist/serve.js

@@ -106,7 +106,7 @@ export function serve(config, opts = {}) {
     const cancellations = new Map();
     const legacyRuns = new Map();
     const updateEligibility = opts.update?.eligibility
-        ?? (() => detectDaemonUpdateEligibility(opts.profileName));
+        ?? (() => detectDaemonUpdateEligibility(opts.profileName, { localHome }));
     const updateController = createDaemonUpdateController({
         eligibility: updateEligibility,
         install: opts.update?.install ?? ((input) => installExactDaemonUpdate({

package/dist/storage-config.js

@@ -3,6 +3,7 @@ import { posix, win32 } from "node:path";
 import { z } from "zod";
 import { atomicPrivateWrite } from "./atomic-private-write.js";
 import { resolveEnvTag, resolveNowworkHome, storageLayout, } from "./storage-layout.js";
+import { resolveDaemonLocalStateRootFromEnv } from "./daemon-local-home.js";
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
 const PROFILE = /^[a-z0-9][a-z0-9_-]{0,47}$/u;
 const PORTABLE_ABSOLUTE_PATH = z.string().min(1).max(32768).refine((value) => posix.isAbsolute(value) || win32.isAbsolute(value), "must be an absolute path");
@@ -46,9 +47,34 @@ function absoluteBase(value, fallback, platform, name) {
     }
     return paths.normalize(selected);
 }
+function localHomeRoot(input) {
+    const environment = input.environment;
+    if (environment.NOWWORK_LOCAL_HOME === undefined
+        && environment.NOWWORK_LOCAL_HOME_MODE === undefined
+        && environment.NOWWORK_STORAGE_MODE === undefined) {
+        return null;
+    }
+    return resolveDaemonLocalStateRootFromEnv(input);
+}
+function rootsUnderLocalHome(root, platform) {
+    const paths = pathsFor(platform);
+    const cacheRoot = paths.join(root, "cache");
+    const stateRoot = paths.join(root, "state");
+    return Object.freeze({
+        configRoot: paths.join(root, "config"),
+        runtimeBase: paths.join(root, "runtime"),
+        cacheRoot,
+        stateRoot,
+        backupsRoot: paths.join(stateRoot, "backups"),
+        runtimePackagesRoot: paths.join(cacheRoot, "runtime-packages"),
+    });
+}
 export function resolveLocalStorageRoots(input) {
     const paths = pathsFor(input.platform);
     const userHome = absoluteBase(input.userHome, input.userHome, input.platform, "user home");
+    const configuredLocalHome = localHomeRoot({ ...input, userHome });
+    if (configuredLocalHome !== null)
+        return rootsUnderLocalHome(configuredLocalHome, input.platform);
     if (input.platform === "win32") {
         const local = absoluteBase(input.environment.LOCALAPPDATA, paths.join(userHome, "AppData", "Local"), input.platform, "LOCALAPPDATA");
         const root = paths.join(local, "NowWork");

package/dist/storage-migration-controller.js

@@ -54,7 +54,6 @@ const REQUIRED_BACKUP_ARTIFACTS = Object.freeze([
     "profile.json",
     "service-descriptor",
     "managed-service-registry.json",
-    "installations.json",
 ]);
 export class StorageMigrationFailure extends Error {
     code;

package/dist/storage-runtime-readiness.js

@@ -1,4 +1,5 @@
 import { realpathSync } from "node:fs";
+import { lstat } from "node:fs/promises";
 import { isAbsolute, resolve } from "node:path";
 import { z } from "zod";
 import { buildServiceSpec } from "./computer-service.js";
@@ -10,7 +11,7 @@ import { readStorageMigrationPolicy } from "./storage-migration-policy.js";
 import { createStorageMigrationRuntimeController, } from "./storage-runtime-controller.js";
 import { resolveEnvTag, resolveNowworkHome } from "./storage-layout.js";
 import { readStorageOwnershipClaim } from "./storage-ownership.js";
-import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
+import { parseDaemonLocalHomeMode, resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
 const notReady = (reason) => Object.freeze({ ready: false, reason });
 function canonicalPath(value) {
     const absolute = resolve(value);
@@ -75,15 +76,33 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
         serverUrl: z.string().url().parse(rawInput.serverUrl),
         platform: rawInput.platform,
     };
-    const localHome = resolveDaemonLocalStateRoot({
-        userHome: rawInput.userHome,
-        platform: rawInput.platform,
-        explicit: rawInput.environment.NOWWORK_LOCAL_HOME,
-        mode: rawInput.environment.NOWWORK_LOCAL_HOME_MODE ?? rawInput.environment.NOWWORK_STORAGE_MODE,
-    });
+    let sourceLocalHome;
+    let targetLocalHome;
+    let targetEnvironment;
     let nowworkHome;
     let environment;
+    let local;
     try {
+        sourceLocalHome = resolveDaemonLocalStateRoot({
+            userHome: rawInput.userHome,
+            platform: rawInput.platform,
+            profile: input.profile,
+            daemonHome: input.currentDaemonHome,
+        });
+        const requestedLocalHomeMode = parseDaemonLocalHomeMode(rawInput.environment.NOWWORK_LOCAL_HOME_MODE ?? rawInput.environment.NOWWORK_STORAGE_MODE);
+        if (requestedLocalHomeMode === "legacy")
+            throw new Error("storage migration target must use the canonical local .nowwork root");
+        targetLocalHome = resolveDaemonLocalStateRoot({
+            userHome: rawInput.userHome,
+            platform: rawInput.platform,
+            explicit: rawInput.environment.NOWWORK_LOCAL_HOME ?? resolve(rawInput.userHome, ".nowwork"),
+            mode: "nowwork",
+        });
+        targetEnvironment = {
+            ...input.environment,
+            NOWWORK_LOCAL_HOME: targetLocalHome,
+            NOWWORK_LOCAL_HOME_MODE: "nowwork",
+        };
         const home = resolveNowworkHome({
             environment: configuredNowworkHome,
             userHome: input.userHome,
@@ -97,6 +116,11 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
                 ? {}
                 : { environment: input.environment.NOWWORK_ENV_TAG }),
         }).environment;
+        local = resolveLocalStorageRoots({
+            platform: input.platform,
+            userHome: input.userHome,
+            environment: targetEnvironment,
+        });
     }
     catch {
         return notReady("storage_environment_invalid");
@@ -119,7 +143,7 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
     };
     let sourceRecord;
     try {
-        const records = await dependencies.readManagedServices({ userHome: input.userHome, localHome });
+        const records = await dependencies.readManagedServices({ userHome: input.userHome, localHome: sourceLocalHome });
         const found = findSourceRecord(records, input);
         if (found === null)
             return notReady("source_service_record_missing");
@@ -141,7 +165,7 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
     const assertSourceIdentity = () => dependencies.assertManagedServiceIdentity({
         spec: sourceSpec,
         record: sourceRecord,
-        registry: { userHome: input.userHome, localHome },
+        registry: { userHome: input.userHome, localHome: sourceLocalHome },
     });
     try {
         await assertSourceIdentity();
@@ -173,11 +197,18 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
     }
     if (ownership.environment !== environment)
         return notReady("storage_ownership_claim_invalid");
-    const local = resolveLocalStorageRoots({
-        platform: input.platform,
-        userHome: input.userHome,
-        environment: input.environment,
-    });
+    const targetInstallationsPath = installationsPath(local.configRoot);
+    let targetInstallationsArtifact = null;
+    try {
+        const targetInstallations = await lstat(targetInstallationsPath);
+        if (!targetInstallations.isFile())
+            return notReady("target_installations_invalid");
+        targetInstallationsArtifact = { name: "installations.json", path: targetInstallationsPath };
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            return notReady("target_installations_invalid");
+    }
     const runtime = dependencies.createController({
         profile: input.profile,
         serverUrl: input.serverUrl,
@@ -194,12 +225,15 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
             NOWWORK_HOME: nowworkHome,
             NOWWORK_ENV_TAG: environment,
             NOWWORK_STORAGE_POLICY_PATH: policyPath,
+            ...(targetEnvironment.NOWWORK_LOCAL_HOME === undefined ? {} : { NOWWORK_LOCAL_HOME: targetEnvironment.NOWWORK_LOCAL_HOME }),
+            ...(targetEnvironment.NOWWORK_LOCAL_HOME_MODE === undefined
+                ? {} : { NOWWORK_LOCAL_HOME_MODE: targetEnvironment.NOWWORK_LOCAL_HOME_MODE }),
         },
         backupArtifacts: [
             { name: "profile.json", path: profilePath(input.profile, input.currentDaemonHome) },
             { name: "service-descriptor", path: sourceRecord.descriptorPath },
-            { name: "managed-service-registry.json", path: managedServiceRegistryPath(input.userHome, localHome) },
-            { name: "installations.json", path: installationsPath(local.configRoot) },
+            { name: "managed-service-registry.json", path: managedServiceRegistryPath(input.userHome, sourceLocalHome) },
+            ...(targetInstallationsArtifact === null ? [] : [targetInstallationsArtifact]),
         ],
     }, { assertSourceIdentity });
     return Object.freeze({ ready: true, runtime });

package/dist/storage-worker-executor.js

@@ -12,6 +12,7 @@ import { readStorageWorkerHandoff } from "./storage-worker-handoff.js";
 import { readStorageWorkerOperation } from "./storage-worker-operation.js";
 import { storageIdFingerprint } from "./storage-identity.js";
 import { waitForStorageMigrationAcknowledgement } from "./storage-target-confirmation.js";
+import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
 const defaultServiceDependencies = () => ({
     assertManagedServiceIdentity,
     serviceAction,
@@ -27,7 +28,7 @@ const defaultServiceDependencies = () => ({
     readInstallations,
     writeInstallations,
 });
-function serviceSpec(operation, record, profileHome) {
+function serviceSpec(operation, record, profileHome, layout = "target") {
     return buildServiceSpec({
         platform: operation.service.platform,
         profile: operation.profile,
@@ -36,7 +37,7 @@ function serviceSpec(operation, record, profileHome) {
         nodePath: record.nodePath,
         entryPath: record.entryPath,
         profileHome,
-        ...(operation.service.serviceEnvironment === undefined
+        ...(layout === "source" || operation.service.serviceEnvironment === undefined
             ? {}
             : { environment: operation.service.serviceEnvironment }),
     });
@@ -74,10 +75,27 @@ function canonicalServerUrl(value) {
 }
 export function createStorageWorkerServiceLifecycle(operation, injected = {}) {
     const dependencies = { ...defaultServiceDependencies(), ...injected };
-    const registry = { userHome: operation.service.userHome };
+    const sourceLocalHome = resolveDaemonLocalStateRoot({
+        userHome: operation.service.userHome,
+        platform: operation.service.platform,
+        profile: operation.service.sourceRecord.profile,
+        daemonHome: operation.service.sourceRecord.daemonHome,
+    });
+    const targetLocalHome = resolveDaemonLocalStateRoot({
+        userHome: operation.service.userHome,
+        platform: operation.service.platform,
+        profile: operation.service.targetRecord.profile,
+        daemonHome: operation.service.targetRecord.daemonHome,
+        ...(operation.service.serviceEnvironment?.NOWWORK_LOCAL_HOME === undefined
+            ? {} : { explicit: operation.service.serviceEnvironment.NOWWORK_LOCAL_HOME }),
+        ...(operation.service.serviceEnvironment?.NOWWORK_LOCAL_HOME_MODE === undefined
+            ? {} : { mode: operation.service.serviceEnvironment.NOWWORK_LOCAL_HOME_MODE }),
+    });
+    const sourceRegistry = { userHome: operation.service.userHome, localHome: sourceLocalHome };
+    const targetRegistry = { userHome: operation.service.userHome, localHome: targetLocalHome };
     const sourceRecord = operation.service.sourceRecord;
     const targetRecord = operation.service.targetRecord;
-    const sourceSpec = serviceSpec(operation, sourceRecord, operation.migration.sourceRoots["daemon-home"]);
+    const sourceSpec = serviceSpec(operation, sourceRecord, operation.migration.sourceRoots["daemon-home"], "source");
     const targetSpec = serviceSpec(operation, targetRecord, operation.installation.configRoot);
     assertRecordMatchesSpec(sourceRecord, sourceSpec);
     assertRecordMatchesSpec(targetRecord, targetSpec);
@@ -89,7 +107,7 @@ export function createStorageWorkerServiceLifecycle(operation, injected = {}) {
     const assertSourceIdentity = () => dependencies.assertManagedServiceIdentity({
         spec: sourceSpec,
         record: sourceRecord,
-        registry,
+        registry: sourceRegistry,
     });
     const readTargetInstallations = () => dependencies.readInstallations({
         configRoot: operation.installation.configRoot,
@@ -140,7 +158,7 @@ export function createStorageWorkerServiceLifecycle(operation, injected = {}) {
             spec: sourceSpec,
             record: sourceRecord,
             runner: systemCommandRunner,
-            registry,
+            registry: sourceRegistry,
         });
         const { version: _version, ...profile } = sourceProfile;
         savedTargetProfile = await dependencies.saveProfile({
@@ -154,7 +172,7 @@ export function createStorageWorkerServiceLifecycle(operation, injected = {}) {
             spec: targetSpec,
             record: targetRecord,
             runner: systemCommandRunner,
-            registry,
+            registry: targetRegistry,
         });
         const target = await dependencies.captureExactService(targetSpec, systemCommandRunner);
         if (!target.installed || !target.exact || target.running) {
@@ -169,7 +187,7 @@ export function createStorageWorkerServiceLifecycle(operation, injected = {}) {
         }
     };
     const removeTargetService = async () => {
-        const records = await dependencies.readManagedServices(registry);
+        const records = await dependencies.readManagedServices(targetRegistry);
         const registered = records.find((record) => record.serviceId === targetRecord.serviceId
             || (record.profile === targetRecord.profile && record.daemonHome === targetRecord.daemonHome));
         if (registered !== undefined && !sameRecord(registered, targetRecord)) {
@@ -180,7 +198,7 @@ export function createStorageWorkerServiceLifecycle(operation, injected = {}) {
                 spec: targetSpec,
                 record: targetRecord,
                 runner: systemCommandRunner,
-                registry,
+                registry: targetRegistry,
             });
         }
         else {
@@ -193,7 +211,7 @@ export function createStorageWorkerServiceLifecycle(operation, injected = {}) {
                     daemonHome: targetRecord.daemonHome,
                     npmPrefix: targetRecord.npmPrefix,
                     runner: systemCommandRunner,
-                    registry,
+                    registry: targetRegistry,
                 });
             }
         }
@@ -231,7 +249,7 @@ export function createStorageWorkerServiceLifecycle(operation, injected = {}) {
                 spec: sourceSpec,
                 record: sourceRecord,
                 runner: systemCommandRunner,
-                registry,
+                registry: sourceRegistry,
             });
         }
         const afterInstall = current.installed

package/dist/storage-worker-operation.js

@@ -7,6 +7,7 @@ import { atomicPrivateWrite } from "./atomic-private-write.js";
 import { assertStorageControlMaterialTokenFree } from "./storage-credential-guard.js";
 import { storageLayout } from "./storage-layout.js";
 import { StorageMigrationWarningCodeSchema } from "./storage-migration-policy.js";
+import { parseDaemonLocalHomeMode } from "./daemon-local-home.js";
 const CONTROL = /[\0\r\n]/u;
 const PROFILE = /^[a-z0-9][a-z0-9_-]{0,47}$/u;
 const ENVIRONMENT = /^[a-z0-9][a-z0-9_-]{0,31}$/u;
@@ -95,6 +96,8 @@ const StorageServiceEnvironmentSchema = z.object({
     NOWWORK_HOME: AbsolutePathSchema.optional(),
     NOWWORK_ENV_TAG: z.string().regex(ENVIRONMENT).optional(),
     NOWWORK_STORAGE_POLICY_PATH: AbsolutePathSchema.optional(),
+    NOWWORK_LOCAL_HOME: AbsolutePathSchema.optional(),
+    NOWWORK_LOCAL_HOME_MODE: z.string().min(1).max(32).optional(),
 }).strict();
 const OperationSchema = z.object({
     version: z.literal(1),
@@ -182,6 +185,9 @@ function isInside(root, candidate, platform) {
     return child === "" || (!child.startsWith("..") && !paths.isAbsolute(child));
 }
 function assertSemanticIdentity(operation) {
+    const localHomeMode = operation.service.serviceEnvironment?.NOWWORK_LOCAL_HOME_MODE;
+    if (localHomeMode !== undefined)
+        parseDaemonLocalHomeMode(localHomeMode);
     const identity = [operation.doctorInput, operation.installation.target];
     if (identity.some((value) => value.workspaceId !== operation.workspaceId
         || value.environment !== operation.environment || value.profile !== operation.profile)

package/package.json

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