@nowcrew/daemon 0.6.80-beta.1 → 0.6.80-beta.3

package/dist/agent-ability/resolver.js

@@ -10,8 +10,8 @@ import { PROJECT_MANIFEST_SOURCE_PATH, ProjectDependencyManifestSchema, } from "
 import { normalizeRepositoryIdentity } from "../repository-identity.js";
 const runFile = promisify(execFile);
 const MAX_FILES = 5_000;
-const MAX_TOTAL_BYTES = 25 * 1024 * 1024;
-const MAX_FILE_BYTES = 2 * 1024 * 1024;
+export const AGENT_ABILITY_MAX_TOTAL_BYTES = 200 * 1024 * 1024;
+export const AGENT_ABILITY_MAX_FILE_BYTES = 100 * 1024 * 1024;
 const MAX_INSTRUCTIONS_BYTES = 96 * 1024;
 const MAX_MEMORY_BYTES = 64 * 1024;
 const AUTHORING_ONLY_ROOTS = new Set([".claude"]);
@@ -125,10 +125,11 @@ export const collectAbilityFiles = async (root) => {
             if (info.isDirectory())
                 await visit(absolute);
             else if (info.isFile()) {
-                if (info.size > MAX_FILE_BYTES)
+                if (info.size > AGENT_ABILITY_MAX_FILE_BYTES) {
                     throw new Error(`ability_file_size_exceeded:${relative(root, absolute)}`);
+                }
                 totalBytes += info.size;
-                if (totalBytes > MAX_TOTAL_BYTES)
+                if (totalBytes > AGENT_ABILITY_MAX_TOTAL_BYTES)
                     throw new Error("ability_total_size_exceeded");
                 if (files.length >= MAX_FILES)
                     throw new Error("ability_file_count_exceeded");
@@ -262,7 +263,7 @@ export const validateAbilityDependencyDeclarations = (manifest, lock) => {
         throw new Error("ability_lock_has_undeclared_dependency");
     }
 };
-const scan = (files, manifest) => {
+export const scanAbilityFiles = (files, manifest) => {
     const findings = [];
     const secrets = [
         /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/u,
@@ -270,7 +271,9 @@ const scan = (files, manifest) => {
         /\bAK(?:ID|IA)[A-Z0-9]{12,}\b/u,
     ];
     const executable = new Set([".exe", ".dll", ".dylib", ".so", ".bin", ".class", ".jar"]);
-    const allowedBinaryDocuments = new Set([".pdf", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".xlsx", ".xls", ".docx", ".pptx"]);
+    const allowedBinaryDocuments = new Set([
+        ".pdf", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".xlsx", ".xls", ".docx", ".pptx", ".ttf", ".otf",
+    ]);
     for (const file of files) {
         let text;
         try {
@@ -396,7 +399,7 @@ export async function resolveAbilityRelease(agentsRoot, command) {
     }
     const externalPaths = await verifyExternalDependencies(cacheRoot, resolved.root, lock);
     files = await collectAbilityFiles(resolved.root);
-    const security = scan(files, manifest);
+    const security = scanAbilityFiles(files, manifest);
     const kinds = new Set(lock.assets.map((asset) => asset.kind));
     const memory = [];
     for (const [layer, mounts] of [["release-policy", manifest.spec.memory.policy], ["release-seed", manifest.spec.memory.seeds]]) {

package/dist/computer-cli.js

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

package/dist/computer-service.js

@@ -32,6 +32,18 @@ export const systemCommandRunner = async (command, args) => {
         };
     }
 };
+/** Build the non-secret storage environment persisted in managed services. */
+export function storageServiceEnvironment(env) {
+    return {
+        ...(env.NOWWORK_HOME === undefined ? {} : { NOWWORK_HOME: env.NOWWORK_HOME }),
+        ...(env.NOWWORK_ENV_TAG === undefined ? {} : { NOWWORK_ENV_TAG: env.NOWWORK_ENV_TAG }),
+        ...(env.NOWWORK_STORAGE_POLICY_PATH === undefined
+            ? {} : { NOWWORK_STORAGE_POLICY_PATH: env.NOWWORK_STORAGE_POLICY_PATH }),
+        ...(env.NOWWORK_LOCAL_HOME === undefined ? {} : { NOWWORK_LOCAL_HOME: env.NOWWORK_LOCAL_HOME }),
+        ...(env.NOWWORK_LOCAL_HOME_MODE === undefined && env.NOWWORK_STORAGE_MODE === undefined
+            ? {} : { NOWWORK_LOCAL_HOME_MODE: env.NOWWORK_LOCAL_HOME_MODE ?? env.NOWWORK_STORAGE_MODE }),
+    };
+}
 function serviceIdentitySuffix(profileHome, userHome) {
     if (profileHome === undefined || resolve(profileHome) === resolve(userHome, ".crew", "daemon"))
         return "";
@@ -80,6 +92,8 @@ export function buildServiceSpec(input) {
             ["NOWWORK_HOME", environment.NOWWORK_HOME],
             ["NOWWORK_ENV_TAG", environment.NOWWORK_ENV_TAG],
             ["NOWWORK_STORAGE_POLICY_PATH", environment.NOWWORK_STORAGE_POLICY_PATH],
+            ["NOWWORK_LOCAL_HOME", environment.NOWWORK_LOCAL_HOME],
+            ["NOWWORK_LOCAL_HOME_MODE", environment.NOWWORK_LOCAL_HOME_MODE],
         ].flatMap(([key, value]) => value === undefined
             ? []
             : [`    <key>${key}</key><string>${xml(assertSingleLine(value, key))}</string>`]);

package/dist/daemon-local-home.js

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

package/dist/daemon-update-eligibility.js

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

package/dist/execution-protocol.js

@@ -200,6 +200,7 @@ export const ExecutionStartSchema = z.object({
         language: z.enum(["zh", "en"]),
         systemPrompt: z.string(),
         wakePrompt: z.string(),
+        maintenancePurpose: z.literal("self_training").optional(),
     }).strict(),
     runtime: z.object({
         name: RuntimeSchema,

package/dist/execution-runner.js

@@ -567,8 +567,9 @@ export async function runExecution(config, input, dependencies) {
             projectContext = await cancellable(resolveProjectContext(projectSnapshot, projectWorkspaceRegistry), dependencies.cancellation);
             sessionContextFingerprint = projectSessionContextFingerprint(spec.runtime.name, projectSnapshot);
         }
+        const selfTraining = spec.instructions.maintenancePurpose === "self_training";
         let recalledMemory = "";
-        if (spec.agent.memoryEnabled === true && dependencies.agentMemory !== undefined) {
+        if (!selfTraining && spec.agent.memoryEnabled === true && dependencies.agentMemory !== undefined) {
             try {
                 recalledMemory = await cancellable(dependencies.agentMemory.recall(spec.agent.handle, spec.instructions.wakePrompt, spec.executionId, spec.agent.memoryAgentId ?? null), dependencies.cancellation);
             }
@@ -827,7 +828,10 @@ export async function runExecution(config, input, dependencies) {
         const baseSystemPromptBudget = spec.agent.abilityRelease === undefined
             ? systemPromptBudget
             : Math.max(0, Math.min(systemPromptBudget, Math.max(32 * 1024, systemPromptBudget - 168 * 1024)));
-        const systemPromptWithLocalFacts = withLocalExecutionFacts(spec.instructions.systemPrompt, baseSystemPromptBudget, { collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex" });
+        const systemPromptWithLocalFacts = withLocalExecutionFacts(spec.instructions.systemPrompt, baseSystemPromptBudget, {
+            ...(selfTraining ? { isolateLocalMemory: true } : {}),
+            collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex",
+        });
         const boundedSystemPrompt = (context) => appendAgentMemoryContext(typeof systemPromptWithLocalFacts === "string"
             ? systemPromptWithLocalFacts
             : systemPromptWithLocalFacts(context), recalledMemory, baseSystemPromptBudget);
@@ -876,12 +880,13 @@ export async function runExecution(config, input, dependencies) {
                 } : {}),
             },
             session: {
-                enabled: config.resume,
+                enabled: selfTraining ? false : config.resume,
                 warmMs: config.resumeWarmMs,
                 budgetTokens: config.sessionBudgetTokens,
                 softTokens: config.sessionSoftTokens,
                 maxTurns: config.sessionMaxTurns,
             },
+            ...(selfTraining ? { maintenancePurpose: "self_training" } : {}),
             localMemoryV2Enabled: config.localMemoryV2Handles?.has(spec.agent.handle) === true,
         };
         const result = await Promise.race([
@@ -1048,6 +1053,7 @@ export async function runExecution(config, input, dependencies) {
     }
     await dependencies.journal.complete(spec.executionId, completion);
     if (completion.outcome === "succeeded"
+        && spec.instructions.maintenancePurpose !== "self_training"
         && spec.agent.memoryEnabled === true
         && memoryCaptureFinalText !== null
         && dependencies.agentMemory !== undefined) {

package/dist/local-execution-prompt.js

@@ -47,12 +47,13 @@ function takeCompletePromptSections(sections, maxBytes) {
 /** v1 server instructions opt in to daemon-owned paths and bounded local workspace context. */
 export function withLocalExecutionFacts(serverPrompt, maxBytes, options = {}) {
     return ({ workspace, resuming, projectContext, trainingProjectContext }) => {
-        const memory = capMemoryForInject(workspace.memory);
+        const memory = options.isolateLocalMemory ? "" : capMemoryForInject(workspace.memory);
         const workLog = resuming ? "" : capWorkLogForInject(workspace.workLog);
         const collaborationPrompt = options.collaborationTools === true ? buildCollaborationToolsPrompt() : "";
         const mandatoryWorkspacePrompt = `${buildRuntimeWorkspacePrompt(projectContext)}${buildTrainingGitProjectPrompt(trainingProjectContext)}`;
+        const crewHome = options.isolateLocalMemory ? workspace.runDir : workspace.dir;
         const localFactSections = [`\n\n## Local execution facts
-- $CREW_HOME: ${workspace.dir}
+- $CREW_HOME: ${crewHome}
 - $CREW_TASK_LOG: ${workspace.workLogPath}`,
             ...(memory ? [`\n\n## Injected MEMORY.md (bounded local context)\n${memory}`] : []),
             ...(workLog ? [`\n\n## Injected work-log (bounded local context)\n${workLog}`] : []),

package/dist/local-executor.js

@@ -1,6 +1,7 @@
 import { createInterface } from "node:readline";
 import { readFile, rm, writeFile } from "node:fs/promises";
 import { delimiter, join } from "node:path";
+import { cleanupSelfTrainingRunDir } from "./self-training-workspace.js";
 import { prepareWorkspace, rotateAgentSession, safeKey, } from "./workspace.js";
 import { CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV, isClaudeAdditionalDirectoryInstructionsSupported, probeClaudeVersion, spawnClaude, } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
@@ -111,6 +112,7 @@ async function launchLegacyRuntime(request) {
         effectivePermission: request.effectivePermission,
         ...(request.model === undefined ? {} : { model: request.model }),
         ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
+        ...(request.networkAccess === undefined ? {} : { networkAccess: request.networkAccess }),
     };
     if (request.runtime === "claude") {
         const additionalDirectories = request.claudeAdditionalDirectories
@@ -200,6 +202,7 @@ export async function executeLocal(input, callbacks = {}, dependencies = {}) {
 async function executeLocalUnlocked(input, callbacks, dependencies) {
     const providerConfig = input.launch.providerConfig ?? {};
     const { runtime } = input;
+    const isolatedMaintenance = input.maintenancePurpose === "self_training";
     const isDeepSeekCodex = runtime.name === "codex" && providerConfig.provider === "deepseek";
     const currentModel = isDeepSeekCodex ? DEEPSEEK_CODEX_MODEL : runtime.model ?? null;
     const launchModel = isDeepSeekCodex ? DEEPSEEK_CODEX_MODEL : runtime.model;
@@ -224,6 +227,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 ? {}
                 : { sessionContextFingerprint: input.sessionContextFingerprint }),
             ...(input.launch.description ? { description: input.launch.description } : {}),
+            ...(isolatedMaintenance ? { skipLocalMemory: true } : {}),
         }), dependencies.cancellation);
     }
     catch (error) {
@@ -254,12 +258,23 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     }
     const sourceCodexHome = inheritedEnv.CODEX_HOME
         ?? (inheritedEnv.HOME === undefined ? undefined : join(inheritedEnv.HOME, ".codex"));
+    let materializedDeepSeekHome;
     try {
         if (isDeepSeekCodex && !providerConfig.providerApiKey) {
             throw new Error("DeepSeek API key is not configured for this Agent");
         }
         if (isDeepSeekCodex) {
-            await awaitWithCancellation((dependencies.materializeDeepSeekCodexHome ?? materializeDeepSeekCodexHome)(workspace.homeDir), dependencies.cancellation);
+            const providerBaseUrl = providerConfig.providerBaseUrl
+                ? new URL(providerConfig.providerBaseUrl, input.launch.serverUrl).toString()
+                : undefined;
+            const materialize = dependencies.materializeDeepSeekCodexHome ?? materializeDeepSeekCodexHome;
+            const materializeOptions = {
+                ...(providerBaseUrl === undefined ? {} : { baseUrl: providerBaseUrl }),
+                ...(isolatedMaintenance ? { selfTraining: true } : {}),
+            };
+            materializedDeepSeekHome = await awaitWithCancellation(providerBaseUrl === undefined && !isolatedMaintenance
+                ? materialize(workspace.homeDir)
+                : materialize(workspace.homeDir, materializeOptions), dependencies.cancellation);
         }
         const supportsNativeResume = runtime.name === "claude"
             || (dependencies.launchRuntime !== undefined && runtimeCapability(runtime.name).nativeResume);
@@ -387,29 +402,30 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const systemPrompt = localMemoryResultPath === null
             ? baseSystemPrompt
             : `${baseSystemPrompt}${structuredMemoryInstructions ?? ""}`;
-        try {
-            localMemoryTelemetry = createLocalMemoryTelemetry({
-                executionId: input.executionId,
-                agentHandle: input.handle,
-                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-                runtime: runtime.name,
-                stableProtocolRuntime: dependencies.launchRuntime !== undefined,
-                agentDir: executionWorkspace.dir,
-                runDir: executionWorkspace.runDir,
-                isMemoryPrune: memoryPruneTraceId !== null,
-                diagnosticsTimeoutMs: dependencies.localMemoryDiagnosticsTimeoutMs
-                    ?? LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS,
-            });
-            await localMemoryTelemetry.captureBefore();
-        }
-        catch (error) {
-            localMemoryTelemetry = null;
-            logLocalMemoryDiagnosticsFailure({
-                executionId: input.executionId,
-                agentHandle: input.handle,
-                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-            }, "initialize", error);
-        }
+        if (!isolatedMaintenance)
+            try {
+                localMemoryTelemetry = createLocalMemoryTelemetry({
+                    executionId: input.executionId,
+                    agentHandle: input.handle,
+                    ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+                    runtime: runtime.name,
+                    stableProtocolRuntime: dependencies.launchRuntime !== undefined,
+                    agentDir: executionWorkspace.dir,
+                    runDir: executionWorkspace.runDir,
+                    isMemoryPrune: memoryPruneTraceId !== null,
+                    diagnosticsTimeoutMs: dependencies.localMemoryDiagnosticsTimeoutMs
+                        ?? LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS,
+                });
+                await localMemoryTelemetry.captureBefore();
+            }
+            catch (error) {
+                localMemoryTelemetry = null;
+                logLocalMemoryDiagnosticsFailure({
+                    executionId: input.executionId,
+                    agentHandle: input.handle,
+                    ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+                }, "initialize", error);
+            }
         if (memoryPruneTraceId !== null) {
             memoryPruneSharedWriteKey = JSON.stringify([input.launch.agentsRoot, input.handle]);
             const activePruneCount = (activeMemoryPrunes.get(memoryPruneSharedWriteKey) ?? 0) + 1;
@@ -443,6 +459,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             }
         }
         memoryPruneFailurePhase = "runtime_prepare";
+        const crewHome = isolatedMaintenance ? executionWorkspace.runDir : workspace.dir;
         const baseEnv = {
             ...inheritedEnv,
             ...sanitizeEnvVars(providerConfig.envVars),
@@ -454,7 +471,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             CREW_SERVER_URL: input.launch.serverUrl,
             CREW_TOKEN: input.launch.token,
             CREW_CHANNEL: input.channelId,
-            CREW_HOME: workspace.dir,
+            CREW_HOME: crewHome,
             // 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
@@ -464,7 +481,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             ...(input.launch.qaReportRoot === undefined ? {} : { QA_REPORT_HUB: input.launch.qaReportRoot }),
             // Expose only the training root; ability-specific workspace layout stays
             // owned by the training package rather than the NowWork daemon.
-            QA_RUNTIME_ROOT: join(workspace.dir, "training"),
+            QA_RUNTIME_ROOT: join(crewHome, "training"),
             CREW_TASK_DIR: executionWorkspace.runDir,
             CREW_TASK_LOG: executionWorkspace.workLogPath,
             ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
@@ -480,7 +497,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         };
         const providerEnv = applyProviderEnv(baseEnv, runtime.name, input.launch.codexHomeMode === undefined
             ? providerConfig
-            : { ...providerConfig, codexHomeMode: input.launch.codexHomeMode }, workspace.homeDir);
+            : { ...providerConfig, codexHomeMode: input.launch.codexHomeMode }, workspace.homeDir, materializedDeepSeekHome);
         const childEnv = runtime.name === "deepseek-harness"
             ? applyDeepSeekHarnessMachineEnv(providerEnv, inheritedEnv)
             : providerEnv;
@@ -492,7 +509,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             qa_runtime_root_present: childEnv.QA_RUNTIME_ROOT !== undefined,
             inherited_qa_runtime_root_present: inheritedEnv.QA_RUNTIME_ROOT !== undefined,
             ...packageManagerEnvFacts(childEnv),
-            training_root: join(workspace.dir, "training"),
+            training_root: join(crewHome, "training"),
             project_context_present: input.projectContext !== undefined,
             project_ids: JSON.stringify(input.projectContext === undefined
                 ? []
@@ -624,6 +641,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 ...(input.projectContext === undefined ? {} : {
                     projectContext: input.projectContext,
                 }),
+                ...(isolatedMaintenance && runtime.name === "codex" ? { networkAccess: true } : {}),
                 ...(input.projectContext === undefined && workspaceRoots.length === 0
                     ? {}
                     : { workspaceRoots: Object.freeze(workspaceRoots) }),
@@ -1107,5 +1125,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             const detail = error instanceof Error ? error.message : String(error);
             process.stderr.write(`[execution] failed to remove prompt ${workspace.systemPromptPath}: ${detail}\n`);
         }
+        if (isolatedMaintenance) {
+            await cleanupSelfTrainingRunDir(join(workspace.dir, "tasks"), executionWorkspace.runDir);
+        }
     }
 }

package/dist/machine-info.js

@@ -25,7 +25,9 @@ export { executableRuntimes } from "./runtime-capabilities.js";
 const execFileP = promisify(execFile);
 export const PROJECT_WORKSPACES_CAPABILITY = "project_workspaces_v1";
 export const TRAINING_PROJECT_DEPENDENCIES_CAPABILITY = "training_project_dependencies_v1";
+export const SELF_TRAINING_EXECUTION_CAPABILITY = "self_training_execution_v1";
 export const EXECUTION_LARGE_ATTACHMENTS_CAPABILITY = "execution_attachments_300m_v1";
+export const PROJECT_SKILL_PROJECTION_CAPABILITY = "project_skill_projection_v2";
 export const NATIVE_PROJECT_WORKSPACE_READINESS = Object.freeze({
     resolverReady: true,
     nativeRuntimeAdaptersReady: true,
@@ -42,6 +44,7 @@ export const DAEMON_CAPABILITIES = Object.freeze([
     "execution_machine_queue_v1",
     "execution_agent_memory_policy_v1",
     "execution_agent_memory_mapping_v1",
+    SELF_TRAINING_EXECUTION_CAPABILITY,
     "project_skills_v1",
     "project_skill_projection_v2",
     PROJECT_WORKSPACES_CAPABILITY,

package/dist/main.js

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

package/dist/managed-service-lifecycle.js

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