@nowcrew/daemon 0.6.77-beta.7 → 0.6.77-beta.9

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/automatic-daemon-installer.js

@@ -13,6 +13,7 @@ import { daemonReleaseChannel, isDaemonReleaseVersion } from "./daemon-release-v
 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,
@@ -31,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 = [];
@@ -39,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 } : {}),
@@ -58,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) {
@@ -92,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);
@@ -119,7 +122,7 @@ function defaultDependencies() {
                 spec,
                 record,
                 runner,
-                registry: { userHome },
+                registry: { userHome, localHome },
             });
         },
         removeLegacyService: async (legacy) => {
@@ -146,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) {
@@ -160,7 +163,7 @@ function defaultDependencies() {
                     spec,
                     record: previousManagedRecord,
                     runner,
-                    registry: { userHome },
+                    registry: { userHome, localHome },
                 });
                 if (previous.running)
                     await serviceAction(spec, "start", runner);
@@ -231,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 }),
@@ -238,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,6 +1,6 @@
 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";
@@ -18,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")
@@ -67,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";
@@ -154,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,
@@ -162,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,
@@ -221,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);
@@ -276,7 +304,7 @@ 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
@@ -358,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;
@@ -367,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) {
@@ -378,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,
                         });
                     }
@@ -398,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,
                         });
                     }
@@ -408,7 +436,7 @@ export async function runComputerCommand(argv, overrides = {}) {
                         spec,
                         record: current,
                         runner: deps.runner,
-                        registry: { userHome: deps.userHome },
+                        registry: { userHome: deps.userHome, localHome },
                     });
                 }
             }
@@ -420,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);
@@ -451,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/daemon-installation-lease.js

@@ -3,6 +3,7 @@ import { realpathSync } from "node:fs";
 import { mkdir, open } from "node:fs/promises";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
+import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
 import { defaultProcessController } from "./execution-journal.js";
 import { createJournalLease, createJournalLeaseRegistry, inspectJournalLock, } from "./execution-journal-lock.js";
 const registry = createJournalLeaseRegistry();
@@ -18,9 +19,10 @@ function canonicalPrefix(npmPrefix) {
         return absolute;
     }
 }
