@nowcrew/daemon 0.6.77-beta.1 → 0.6.77-beta.10

package/README.md

@@ -479,6 +479,33 @@ failure matrix, rollout limits, and the server-native follow-up design.
 
 ## Code Map
 
+## Local daemon installation root (experimental)
+
+New installations use `~/.nowwork` for machine-local daemon configuration and npm runtimes. The
+Workspace persistence root is still selected independently by `NOWWORK_HOME`; it may be a local
+directory or an ECS-specific NAS directory. Runtime packages, locks, sockets, PIDs and temporary
+files must remain on the machine running the daemon.
+
+The same local root also owns shared daemon control state:
+`daemon/managed-services/registry.json`, `daemon/managed-services/installation-leases/`,
+`daemon/compute-execution/`, and `logs/sls-spool/`. This keeps service ownership, upgrade leases,
+host-wide execution admission, and offline log delivery on the daemon host rather than on NAS.
+
+The selector is controlled by `NOWWORK_LOCAL_HOME_MODE`:
+
+- `auto` (default): use an existing `.nowwork` installation, otherwise preserve an existing `.crew`
+  installation; a brand-new profile is created under `.nowwork`.
+- `nowwork`: require the `.nowwork` installation root.
+- `legacy`: force the old `.crew` root for rollback.
+
+`NOWWORK_STORAGE_MODE` is accepted as a compatibility alias. `NOWWORK_LOCAL_HOME` can override the
+local root and should point to a local filesystem, never to the NAS Workspace root; the mount/device
+check remains a doctor/migration gate. If the same profile
+is found in both roots, startup/install is refused until the duplicate is resolved explicitly. The
+old `.crew` tree is not deleted by this compatibility layer.
+For shared machine control state, `auto` prefers an existing `~/.nowwork` root; during a mixed
+migration window, set `NOWWORK_LOCAL_HOME_MODE=legacy` on services that still use the old registry.
+
 - `src/serve.ts`: connection, negotiation, routing, sync, and legacy boundary.
 - `src/daemon-update-eligibility.ts`, `src/daemon-updater.ts`, and `src/daemon-update-controller.ts`:
   managed-update eligibility, exact npm replacement, host-wide admission barrier, and restart handoff.

package/dist/agent-ability/resolver.js

