@nowcrew/daemon 0.6.77 → 0.6.78

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-registry.js

@@ -0,0 +1,20 @@
+import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
+export const DAEMON_PUBLIC_NPM_REGISTRY = normalizeDaemonNpmRegistry();
+export const DAEMON_PUBLIC_NPM_MIRROR = "https://registry.npmmirror.com";
+/** Keep every daemon package operation on the same ordered, channel-safe sources. */
+export function daemonRegistryCandidates(input) {
+    try {
+        const requested = input.registryUrl ?? input.env?.CREW_NPM_REGISTRY;
+        const configured = requested === undefined
+            ? DAEMON_PUBLIC_NPM_REGISTRY
+            : normalizeDaemonNpmRegistry(requested, { allowLoopbackHttp: input.betaUpdate });
+        return [...new Set([
+                configured,
+                DAEMON_PUBLIC_NPM_REGISTRY,
+                ...(input.betaUpdate ? [DAEMON_PUBLIC_NPM_MIRROR] : []),
+            ])];
+    }
+    catch {
+        return null;
+    }
+}

package/dist/daemon-update-controller.js

@@ -30,6 +30,7 @@ export function createDaemonUpdateController(deps) {
                 targetVersion: message.targetVersion,
                 packageRoot: eligibility.packageRoot,
                 npmPrefix: eligibility.npmPrefix,
+                ...(eligibility.registryUrl === undefined ? {} : { registryUrl: eligibility.registryUrl }),
                 onInstalling: () => {
                     deps.sendStatus({ type: "daemon:update-status", updateId: message.updateId, status: "installing" });
                 },

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" };
     }
@@ -109,6 +117,7 @@ export async function detectDaemonUpdateEligibility(profileName, overrides = {})
             eligible: true,
             profileName,
             ...installation,
+            ...(profile.registryUrl === undefined ? {} : { registryUrl: profile.registryUrl }),
             serviceSpec: { ...spec, runtimeProcessIdentity: scope.processIdentity },
         };
     }
@@ -188,6 +197,7 @@ export async function detectDaemonUpdateEligibility(profileName, overrides = {})
         eligible: true,
         profileName,
         ...installation,
+        ...(profile.registryUrl === undefined ? {} : { registryUrl: profile.registryUrl }),
         serviceSpec: selectedSpec,
     };
 }

package/dist/daemon-updater.js

@@ -1,25 +1,10 @@
 import { readFile } from "node:fs/promises";
-import { posix, resolve, win32 } from "node:path";
+import { resolve } from "node:path";
 import { systemCommandRunner } from "./computer-service.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { daemonReleaseChannel, isDaemonReleaseVersion } from "./daemon-release-version.js";
-import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
-const PUBLIC_NPM_REGISTRY = normalizeDaemonNpmRegistry();
-function configuredRegistries(betaUpdate) {
-    try {
-        const configured = process.env.CREW_NPM_REGISTRY === undefined
-            ? PUBLIC_NPM_REGISTRY
-            : normalizeDaemonNpmRegistry(process.env.CREW_NPM_REGISTRY, { allowLoopbackHttp: betaUpdate });
-        return betaUpdate ? [...new Set([configured, PUBLIC_NPM_REGISTRY])] : [configured];
-    }
-    catch {
-        return null;
-    }
-}
-function npmCommand(platform, nodePath) {
-    const paths = platform === "win32" ? win32 : posix;
-    return paths.join(paths.dirname(nodePath), platform === "win32" ? "npm.cmd" : "npm");
-}
+import { daemonRegistryCandidates } from "./daemon-registry.js";
+import { npmInvocation } from "./npm-command.js";
 function registryArgs(registry) {
     return ["--registry", registry];
 }
@@ -51,10 +36,11 @@ async function readPackageVersion(packageRoot) {
     const body = JSON.parse(await readFile(resolve(packageRoot, "package.json"), "utf8"));
     return typeof body.version === "string" ? body.version : "";
 }