-function leaseDirectory(npmPrefix, userHome) {
+function leaseDirectory(npmPrefix, userHome, localHome) {
     const fingerprint = createHash("sha256").update(resolve(npmPrefix)).digest("hex");
-    return resolve(userHome, ".crew", "daemon", "managed-services", "installation-leases", fingerprint);
+    const root = localHome ?? resolveDaemonLocalStateRoot({ userHome, platform: process.platform });
+    return resolve(root, "daemon", "managed-services", "installation-leases", fingerprint);
 }
 async function syncDirectory(path) {
     if (process.platform === "win32")
@@ -35,7 +37,8 @@ async function syncDirectory(path) {
 }
 export async function acquireDaemonInstallationLease(npmPrefix, options = {}) {
     const normalizedPrefix = canonicalPrefix(npmPrefix);
-    const directory = leaseDirectory(normalizedPrefix, options.userHome ?? homedir());
+    const userHome = options.userHome ?? homedir();
+    const directory = leaseDirectory(normalizedPrefix, userHome, options.localHome);
     await mkdir(directory, { recursive: true, mode: 0o700 });
     const lease = createJournalLease({
         directory,
@@ -75,7 +78,7 @@ export function daemonInstallationLeaseHeld(npmPrefix) {
 export async function inspectDaemonInstallationLease(npmPrefix, options = {}) {
     const normalizedPrefix = canonicalPrefix(npmPrefix);
     return inspectJournalLock({
-        directory: leaseDirectory(normalizedPrefix, options.userHome ?? homedir()),
+        directory: leaseDirectory(normalizedPrefix, options.userHome ?? homedir(), options.localHome),
         inspectIdentity: options.inspectIdentity ?? defaultProcessController.inspectIdentity,
     });
 }

package/dist/daemon-local-home.js

@@ -0,0 +1,108 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+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;
+export function parseDaemonLocalHomeMode(value) {
+    if (value === undefined || value.trim() === "")
+        return "auto";
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "auto" || normalized === "nowwork" || normalized === "legacy")
+        return normalized;
+    throw new Error("NOWWORK_LOCAL_HOME_MODE must be auto, nowwork or legacy");
+}
+function absoluteRoot(value, userHome, platform) {
+    const paths = pathsFor(platform);
+    if (value.length === 0 || CONTROL.test(value))
+        throw new Error("NOWWORK_LOCAL_HOME must be a non-empty single-line path");
+    const expanded = value === "~"
+        ? userHome
+        : value.startsWith("~/") || (platform === "win32" && value.startsWith("~\\"))
+            ? paths.join(userHome, value.slice(2))
+            : value;
+    if (!paths.isAbsolute(expanded))
+        throw new Error("NOWWORK_LOCAL_HOME must be absolute or start with '~/'");
+    return paths.normalize(expanded);
+}
+function legacyDaemonDirectory(profile) {
+    if (profile === "in" || profile === "production")
+        return "daemon";
+    if (profile === "dev")
+        return "daemon-dev";
+    if (profile.startsWith("nw-"))
+        return `daemon-${profile.slice(3)}`;
+    return `daemon-${profile}`;
+}
+function resolution(mode, root, profile, platform, source) {
+    const paths = pathsFor(platform);
+    return Object.freeze({
+        mode,
+        root,
+        daemonHome: mode === "nowwork" ? paths.join(root, "config") : paths.join(root, legacyDaemonDirectory(profile)),
+        runtimePrefix: paths.join(root, "daemon-runtimes", profile),
+        source,
+    });
+}
+export function resolveDaemonLocalHome(input) {
+    if (!PROFILE.test(input.profile))
+        throw new Error("daemon profile is invalid");
+    const mode = parseDaemonLocalHomeMode(input.mode);
+    const paths = pathsFor(input.platform);
+    const nowworkRoot = absoluteRoot(input.explicit ?? paths.join(input.userHome, ".nowwork"), input.userHome, input.platform);
+    const legacyRoot = absoluteRoot(paths.join(input.userHome, ".crew"), input.userHome, input.platform);
+    if (input.explicit !== undefined && mode !== "legacy") {
+        return resolution("nowwork", nowworkRoot, input.profile, input.platform, "explicit");
+    }
+    if (mode === "nowwork")
+        return resolution("nowwork", nowworkRoot, input.profile, input.platform, "nowwork_forced");
+    if (mode === "legacy")
+        return resolution("legacy", legacyRoot, input.profile, input.platform, "legacy_forced");
+    const exists = input.exists ?? existsSync;
+    const nowwork = resolution("nowwork", nowworkRoot, input.profile, input.platform, "auto_nowwork_existing");
+    const legacy = resolution("legacy", legacyRoot, input.profile, input.platform, "auto_legacy_existing");
+    const hasNowwork = exists(nowwork.runtimePrefix) || exists(paths.join(nowwork.daemonHome, "profiles", `${input.profile}.json`));
+    const hasLegacy = exists(legacy.runtimePrefix) || exists(paths.join(legacy.daemonHome, "profiles", `${input.profile}.json`));
+    if (hasNowwork && hasLegacy) {
+        throw new Error(`Daemon local home conflict: profile '${input.profile}' exists under both .crew and .nowwork`);
+    }
+    if (hasNowwork)
+        return nowwork;
+    if (hasLegacy)
+        return legacy;
+    return resolution("nowwork", nowworkRoot, input.profile, input.platform, "auto_new");
+}
+/**
+ * Resolve the local machine state root shared by service metadata, leases,
+ * host coordination and offline logs. It intentionally stays separate from
+ * NOWWORK_HOME, which may point at a NAS persistent data root.
+ */
+export function resolveDaemonLocalStateRoot(input) {
+    const paths = pathsFor(input.platform);
+    const mode = parseDaemonLocalHomeMode(input.mode);
+    const nowworkRoot = absoluteRoot(input.explicit ?? paths.join(input.userHome, ".nowwork"), input.userHome, input.platform);
+    const legacyRoot = absoluteRoot(paths.join(input.userHome, ".crew"), input.userHome, input.platform);
+    if (mode === "legacy")
+        return legacyRoot;
+    if (input.explicit !== undefined || mode === "nowwork")
+        return nowworkRoot;
+    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.
+    if (exists(nowworkRoot))
+        return nowworkRoot;
+    if (exists(legacyRoot))
+        return legacyRoot;
+    return nowworkRoot;
+}
+export function resolveDaemonLocalStateRootFromEnv(input = {}) {
+    const environment = input.environment ?? process.env;
+    return resolveDaemonLocalStateRoot({
+        userHome: input.userHome ?? homedir(),
+        platform: input.platform ?? process.platform,
+        ...(environment.NOWWORK_LOCAL_HOME === undefined ? {} : { explicit: environment.NOWWORK_LOCAL_HOME }),
+        ...(environment.NOWWORK_LOCAL_HOME_MODE === undefined && environment.NOWWORK_STORAGE_MODE === undefined
+            ? {}
+            : { mode: environment.NOWWORK_LOCAL_HOME_MODE ?? environment.NOWWORK_STORAGE_MODE }),
+    });
+}

package/dist/daemon-migration-controller.js

@@ -21,6 +21,9 @@ const MigrationMessageSchema = z.object({
 function migrationBackupRoot(input, id) {
     return resolve(input.backupRoot ?? resolve(input.userHome ?? homedir(), ".crew", "migration-backups"), id);
 }
+function legacyLocalHome(input) {
+    return resolve(input.userHome ?? homedir(), ".crew");
+}
 async function assertEmptyOrMissing(path) {
     try {
         const entries = await readdir(path);
@@ -77,10 +80,10 @@ async function backupAndCopy(input, id, targetHome, targetAgents, service) {
 }
 async function cleanupCurrentServiceDefault(spec, input) {
     const userHome = input.userHome ?? homedir();
-    const records = await readManagedServiceRegistry({ userHome });
+    const records = await readManagedServiceRegistry({ userHome, localHome: legacyLocalHome(input) });
     const record = records.find((candidate) => candidate.profile === spec.profile && candidate.daemonHome === input.currentDaemonHome);
     if (record !== undefined && (spec.platform === "darwin" || spec.platform === "linux")) {
-        await uninstallManagedService({ spec, record, runner: systemCommandRunner, registry: { userHome } });
+        await uninstallManagedService({ spec, record, runner: systemCommandRunner, registry: { userHome, localHome: legacyLocalHome(input) } });
         return;
     }
     // Windows and legacy descriptors are handled by the normal CLI/service lifecycle.
@@ -125,7 +128,15 @@ export function createDaemonMigrationController(input) {
                 if (currentProfile.machineToken !== input.machineToken)
                     throw new Error("active profile token does not match this daemon");
                 currentRegistryUrl = currentProfile.registryUrl;
-                const target = resolveAutomaticInstallTarget({ serverUrl: input.serverUrl, requestedProfile: message.targetProfile, userHome, platform });
+                const target = resolveAutomaticInstallTarget({
+                    serverUrl: input.serverUrl,
+                    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",
+                });
                 if (!isAbsolute(message.targetDaemonHome) || !isAbsolute(message.targetAgentsRoot)
                     || resolve(message.targetDaemonHome) !== resolve(target.daemonHome)
                     || resolve(message.targetAgentsRoot) !== resolve(target.agentsRoot))
@@ -140,7 +151,7 @@ export function createDaemonMigrationController(input) {
                     throw new Error("current managed service identity is not exact and running");
                 currentService = { installed: exact.installed, running: exact.running };
                 if (platform === "darwin" || platform === "linux") {
-                    const records = await (input.readManagedRecords ?? (() => readManagedServiceRegistry({ userHome })))();
+                    const records = await (input.readManagedRecords ?? (() => readManagedServiceRegistry({ userHome, localHome: legacyLocalHome(input) })))();
                     managedRecord = records.find((record) => record.serviceId === currentSpec.id && record.profile === input.profileName && record.daemonHome === input.currentDaemonHome) ?? null;
                     if (managedRecord === null)
                         throw new Error("current managed service registry record is missing");

package/dist/daemon-update-eligibility.js

@@ -9,6 +9,7 @@ import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { daemonInstallationLeaseHeld } from "./daemon-installation-lease.js";
 import { inspectLegacyServiceInstallation } from "./legacy-service-installation.js";
 import { inspectWindowsServiceUpdateScope } from "./windows-scheduled-task.js";
+import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
 import { assertRegistryCoversDescriptors, listManagedServiceDescriptorPaths, managedServiceIdentityMatches, readManagedServiceRegistry, serviceDescriptorSha256, } from "./managed-service-registry.js";
 export async function managedDaemonCapabilities(eligibility) {
     try {
@@ -20,24 +21,31 @@ export async function managedDaemonCapabilities(eligibility) {
         return [];
     }
 }
-function defaults() {
+function defaults(profileName) {
+    const userHome = homedir();
+    const localHome = resolveDaemonLocalStateRoot({
+        userHome,
+        platform: process.platform,
+        explicit: process.env.NOWWORK_LOCAL_HOME,
+        mode: process.env.NOWWORK_LOCAL_HOME_MODE ?? process.env.NOWWORK_STORAGE_MODE,
+    });
     return {
         platform: process.platform,
-        profileHome: daemonHome(),
-        userHome: homedir(),
+        profileHome: daemonHome(process.env, profileName),
+        userHome,
         uid: process.getuid?.(),
         nodePath: process.execPath,
         entryPath: builtDaemonEntry(),
         loadProfile,
-        readManagedServices: () => readManagedServiceRegistry(),
-        listManagedDescriptorPaths: () => listManagedServiceDescriptorPaths(process.platform, homedir()),
+        readManagedServices: () => readManagedServiceRegistry({ userHome, localHome }),
+        listManagedDescriptorPaths: () => listManagedServiceDescriptorPaths(process.platform, userHome),
         readServiceDescriptor,
         serviceStatus,
         assertWritable: (path) => access(path, constants.W_OK),
         installationLeaseHeld: daemonInstallationLeaseHeld,
         installationRealpath: realpathSync.native,
         inspectWindowsServiceUpdateScope,
-        inspectLegacyDescriptorInstallation: (descriptorPath) => inspectLegacyServiceInstallation(descriptorPath, process.platform, homedir(), process.getuid?.()),
+        inspectLegacyDescriptorInstallation: (descriptorPath) => inspectLegacyServiceInstallation(descriptorPath, process.platform, userHome, process.getuid?.()),
     };
 }
 async function registryCoversUpdateScope(services, descriptorPaths, targetDescriptorPath, npmPrefix, inspectLegacyDescriptorInstallation) {
@@ -57,7 +65,7 @@ async function registryCoversUpdateScope(services, descriptorPaths, targetDescri
     return true;
 }
 export async function detectDaemonUpdateEligibility(profileName, overrides = {}) {
-    const deps = { ...defaults(), ...overrides };
+    const deps = { ...defaults(profileName), ...overrides };
     if (deps.platform !== "darwin" && deps.platform !== "linux" && deps.platform !== "win32") {
         return { eligible: false, reason: "unsupported_platform" };
     }