@@ -185,7 +185,7 @@ const materializeGit = async (cacheRoot, repositoryUrl, commit, target) => {
     await git(["--git-dir", bare, "fetch", "--no-tags", "--prune", "origin", commit]);
     const temp = `${target}.tmp-${randomUUID()}`;
     await rm(temp, { recursive: true, force: true });
-    await git(["clone", "--no-checkout", "--shared", bare, temp]);
+    await git(["clone", "--shared", bare, temp]);
     await git(["checkout", "--detach", commit], temp);
     await rm(join(temp, ".git"), { recursive: true, force: true });
     await mkdir(dirname(target), { recursive: true });

package/dist/attachment-limits.js

@@ -0,0 +1,4 @@
+export const ATTACHMENT_MAX_FILE_BYTES = 300 * 1024 * 1024;
+export const ATTACHMENT_MAX_TOTAL_BYTES = ATTACHMENT_MAX_FILE_BYTES;
+export const ATTACHMENT_DOWNLOAD_TIMEOUT_MS = 10 * 60_000;
+export const ATTACHMENT_NATIVE_IMAGE_MAX_BYTES = 25 * 1024 * 1024;

package/dist/attachments.js

@@ -1,7 +1,6 @@
-import { mkdir, rm, writeFile } from "node:fs/promises";
+import { mkdir, open, rm } from "node:fs/promises";
 import { basename, extname, resolve, sep } from "node:path";
-export const ATTACHMENT_MAX_FILE_BYTES = 25 * 1024 * 1024;
-export const ATTACHMENT_MAX_TOTAL_BYTES = 50 * 1024 * 1024;
+import { ATTACHMENT_DOWNLOAD_TIMEOUT_MS, ATTACHMENT_MAX_FILE_BYTES, ATTACHMENT_MAX_TOTAL_BYTES, } from "./attachment-limits.js";
 const throwIfAborted = (signal) => {
     if (signal?.aborted)
         throw signal.reason ?? new Error("Attachment materialization aborted");
@@ -46,7 +45,7 @@ function checkedRedirect(value, base) {
     }
     return url;
 }
-async function readBounded(response, maxBytes) {
+async function writeBounded(response, path, maxBytes, signal) {
     const declared = Number(response.headers.get("content-length") ?? "");
     if (Number.isFinite(declared) && declared > maxBytes) {
         throw new Error(`Attachment exceeds the ${maxBytes} byte limit`);
@@ -54,21 +53,33 @@ async function readBounded(response, maxBytes) {
     if (!response.body)
         throw new Error("Attachment response body is empty");
     const reader = response.body.getReader();
-    const chunks = [];
     let size = 0;
-    while (true) {
-        const part = await reader.read();
-        if (part.done)
-            break;
-        const chunk = Buffer.from(part.value);
-        size += chunk.length;
-        if (size > maxBytes) {
-            await reader.cancel();
-            throw new Error(`Attachment exceeds the ${maxBytes} byte limit`);
+    try {
+        const file = await open(path, "wx", 0o600);
+        try {
+            while (true) {
+                throwIfAborted(signal);
+                const part = await reader.read();
+                if (part.done)
+                    break;
+                const chunk = Buffer.from(part.value);
+                size += chunk.length;
+                if (size > maxBytes) {
+                    throw new Error(`Attachment exceeds the ${maxBytes} byte limit`);
+                }
+                await file.writeFile(chunk);
+            }
+            throwIfAborted(signal);
+            return size;
+        }
+        finally {
+            await file.close();
         }
-        chunks.push(chunk);
     }
-    return Buffer.concat(chunks, size);
+    catch (error) {
+        await reader.cancel().catch(() => { });
+        throw error;
+    }
 }
 async function downloadAttachment(input) {
     const initial = new URL(`/agent/attachments/${encodeURIComponent(input.attachment.id)}/download`, input.serverUrl);
@@ -104,12 +115,11 @@ async function downloadAttachment(input) {
         }
         if (!response.ok)
             throw new Error(`Attachment download failed with status ${response.status}`);
-        const data = await readBounded(response, input.maxFileBytes);
+        const size = await writeBounded(response, input.path, input.maxFileBytes, input.signal);
         throwIfAborted(input.signal);
-        if (data.length !== input.attachment.sizeBytes) {
-            throw new Error(`Attachment size mismatch: expected ${input.attachment.sizeBytes}, received ${data.length}`);
+        if (size !== input.attachment.sizeBytes) {
+            throw new Error(`Attachment size mismatch: expected ${input.attachment.sizeBytes}, received ${size}`);
         }
-        return data;
     }
     catch (error) {
         if (input.signal?.aborted) {
@@ -161,22 +171,18 @@ export async function materializeAttachments(input) {
             }
             used.add(filename.toLowerCase());
             const path = containedPath(directory, filename);
-            const data = await downloadAttachment({
+            await downloadAttachment({
                 serverUrl: input.serverUrl,
                 token: input.token,
                 attachment,
                 fetchImpl: input.fetchImpl ?? fetch,
                 maxFileBytes,
                 maxRedirects: input.maxRedirects ?? 3,
-                timeoutMs: input.timeoutMs ?? 10_000,
+                timeoutMs: input.timeoutMs ?? ATTACHMENT_DOWNLOAD_TIMEOUT_MS,
+                path,
                 ...(input.signal === undefined ? {} : { signal: input.signal }),
             });
             throwIfAborted(input.signal);
-            await writeFile(path, data, {
-                flag: "wx",
-                mode: 0o600,
-                ...(input.signal === undefined ? {} : { signal: input.signal }),
-            });
             materialized.push({ ...attachment, filename, path });
         }
         return { directory, attachments: materialized };

package/dist/automatic-daemon-installer.js

@@ -10,8 +10,10 @@ import { acquireDaemonInstallationLease, } from "./daemon-installation-lease.js"
 import { daemonVersion } from "./machine-info.js";
 import { daemonReleaseProvenance } from "./release-provenance.js";
 import { daemonReleaseChannel, isDaemonReleaseVersion } from "./daemon-release-version.js";
-import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
+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";
 function profileStorage(platform, userHome, runner) {
     return {
         platform,
@@ -30,6 +32,7 @@ function sameHostname(left, right) {
 function defaultDependencies() {
     const platform = process.platform;
     const userHome = homedir();
+    const localHome = resolveDaemonLocalStateRootFromEnv({ userHome, platform, environment: process.env });
     const runner = systemCommandRunner;
     const storage = profileStorage(platform, userHome, runner);
     let managedRecords = [];
@@ -38,6 +41,7 @@ function defaultDependencies() {
         platform,
         userHome,
         uid: process.getuid?.(),
+        environment: process.env,
         nodePath: process.execPath,
         version: daemonVersion(),
         ...(process.env.PATH ? { runtimePath: process.env.PATH } : {}),
@@ -57,7 +61,7 @@ function defaultDependencies() {
         },
         captureService: async (spec, target) => {
             if (platform !== "win32") {
-                managedRecords = await readManagedServiceRegistry({ userHome });
+                managedRecords = await readManagedServiceRegistry({ userHome, localHome });
                 const entryPath = spec.daemonCommand[1];
                 const installation = daemonGlobalInstallation(entryPath, platform);
                 if (installation === null) {
@@ -91,7 +95,7 @@ function defaultDependencies() {
             managedServices: managedRecords,
         }),
         stopService: (spec) => serviceAction(spec, "stop", runner),
-        acquireInstallationLease: (npmPrefix) => acquireDaemonInstallationLease(npmPrefix, { userHome }),
+        acquireInstallationLease: (npmPrefix) => acquireDaemonInstallationLease(npmPrefix, { userHome, localHome }),
         installPackage: installExactDaemonPackage,
         saveTargetProfile: async (profile, daemonHome) => {
             await saveProfile(profile, daemonHome, storage);
@@ -118,7 +122,7 @@ function defaultDependencies() {
                 spec,
                 record,
                 runner,
-                registry: { userHome },
+                registry: { userHome, localHome },
             });
         },
         removeLegacyService: async (legacy) => {
@@ -145,13 +149,13 @@ function defaultDependencies() {
                 await restoreExactService(spec, previous, runner);
                 return;
             }
-            const current = (await readManagedServiceRegistry({ userHome })).find((record) => record.serviceId === spec.id);
+            const current = (await readManagedServiceRegistry({ userHome, localHome })).find((record) => record.serviceId === spec.id);
             if (current !== undefined && JSON.stringify(current) !== JSON.stringify(previousManagedRecord)) {
                 await uninstallManagedService({
                     spec,
                     record: current,
                     runner,
-                    registry: { userHome },
+                    registry: { userHome, localHome },
                 });
             }
             if (previousManagedRecord !== undefined) {
@@ -159,7 +163,7 @@ function defaultDependencies() {
                     spec,
                     record: previousManagedRecord,
                     runner,
-                    registry: { userHome },
+                    registry: { userHome, localHome },
                 });
                 if (previous.running)
                     await serviceAction(spec, "start", runner);
@@ -178,24 +182,34 @@ export function stableDaemonEntry(target, platform) {
         ? paths.join(target.npmPrefix, "node_modules", "@nowcrew", "daemon", "dist", "main.js")
         : paths.join(target.npmPrefix, "lib", "node_modules", "@nowcrew", "daemon", "dist", "main.js");
 }
-export async function installExactDaemonPackage(npmPrefix, version, platform, runner, registryUrl) {
-    const command = platform === "win32" ? "npm.cmd" : "npm";
-    const result = await runner(command, [
-        "install",
-        "--global",
-        "--prefix",
-        npmPrefix,
-        "--ignore-scripts",
-        "--no-audit",
-        "--no-fund",
-        ...(registryUrl === undefined ? [] : ["--registry", normalizeDaemonNpmRegistry(registryUrl, {
-                allowLoopbackHttp: daemonReleaseChannel(version) === "beta",
-            })]),
-        `@nowcrew/daemon@${version}`,
-    ]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Daemon package installation failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.exitCode}`}`);
+export async function installExactDaemonPackage(npmPrefix, version, platform, runner, registryUrl, nodePath = process.execPath) {
+    const registries = daemonRegistryCandidates({
+        betaUpdate: daemonReleaseChannel(version) === "beta",
+        ...(registryUrl === undefined ? {} : { registryUrl }),
+    });
+    if (registries === null)
+        throw new Error("Daemon package installation failed: invalid registry");
+    const npm = npmInvocation(platform, nodePath);
+    let lastFailure = "";
+    for (const registry of registries) {
+        const result = await runner(npm.command, [
+            ...npm.argsPrefix,
+            "install",
+            "--global",
+            "--prefix",
+            npmPrefix,
+            "--ignore-scripts",
+            "--no-audit",
+            "--no-fund",
+            "--registry",
+            registry,
+            `@nowcrew/daemon@${version}`,
+        ]);
+        if (result.exitCode === 0)
+            return;
+        lastFailure = result.stderr.trim() || result.stdout.trim() || `exit ${result.exitCode}`;
     }
+    throw new Error(`Daemon package installation failed: ${lastFailure}`);
 }
 export async function waitForServiceRunning(spec, status, options = {}) {
     const timeoutMs = options.timeoutMs ?? 10_000;
@@ -220,6 +234,10 @@ function recoveryError(primary, failures) {
 }
 export async function installDaemonAutomatically(input, dependencies = defaultDependencies()) {
     const machineToken = MachineTokenSchema.parse(input.machineToken);
+    const requestedLocalHome = input.requestedLocalHome ?? dependencies.environment.NOWWORK_LOCAL_HOME;
+    const requestedLocalHomeMode = input.requestedLocalHomeMode
+        ?? dependencies.environment.NOWWORK_LOCAL_HOME_MODE
+        ?? dependencies.environment.NOWWORK_STORAGE_MODE;
     const target = resolveAutomaticInstallTarget({
         serverUrl: input.serverUrl,
         ...(input.requestedProfile === undefined ? {} : { requestedProfile: input.requestedProfile }),
@@ -227,6 +245,8 @@ export async function installDaemonAutomatically(input, dependencies = defaultDe
         ...(input.requestedRegistryUrl === undefined ? {} : { requestedRegistryUrl: input.requestedRegistryUrl }),
         userHome: dependencies.userHome,
         platform: dependencies.platform,
+        ...(requestedLocalHome === undefined ? {} : { requestedLocalHome }),
+        ...(requestedLocalHomeMode === undefined ? {} : { requestedLocalHomeMode }),
     });
     if (!isDaemonReleaseVersion(dependencies.version)) {
         throw new Error(`Invoking daemon package has an invalid release version '${dependencies.version}'`);

package/dist/automatic-install-target.js

@@ -1,6 +1,7 @@
 import { posix, win32 } from "node:path";
 import { profileLayout, validateLocalInstanceName } from "./profile-layout.js";
 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 = {
     "nowwork-in.nowcoder.com": {
@@ -72,13 +73,21 @@ function knownTargetForProfile(environment, requestedProfile, input, parsed) {
     const legacyProfile = environment === "production" ? "in" : environment;
     assertReleaseTagForServerUrl(input.serverUrl, input.requestedReleaseTag);
     if (requestedProfile === undefined || requestedProfile === legacyProfile) {
+        const local = resolveDaemonLocalHome({
+            userHome: input.userHome,
+            platform: input.platform,
+            profile: legacyProfile,
+            ...(input.requestedLocalHome === undefined ? {} : { explicit: input.requestedLocalHome }),
+            ...(input.requestedLocalHomeMode === undefined ? {} : { mode: input.requestedLocalHomeMode }),
+            ...(input.pathExists === undefined ? {} : { exists: input.pathExists }),
+        });
         return Object.freeze({
             kind: "known",
             profile: legacyProfile,
             serverUrl: normalizedServerUrl(parsed),
-            daemonHome: paths.join(input.userHome, ".crew", environment === "production" ? "daemon" : "daemon-dev"),
-            agentsRoot: paths.join(input.userHome, ".crew", environment === "production" ? "agents" : "agents-dev"),
-            npmPrefix: paths.join(input.userHome, ".crew", "daemon-runtimes", legacyProfile),
+            daemonHome: local.daemonHome,
+            agentsRoot: paths.join(local.root, environment === "production" ? "agents" : "agents-dev"),
+            npmPrefix: local.runtimePrefix,
             releaseTag: environment === "dev" ? "beta" : "latest",
         });
     }
@@ -99,15 +108,23 @@ function knownTargetForProfile(environment, requestedProfile, input, parsed) {
         userHome: input.userHome,
         platform: input.platform,
     });
+    const local = resolveDaemonLocalHome({
+        userHome: input.userHome,
+        platform: input.platform,
+        profile: layout.profile,
+        ...(input.requestedLocalHome === undefined ? {} : { explicit: input.requestedLocalHome }),
+        ...(input.requestedLocalHomeMode === undefined ? {} : { mode: input.requestedLocalHomeMode }),
+        ...(input.pathExists === undefined ? {} : { exists: input.pathExists }),
+    });
     return Object.freeze({
         kind: "known",
         environment,
         localInstanceName,
         profile: layout.profile,
         serverUrl: normalizedServerUrl(parsed),
-        daemonHome: layout.daemonHome,
-        agentsRoot: layout.agentsRoot,
-        npmPrefix: layout.npmPrefix,
+        daemonHome: local.daemonHome,
+        agentsRoot: paths.join(local.root, "agents-" + layout.environment + "-" + layout.localInstanceName),
+        npmPrefix: local.runtimePrefix,
         releaseTag: environment === "dev" ? "beta" : "latest",
     });
 }
@@ -127,13 +144,21 @@ export function resolveAutomaticInstallTarget(input) {
         return registryUrl === undefined ? target : Object.freeze({ ...target, registryUrl });
     }
     const profile = requireCustomProfile(hostname, input.requestedProfile);
+    const local = resolveDaemonLocalHome({
+        userHome: input.userHome,
+        platform: input.platform,
+        profile,
+        ...(input.requestedLocalHome === undefined ? {} : { explicit: input.requestedLocalHome }),
+        ...(input.requestedLocalHomeMode === undefined ? {} : { mode: input.requestedLocalHomeMode }),
+        ...(input.pathExists === undefined ? {} : { exists: input.pathExists }),
+    });
     return Object.freeze({
         kind: "custom",
         profile,
         serverUrl: normalizedServerUrl(parsed),
-        daemonHome: paths.join(input.userHome, ".crew", `daemon-${profile}`),
-        agentsRoot: paths.join(input.userHome, ".crew", `agents-${profile}`),
-        npmPrefix: paths.join(input.userHome, ".crew", "daemon-runtimes", profile),
+        daemonHome: local.daemonHome,
+        agentsRoot: paths.join(local.root, `agents-${profile}`),
+        npmPrefix: local.runtimePrefix,
         releaseTag: input.requestedReleaseTag ?? "latest",
         ...(registryUrl === undefined ? {} : { registryUrl }),
     });

package/dist/computer-cli.js

@@ -1,11 +1,12 @@
 import { parseArgs } from "node:util";
 import { homedir } from "node:os";
-import { resolve } from "node:path";
+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 { releaseTagForServerUrl, assertReleaseTagForServerUrl } from "./automatic-install-target.js";
 import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
+import { npmInvocation } from "./npm-command.js";
 import { defaultProcessController } from "./execution-journal.js";
 import { inspectJournalLock } from "./execution-journal-lock.js";
 import { detectDaemonLang, formatDaemonText } from "./i18n.js";
@@ -17,6 +18,7 @@ import { assertManagedServiceIdentity, buildManagedServiceRecord, installManaged
 import { inspectManagedServiceDiagnostics } from "./managed-service-diagnostics.js";
 import { readManagedServiceRegistry } from "./managed-service-registry.js";
 import { installDaemonAutomatically, } from "./automatic-daemon-installer.js";
+import { resolveDaemonLocalHome, resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
 const COMPUTER_COMMANDS = new Set(["profile", "doctor", "install", "uninstall", "start", "stop", "restart", "status", "upgrade"]);
 export function builtDaemonEntry(moduleUrl = import.meta.url) {
     return moduleUrl.endsWith(".js")
@@ -24,7 +26,7 @@ export function builtDaemonEntry(moduleUrl = import.meta.url) {
         : "";
 }
 function defaults() {
-    const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+    const npm = npmInvocation(process.platform, process.execPath);
     return {
         env: process.env,
         platform: process.platform,
@@ -35,7 +37,7 @@ function defaults() {
         runner: systemCommandRunner,
         ...(process.platform === "win32" ? { profileProtector: windowsDpapiProtector } : {}),
         resolveGlobalNodeModules: async () => {
-            const result = await systemCommandRunner(npmCommand, ["root", "--global"]);
+            const result = await systemCommandRunner(npm.command, [...npm.argsPrefix, "root", "--global"]);
             if (result.exitCode !== 0 || !result.stdout.trim()) {
                 throw new Error(`Unable to locate global npm modules: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
             }
@@ -66,6 +68,7 @@ function usage(td) {
         "  crew-daemon install --server-url <url> --api-key <sk_machine_*> [--profile <custom-name>] [--release-tag <latest|beta>] [--registry <https-url>]",
         "  crew-daemon doctor|install|uninstall|start|stop|restart|status --profile <name>",
         "  crew-daemon upgrade [--profile <name>] [--release-tag <latest|beta>] [--registry <https-url>]",
+        "  NOWWORK_LOCAL_HOME_MODE=auto|nowwork|legacy NOWWORK_LOCAL_HOME=~/.nowwork",
         "",
         td("profile save reads the machine token from CREW_MACHINE_TOKEN, or stdin with --token-stdin."),
     ].join("\n") + "\n";
@@ -153,6 +156,7 @@ export async function runComputerCommand(argv, overrides = {}) {
                 ?? deps.env.CREW_MACHINE_TOKEN)?.trim();
             if (!machineToken)
                 throw new Error(td("Missing machine token for automatic installation"));
+            const requestedLocalHomeMode = deps.env.NOWWORK_LOCAL_HOME_MODE ?? deps.env.NOWWORK_STORAGE_MODE;
             const result = await deps.installAutomatically({
                 serverUrl: parsed.values["server-url"],
                 machineToken,
@@ -161,11 +165,34 @@ export async function runComputerCommand(argv, overrides = {}) {
                 ...(configuredRegistryUrl === undefined
                     ? {}
                     : { requestedRegistryUrl: configuredRegistryUrl }),
+                ...(deps.env.NOWWORK_LOCAL_HOME === undefined
+                    ? {}
+                    : { requestedLocalHome: deps.env.NOWWORK_LOCAL_HOME }),
+                ...(requestedLocalHomeMode === undefined ? {} : { requestedLocalHomeMode }),
             });
             deps.stdout(`${td("Installed daemon {{version}} for profile '{{profile}}'; service '{{service}}' is running.", { version: result.version, profile: result.profile, service: result.serviceId })}\n`);
             return 0;
         }
-        const home = daemonHome(deps.env);
+        const resolvedProfile = profileName ?? positionalName;
+        const configuredLocalHomeMode = deps.env.NOWWORK_LOCAL_HOME_MODE ?? deps.env.NOWWORK_STORAGE_MODE;
+        const home = resolvedProfile !== undefined
+            && (deps.env.NOWWORK_LOCAL_HOME !== undefined
+                || deps.env.NOWWORK_LOCAL_HOME_MODE !== undefined
+                || deps.env.NOWWORK_STORAGE_MODE !== undefined)
+            ? resolveDaemonLocalHome({
+                userHome: deps.userHome,
+                platform: deps.platform,
+                profile: resolvedProfile,
+                ...(deps.env.NOWWORK_LOCAL_HOME === undefined ? {} : { explicit: deps.env.NOWWORK_LOCAL_HOME }),
+                ...(configuredLocalHomeMode === undefined ? {} : { mode: configuredLocalHomeMode }),
+            }).daemonHome
+            : daemonHome(deps.env);
+        const localHome = resolveDaemonLocalStateRoot({
+            userHome: deps.userHome,
+            platform: deps.platform,
+            explicit: deps.env.NOWWORK_LOCAL_HOME,
+            mode: configuredLocalHomeMode,
+        });
         const profileStorage = {
             platform: deps.platform,
             userHome: deps.userHome,
@@ -220,7 +247,9 @@ export async function runComputerCommand(argv, overrides = {}) {
                 }),
                 ...(parsed.values["agents-root"]
                     ? { agentsRoot: resolveAgentsRoot(parsed.values["agents-root"], deps.userHome, deps.platform) }
-                    : {}),
+                    : (deps.env.NOWWORK_LOCAL_HOME !== undefined || configuredLocalHomeMode !== undefined)
+                        ? { agentsRoot: resolveAgentsRoot((deps.platform === "win32" ? win32 : posix).join((deps.platform === "win32" ? win32 : posix).dirname(home), `agents-${name}`), deps.userHome, deps.platform) }
+                        : {}),
                 ...(deps.env.PATH ? { runtimePath: deps.env.PATH } : {}),
             };
             await saveProfile(profile, home, profileStorage);
@@ -275,11 +304,11 @@ export async function runComputerCommand(argv, overrides = {}) {
             try {
                 installationLease = installation === null
                     ? null
-                    : await deps.acquireInstallationLease(installation.npmPrefix, { userHome: deps.userHome });
+                    : await deps.acquireInstallationLease(installation.npmPrefix, { userHome: deps.userHome, localHome });
                 await upgradeDaemon(deps.platform, deps.runner, installation?.npmPrefix, releaseTag, configuredRegistryUrl === undefined
                     ? restartProfile?.registryUrl
                         ?? configuredRegistryUrl
-                    : normalizeDaemonNpmRegistry(configuredRegistryUrl, { allowLoopbackHttp: releaseTag === "beta" }));
+                    : normalizeDaemonNpmRegistry(configuredRegistryUrl, { allowLoopbackHttp: releaseTag === "beta" }), deps.nodePath);
             }
             catch (error) {
                 upgradeError = error;
@@ -357,7 +386,7 @@ export async function runComputerCommand(argv, overrides = {}) {
                     spec,
                     record: managedRecord,
                     runner: deps.runner,
-                    registry: { userHome: deps.userHome },
+                    registry: { userHome: deps.userHome, localHome },
                 });
             deps.stdout(`${td("Installed '{{id}}'. Use status to confirm runtime state.", { id: spec.id })}\n`);
             return 0;
@@ -366,7 +395,7 @@ export async function runComputerCommand(argv, overrides = {}) {
             if (managedRecord === null)
                 await uninstallService(spec, deps.runner);
             else {
-                const current = (await readManagedServiceRegistry({ userHome: deps.userHome })).find((record) => record.serviceId === spec.id
+                const current = (await readManagedServiceRegistry({ userHome: deps.userHome, localHome })).find((record) => record.serviceId === spec.id
                     && record.daemonHome === managedRecord.daemonHome
                     && record.profile === name);
                 if (current === undefined) {
@@ -377,7 +406,7 @@ export async function runComputerCommand(argv, overrides = {}) {
                             daemonHome: home,
                             npmPrefix: installation.npmPrefix,
                             runner: deps.runner,
-                            registry: { userHome: deps.userHome },
+                            registry: { userHome: deps.userHome, localHome },
                             acquireInstallationLease: deps.acquireInstallationLease,
                         });
                     }
@@ -397,7 +426,7 @@ export async function runComputerCommand(argv, overrides = {}) {
                             daemonHome: home,
                             npmPrefix: installation.npmPrefix,
                             runner: deps.runner,
-                            registry: { userHome: deps.userHome },
+                            registry: { userHome: deps.userHome, localHome },
                             acquireInstallationLease: deps.acquireInstallationLease,
                         });
                     }
@@ -407,7 +436,7 @@ export async function runComputerCommand(argv, overrides = {}) {
                         spec,
                         record: current,
                         runner: deps.runner,
-                        registry: { userHome: deps.userHome },
+                        registry: { userHome: deps.userHome, localHome },
                     });
                 }
             }
@@ -419,7 +448,7 @@ export async function runComputerCommand(argv, overrides = {}) {
                 await assertManagedServiceIdentity({
                     spec,
                     record: managedRecord,
-                    registry: { userHome: deps.userHome },
+                    registry: { userHome: deps.userHome, localHome },
                 });
             }
             await serviceAction(spec, command, deps.runner);
@@ -450,7 +479,7 @@ export async function runComputerCommand(argv, overrides = {}) {
                 : await inspectManagedServiceDiagnostics({
                     spec,
                     expectedRecord: managedRecord,
-                    registry: { userHome: deps.userHome },
+                    registry: { userHome: deps.userHome, localHome },
                 });
             const checks = [
                 ...serviceChecks,

package/dist/computer-profile.js

@@ -9,6 +9,7 @@ import { acquireProfileSaveLock, } from "./computer-profile-lock.js";
 import { formatDaemonText } from "./i18n.js";
 import { atomicPrivateWrite } from "./atomic-private-write.js";
 import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
+import { resolveDaemonLocalHome } from "./daemon-local-home.js";
 const PROFILE_NAME = /^[a-z0-9][a-z0-9_-]{0,47}$/;
 export const MachineTokenSchema = z.string().startsWith("sk_machine_").max(4096);
 const ServerUrlSchema = z.string().url().max(2048).refine((value) => {
@@ -94,8 +95,20 @@ export class ProfileAgentsRootConflictError extends Error {
 }
 const quotePosixArgument = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
 const quotePowerShellArgument = (value) => `'${value.replaceAll("'", "''")}'`;
-export function daemonHome(env = process.env) {
-    return resolve(env.CREW_DAEMON_HOME ?? resolve(homedir(), ".crew/daemon"));
+export function daemonHome(env = process.env, profile) {
+    if (env.CREW_DAEMON_HOME !== undefined)
+        return resolve(env.CREW_DAEMON_HOME);
+    const mode = env.NOWWORK_LOCAL_HOME_MODE ?? env.NOWWORK_STORAGE_MODE;
+    if (profile !== undefined && (env.NOWWORK_LOCAL_HOME !== undefined || mode !== undefined)) {
+        return resolveDaemonLocalHome({
+            userHome: homedir(),
+            platform: process.platform,
+            profile,
+            ...(env.NOWWORK_LOCAL_HOME === undefined ? {} : { explicit: env.NOWWORK_LOCAL_HOME }),
+            ...(mode === undefined ? {} : { mode }),
+        }).daemonHome;
+    }
+    return resolve(homedir(), ".crew/daemon");
 }
 export function resolveAgentsRoot(configured, userHome = homedir(), platform = process.platform) {
     const pathApi = platform === "win32" ? win32 : posix;

package/dist/computer-service.js

@@ -5,6 +5,8 @@ import { createHash, randomUUID } from "node:crypto";
 import { promisify } from "node:util";
 import { dirname, resolve } from "node:path";
 import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
+import { daemonRegistryCandidates } from "./daemon-registry.js";
+import { npmInvocation } from "./npm-command.js";
 const execFileAsync = promisify(execFile);
 const WINDOWS_STOP_TIMEOUT_MS = 5_000;
 const WINDOWS_STOP_POLL_MS = 100;
@@ -542,10 +544,12 @@ export async function doctorService(spec, profilePrivate, runner = systemCommand
         { name: "service-running", ok: status.running === true, detail: status.running ? "running" : "not running" },
     ];
 }
-export function buildUpgradeCommand(platform, npmPrefix, releaseTag = "latest", registryUrl) {
+export function buildUpgradeCommand(platform, npmPrefix, releaseTag = "latest", registryUrl, nodePath = process.execPath) {
+    const npm = npmInvocation(platform, nodePath);
     return [
-        platform === "win32" ? "npm.cmd" : "npm",
+        npm.command,
         [
+            ...npm.argsPrefix,
             "install",
             "--global",
             "--ignore-scripts",
@@ -557,9 +561,26 @@ export function buildUpgradeCommand(platform, npmPrefix, releaseTag = "latest",
         ],
     ];
 }
-export async function upgradeDaemon(platform, runner = systemCommandRunner, npmPrefix, releaseTag = "latest", registryUrl) {
-    const [command, args] = buildUpgradeCommand(platform, npmPrefix, releaseTag, registryUrl);
-    await checked(runner, command, args, "Daemon upgrade");
+export async function upgradeDaemon(platform, runner = systemCommandRunner, npmPrefix, releaseTag = "latest", registryUrl, nodePath = process.execPath) {
+    const registries = daemonRegistryCandidates({
+        betaUpdate: releaseTag === "beta",
+        ...(registryUrl === undefined ? {} : { registryUrl }),
+        env: process.env,
+    });
+    if (registries === null)
+        throw new Error("Daemon upgrade failed: invalid registry");
+    let lastFailure = "";
+    for (const registry of registries) {
+        const [command, args] = buildUpgradeCommand(platform, npmPrefix, releaseTag, registry, nodePath);
+        try {
+            await checked(runner, command, args, "Daemon upgrade");
+            return;
+        }
+        catch (error) {
+            lastFailure = error instanceof Error ? error.message : String(error);
+        }
+    }
+    throw new Error(lastFailure || "Daemon upgrade failed");
 }
 const WINDOWS_SID_SCRIPT = "[System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value";
 export async function hardenWindowsProfile(path, runner = systemCommandRunner) {