-async function restoreInstalledVersion(input, runner, command, version, registryArgs) {
+async function restoreInstalledVersion(input, runner, command, commandPrefix, version, registryArgs) {
     if (!isDaemonReleaseVersion(version))
         return false;
     const result = await runner(command, [
+        ...commandPrefix,
         "install",
         "--global",
         "--prefix",
@@ -110,7 +96,9 @@ export async function installExactDaemonUpdate(input) {
     }
     const runner = input.runner ?? systemCommandRunner;
     const platform = input.platform ?? process.platform;
-    const command = npmCommand(platform, input.nodePath ?? process.execPath);
+    const npm = npmInvocation(platform, input.nodePath ?? process.execPath);
+    const command = npm.command;
+    const commandPrefix = npm.argsPrefix;
     let previousVersion = "";
     try {
         previousVersion = await (input.readInstalledVersion ?? readPackageVersion)(input.packageRoot);
@@ -124,8 +112,12 @@ export async function installExactDaemonUpdate(input) {
         await release();
         return { ok: false, errorCode: "install_failed" };
     }
-    const registries = configuredRegistries(daemonReleaseChannel(previousVersion) === "beta"
-        || daemonReleaseChannel(input.targetVersion) === "beta");
+    const registries = daemonRegistryCandidates({
+        betaUpdate: daemonReleaseChannel(previousVersion) === "beta"
+            || daemonReleaseChannel(input.targetVersion) === "beta",
+        ...(input.registryUrl === undefined ? {} : { registryUrl: input.registryUrl }),
+        env: process.env,
+    });
     if (registries === null) {
         await release();
         return { ok: false, errorCode: "install_failed" };
@@ -139,10 +131,12 @@ export async function installExactDaemonUpdate(input) {
     }
     let selectedRegistryArgs = [];
     let installed = false;
-    let authFailed = false;
+    let authFailures = 0;
+    let failedAttempts = 0;
     for (const registry of registries) {
         const args = registryArgs(registry);
         const result = await runner(command, [
+            ...commandPrefix,
             "install",
             "--global",
             "--prefix",
@@ -158,12 +152,18 @@ export async function installExactDaemonUpdate(input) {
             installed = true;
             break;
         }
+        failedAttempts += 1;
         if (result !== null && isRegistryAuthFailure(result.stderr))
-            authFailed = true;
+            authFailures += 1;
     }
     if (!installed) {
         await release();
-        return { ok: false, errorCode: authFailed ? "registry_auth_failed" : "install_failed" };
+        return {
+            ok: false,
+            errorCode: failedAttempts > 0 && authFailures === failedAttempts
+                ? "registry_auth_failed"
+                : "install_failed",
+        };
     }
     let installedVersion = "";
     try {
@@ -173,7 +173,7 @@ export async function installExactDaemonUpdate(input) {
         // Version verification is authoritative; unreadable package metadata is a mismatch.
     }
     if (installedVersion !== input.targetVersion) {
-        const restored = await restoreInstalledVersion(input, runner, command, previousVersion, selectedRegistryArgs);
+        const restored = await restoreInstalledVersion(input, runner, command, commandPrefix, previousVersion, selectedRegistryArgs);
         if (!restored) {
             console.error(`[daemon-update] version verification failed; restore of ${previousVersion} was unsuccessful`);
         }

package/dist/execution-runner.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
+import { resolveReposRoot } from "./config.js";
 import { DaemonToServerExecutionFrameSchema, ExecutionCompletedSchema, ExecutionRejectedSchema, ExecutionStartSchema, } from "./execution-protocol.js";
 import { JournalConflictError } from "./execution-journal.js";
 import { boundExecutionFrame } from "./execution-event-limit.js";
@@ -16,8 +17,7 @@ import { HostReservationCancelledError } from "./host-execution-coordinator.js";
 import { supervisorLaunch } from "./supervised-runtime.js";
 import { appendAgentMemoryContext } from "./agent-memory/policy.js";
 import { ProjectSkillRuntimeOwnershipUnverifiedError, } from "./project-skills/reconciler.js";
-import { projectSkillExecutionProjection, projectSkillProjectionErrorCode } from "./project-skills/execution-adapter.js";
-import { redactProjectSkillRuntimeRootError, } from "./project-skills/runtime-launch.js";
+import { projectSkillExecutionProjection, projectSkillProjectionApplies, projectSkillProjectionErrorCode, } from "./project-skills/execution-adapter.js";
 import { createProjectRegistry } from "./project-skills/registry.js";
 import { ProjectDependencyError, } from "./project-dependencies.js";
 import { ProjectContextUnavailableError, resolveProjectContext } from "./project-workspaces/resolver.js";
@@ -524,7 +524,7 @@ export async function runExecution(config, input, dependencies) {
             if (dependencies.abilityRelease !== undefined) {
                 await cancellable(dependencies.abilityRelease.apply(config.agentsRoot, spec.agent.handle, spec.agent.abilityRelease), dependencies.cancellation);
             }
-            const reposRoot = config.reposRoot ?? join(config.agentsRoot, "repos");
+            const reposRoot = resolveReposRoot(config.agentsRoot, config.reposRoot);
             const preparedProjectDependencies = await cancellable(dependencies.projectDependencies.prepare({
                 trainingRoot: join(config.agentsRoot, spec.agent.handle, "training"),
                 reposRoot,
@@ -736,7 +736,7 @@ export async function runExecution(config, input, dependencies) {
                     }
                     catch (error) {
                         await proveActiveSupervisorStopped(error, true);
-                        throw redactProjectSkillRuntimeRootError(error, root);
+                        throw error;
                     }
                 };
                 return safeLaunch;
@@ -863,7 +863,7 @@ export async function runExecution(config, input, dependencies) {
                 token: credential.token,
                 agentId: credential.agentId,
                 agentsRoot: config.agentsRoot,
-                ...(config.reposRoot === undefined ? {} : { reposRoot: config.reposRoot }),
+                reposRoot: resolveReposRoot(config.agentsRoot, config.reposRoot),
                 ...(config.qaReportRoot === undefined ? {} : { qaReportRoot: config.qaReportRoot }),
                 cliPath: config.cliPath,
                 providerConfig,
@@ -973,14 +973,14 @@ export async function runExecution(config, input, dependencies) {
                 await dependencies.cancellation?.waitForStop();
             }
             catch (stopError) {
-                if (spec.agent.projectSkillBindingGeneration !== undefined) {
+                if (projectSkillProjectionApplies(spec)) {
                     throw new ProjectSkillRuntimeOwnershipUnverifiedError();
                 }
                 throw stopError;
             }
         }
         else {
-            await proveActiveSupervisorStopped(error, spec.agent.projectSkillBindingGeneration !== undefined);
+            await proveActiveSupervisorStopped(error, projectSkillProjectionApplies(spec));
         }
         const failureCompletion = cancelled
             ? ExecutionCompletedSchema.parse({

package/dist/host-execution-coordinator.js

@@ -5,6 +5,7 @@ import { randomUUID } from "node:crypto";
 import { defaultProcessController } from "./execution-journal.js";
 import { createJournalLease, createJournalLeaseRegistry, JournalLockedError, } from "./execution-journal-lock.js";
 import { dslog } from "./slog.js";
+import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
 const HOST_EXECUTION_SLOT_COUNT = 10;
 const HOST_STARTUP_SLOT_COUNT = 10;
 const HOST_STARTUP_GAP_MS = 500;
@@ -16,10 +17,10 @@ export class HostReservationCancelledError extends Error {
         super(message);
     }
 }
-export function defaultHostExecutionCoordinatorRoot(userHome = homedir()) {
+export function defaultHostExecutionCoordinatorRoot(userHome = homedir(), localHome) {
     // Deliberately independent of CREW_DAEMON_HOME and agentsRoot: every profile
     // owned by this OS user must share the same physical-compute safety boundary.
-    return resolve(userHome, ".crew", "daemon", "compute-execution");
+    return resolve(localHome ?? resolveDaemonLocalStateRoot({ userHome, platform: process.platform }), "daemon", "compute-execution");
 }
 async function syncDirectory(path) {
     if (process.platform === "win32")
@@ -132,7 +133,7 @@ async function writeLaunchTimestamp(path, value) {
     }
 }
 export function createHostExecutionCoordinator(options = {}) {
-    const root = resolve(options.root ?? defaultHostExecutionCoordinatorRoot());
+    const root = resolve(options.root ?? defaultHostExecutionCoordinatorRoot(options.userHome, options.localHome));
     const executionSlots = options.executionSlots ?? HOST_EXECUTION_SLOT_COUNT;
     const startupSlots = options.startupSlots ?? HOST_STARTUP_SLOT_COUNT;
     const startupGapMs = options.startupGapMs ?? HOST_STARTUP_GAP_MS;

package/dist/local-executor.js

@@ -24,8 +24,9 @@ import { isRuntimeReadyEvent, isRuntimeRunningEvent, } from "./runtime-startup-g
 import { dslog } from "./slog.js";
 import { boundedDiagnosticJsonArray } from "./diagnostic-json.js";
 import { ProjectProjectionError, } from "./project-skills/reconciler.js";
+import { projectSkillProjectionApplies } from "./project-skills/execution-adapter.js";
 import { formatProjectSkillRuntimeWarning } from "./project-skills/runtime-warning.js";
-import { projectSkillRuntimeDirectories, redactProjectSkillRuntimeRootText, redactProjectSkillRuntimeRootValue, } from "./project-skills/runtime-launch.js";
+import { projectSkillRuntimeDirectories, } from "./project-skills/runtime-launch.js";
 import { logIdentityRosterRuntimePrepared } from "./identity-roster-telemetry.js";
 import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, logMemoryPruneDiagnosticsFailure, memoryPruneSnapshotFields, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
@@ -466,6 +467,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             CREW_TOKEN: input.launch.token,
             CREW_CHANNEL: input.channelId,
             CREW_HOME: workspace.dir,
+            // Keep the daemon-selected storage root authoritative for runtimes.
+            // In profile-backed NowWork sessions the daemon config may differ from
+            // the daemon process environment, so inheriting CREW_AGENTS_ROOT is not
+            // sufficient for QA/project diagnostics.
+            CREW_AGENTS_ROOT: input.launch.agentsRoot,
             ...(input.launch.reposRoot === undefined ? {} : { NOWWORK_REPOS_ROOT: input.launch.reposRoot }),
             ...(input.launch.qaReportRoot === undefined ? {} : { QA_REPORT_HUB: input.launch.qaReportRoot }),
             // Expose only the training root; ability-specific workspace layout stays
@@ -520,12 +526,10 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         });
         if (dependencies.cancellation?.isRequested())
             throw new RuntimeCancelledError();
-        let activeProjectSkillRuntimeRoot;
         const abilityContext = input.abilityRelease !== undefined && dependencies.abilityRelease !== undefined
             ? await dependencies.abilityRelease.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.abilityRelease, async (context) => context)
             : undefined;
         const prepareRuntimeLaunch = async (runtimeRoot) => {
-            activeProjectSkillRuntimeRoot = runtimeRoot;
             const effectiveSystemPrompt = abilityContext === undefined
                 ? systemPrompt
                 : `${systemPrompt}\n\n${abilityContext.prompt}`;
@@ -676,11 +680,17 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             return launchRuntime(launchRequest);
         };
         let child;
-        if (input.projectSkills !== undefined && dependencies.projectSkills !== undefined) {
+        const projectionBindings = projectSkillProjectionApplies({
+            agent: { projectSkills: input.projectSkills },
+            runtime: input.runtime,
+        })
+            ? input.projectSkills
+            : undefined;
+        if (projectionBindings !== undefined && dependencies.projectSkills !== undefined) {
             const launchOwner = dependencies.projectSkillLeaseSafeLaunchOwner;
             if (launchOwner === undefined)
                 throw new ProjectProjectionError("skill_projection_failed");
-            child = await dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.executionId, input.handle, input.projectSkills, launchOwner.claim(launchPreparedRuntime), (warning) => callbacks.onConsole?.({
+            child = await dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.executionId, input.handle, projectionBindings, launchOwner.claim(launchPreparedRuntime), (warning) => callbacks.onConsole?.({
                 stream: "system",
                 text: formatProjectSkillRuntimeWarning(warning),
             }));
@@ -813,8 +823,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 usage = meta.usage;
             if (meta.model)
                 observedModel = meta.model;
-            for (const rawActivity of normalizeEvent(event)) {
-                const activity = redactProjectSkillRuntimeRootValue(rawActivity, activeProjectSkillRuntimeRoot);
+            for (const activity of normalizeEvent(event)) {
                 if (activity.kind === "sending")
                     sentViaCrew = true;
                 activities.push(activity);
@@ -822,19 +831,18 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             }
             const extracted = extractFinalText(event);
             if (extracted) {
-                const safeExtracted = redactProjectSkillRuntimeRootText(extracted, activeProjectSkillRuntimeRoot);
                 const incremental = typeof event === "object" && event !== null
                     && "type" in event && (event.type === "kimi.acp.text_delta"
                     || event.type === "hermes.acp.text_delta"
                     || event.type === "deepseek-harness.acp.text_delta"
                     || event.type === "opencode.text_delta");
-                finalText = incremental ? `${finalText ?? ""}${safeExtracted}` : safeExtracted;
+                finalText = incremental ? `${finalText ?? ""}${extracted}` : extracted;
             }
             for (const text of decodeExternalOutputEvent(runtime.name, event, externalOutput)) {
-                callbacks.onExternalOutput?.(redactProjectSkillRuntimeRootText(text, activeProjectSkillRuntimeRoot));
+                callbacks.onExternalOutput?.(text);
             }
             for (const chunk of consoleFormatter.format(event)) {
-                callbacks.onConsole?.(redactProjectSkillRuntimeRootValue(chunk, activeProjectSkillRuntimeRoot));
+                callbacks.onConsole?.(chunk);
             }
         });
         let stderrTail = "";
@@ -856,7 +864,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             })
             : null;
         child.stderr.on("data", (data) => {
-            const text = redactProjectSkillRuntimeRootText(String(data), activeProjectSkillRuntimeRoot);
+            const text = String(data);
             process.stderr.write(text);
             stderrTail = (stderrTail + text).slice(-STDERR_TAIL_CAP);
             codexStartupStageParser?.push(text);
@@ -935,9 +943,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }
         const errorTail = [
             stderrTail.trim(),
-            spawnError === undefined
-                ? undefined
-                : redactProjectSkillRuntimeRootText(spawnError, activeProjectSkillRuntimeRoot),
+            spawnError === undefined ? undefined : spawnError,
             terminationSignal ? `terminated by ${terminationSignal}` : undefined,
         ].filter(Boolean).join(" ").trim();
         const providerError = providerErrorFromExit(exitCode, errorTail);
@@ -989,11 +995,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 : null,
             // 契约答案 = 整轮最后一个闭合的标签块(六个 runtime 语义一致的"后到者胜",半截块与
             // 叙述里的开标签不算数);从未闭合过时才回落到对 finalText 的宽容提取,保住"收尾被
-            // 截断"这一老兜底。解码器存的是原文,这里补脱敏。注意这放宽了"externalAnswer 非空
+            // 截断"这一老兜底。注意这放宽了"externalAnswer 非空
             // ⇒ finalText 非空"的旧不变式;是否上报仍由 execution-runner 按 exitCode===0 把关。
             externalAnswer: input.captureFinal
                 ? (externalOutput.lastClosedBlock !== null
-                    ? redactProjectSkillRuntimeRootText(externalOutput.lastClosedBlock, activeProjectSkillRuntimeRoot)
+                    ? externalOutput.lastClosedBlock
                     : finalText !== null ? extractExternalAnswer(finalText) : null)
                 : null,
             sentViaCrew,

package/dist/local-memory/runtime.js

@@ -3,9 +3,11 @@ import { lstat, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { applyLocalMemoryResult, parseLocalMemoryResult } from "./write.js";
 export function isLocalMemoryV2Eligible(input) {
-    return input.enabledForHandle
-        && (input.localMemoryV2Initialized || (!input.agentHomePreexisted && input.memorySeedCreated))
-        && input.memoryPrune;
+    // The allowlist is the rollout boundary. The marker and seed/pre-existing
+    // state are retained as diagnostics and for backward-compatible marker
+    // creation, but must not prevent an explicitly allowlisted Agent from using
+    // the structured memory-prune protocol.
+    return input.enabledForHandle && input.memoryPrune;
 }
 const LOCAL_MEMORY_V2_MARKER = "v2-enabled";
 export async function initializeLocalMemoryV2(agentDir) {