@nowcrew/daemon 0.6.80-beta.1 → 0.6.80

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

@@ -95,6 +95,9 @@ function storageServiceEnvironment(env) {
         ...(env.NOWWORK_ENV_TAG === undefined ? {} : { NOWWORK_ENV_TAG: env.NOWWORK_ENV_TAG }),
         ...(env.NOWWORK_STORAGE_POLICY_PATH === undefined
             ? {} : { NOWWORK_STORAGE_POLICY_PATH: env.NOWWORK_STORAGE_POLICY_PATH }),
+        ...(env.NOWWORK_LOCAL_HOME === undefined ? {} : { NOWWORK_LOCAL_HOME: env.NOWWORK_LOCAL_HOME }),
+        ...(env.NOWWORK_LOCAL_HOME_MODE === undefined && env.NOWWORK_STORAGE_MODE === undefined
+            ? {} : { NOWWORK_LOCAL_HOME_MODE: env.NOWWORK_LOCAL_HOME_MODE ?? env.NOWWORK_STORAGE_MODE }),
     };
 }
 export async function runComputerCommand(argv, overrides = {}) {

package/dist/computer-service.js

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

@@ -103,6 +103,9 @@ async function main() {
                     ...(process.env.NOWWORK_ENV_TAG === undefined ? {} : { NOWWORK_ENV_TAG: process.env.NOWWORK_ENV_TAG }),
                     ...(process.env.NOWWORK_STORAGE_POLICY_PATH === undefined
                         ? {} : { NOWWORK_STORAGE_POLICY_PATH: process.env.NOWWORK_STORAGE_POLICY_PATH }),
+                    ...(process.env.NOWWORK_LOCAL_HOME === undefined ? {} : { NOWWORK_LOCAL_HOME: process.env.NOWWORK_LOCAL_HOME }),
+                    ...(process.env.NOWWORK_LOCAL_HOME_MODE === undefined && process.env.NOWWORK_STORAGE_MODE === undefined
+                        ? {} : { NOWWORK_LOCAL_HOME_MODE: process.env.NOWWORK_LOCAL_HOME_MODE ?? process.env.NOWWORK_STORAGE_MODE }),
                 },
             });
         }

package/dist/provider-env.js

@@ -11,6 +11,24 @@
 import { join } from "node:path";
 import { DEEPSEEK_CODEX_KEY_ENV, deepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
 import { DEEPSEEK_HARNESS_CONFIG_ENV } from "./runtimes/deepseek-harness.js";
+const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const RESERVED_ENV = new Set([
+    "PATH",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "XDG_CACHE_HOME",
+    "GH_CONFIG_DIR",
+    "CLOUDSDK_CONFIG",
+]);
+/** Keep user-provided variables away from daemon-owned runtime and credential fields. */
+export function sanitizeEnvVars(raw) {
+    if (!raw)
+        return {};
+    return Object.fromEntries(Object.entries(raw).filter(([key, value]) => typeof value === "string"
+        && ENV_KEY_RE.test(key)
+        && !key.toUpperCase().startsWith("CREW_")
+        && !RESERVED_ENV.has(key.toUpperCase())));
+}
 /** custom 模式下必须从继承 env 中剔除的全局路由/凭证变量(避免与注入值叠加或抢优先级)。 */
 const CONFLICTING_ENV = [
     "ANTHROPIC_BASE_URL",
@@ -39,12 +57,12 @@ const CONFLICTING_CODEX_ENV = [
     DEEPSEEK_CODEX_KEY_ENV,
 ];
 /** 返回叠加了 provider 隔离的新 env(不改入参);不支持的 runtime/provider 组合原样返回。 */
-export function applyProviderEnv(base, runtime, cfg, homeDir) {
+export function applyProviderEnv(base, runtime, cfg, homeDir, deepSeekHomeOverride) {
     if (runtime === "codex" && cfg.provider === "deepseek") {
         const env = { ...base };
         for (const key of CONFLICTING_CODEX_ENV)
             delete env[key];
-        env.CODEX_HOME = deepSeekCodexHome(homeDir);
+        env.CODEX_HOME = deepSeekHomeOverride ?? deepSeekCodexHome(homeDir);
         if (cfg.providerApiKey)
             env[DEEPSEEK_CODEX_KEY_ENV] = cfg.providerApiKey;
         return env;
@@ -100,7 +118,7 @@ export function applyDeepSeekHarnessMachineEnv(base, machineEnv) {
  */
 export function providerFingerprint(runtime, cfg) {
     if (runtime === "codex" && cfg.provider === "deepseek") {
-        return `deepseek|${cfg.providerApiKey ? "key" : "nokey"}`;
+        return `deepseek|${cfg.providerBaseUrl ?? "default"}|${cfg.providerApiKey ? "key" : "nokey"}`;
     }
     if (runtime !== "claude" || cfg.provider !== "custom")
         return null;

package/dist/runner.js

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

package/dist/runtimes/codex-app-server-runner.js

@@ -21,9 +21,14 @@ const RunnerInputSchema = z.object({
     cwd: z.string().min(1).optional(),
     workspaceRoots: z.array(z.string().min(1)).optional(),
     skillRoots: z.array(z.string().min(1)).optional(),
+    networkAccess: z.boolean().optional(),
     codexCollaborationTools: z.boolean().optional(),
     resume: z.boolean(),
-}).strict();
+}).strict().superRefine((input, ctx) => {
+    if (input.networkAccess === true && input.effectivePermission !== "workspace_write") {
+        ctx.addIssue({ code: "custom", message: "network_access_requires_workspace_write" });
+    }
+});
 const RPC_TIMEOUT_MS = 30_000;
 const INITIALIZE_RPC_TIMEOUT_MS = 60_000;
 const ERROR_MESSAGE_CAP = 2_000;
@@ -565,18 +570,18 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
             ...(input.model === undefined ? {} : { model: input.model }),
         };
         let thread;
-        const nativeContractRequired = input.workspaceRoots !== undefined || input.skillRoots !== undefined;
+        const workspaceContractRequired = input.workspaceRoots !== undefined;
         try {
             thread = input.resume && input.sessionId !== undefined
                 ? await rpc.request("thread/resume", { threadId: input.sessionId, ...threadParams })
                 : await rpc.request("thread/start", threadParams);
         }
         catch (error) {
-            if (nativeContractRequired)
+            if (workspaceContractRequired)
                 throw codexProjectWorkspaceUnsupported();
             throw error;
         }
-        if (nativeContractRequired) {
+        if (workspaceContractRequired) {
             thread = assertCodexProjectWorkspaceResponse(thread, {
                 cwd: threadCwd,
                 workspaceRoots: input.workspaceRoots ?? [],
@@ -613,6 +618,9 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
             ...(input.reasoning === undefined || input.reasoning === "default"
                 ? {}
                 : { effort: input.reasoning }),
+            ...(input.networkAccess === true ? {
+                sandboxPolicy: { type: "workspaceWrite", networkAccess: true },
+            } : {}),
         });
         logStage(activeStage, "ok", attempt, stageStartedAt);
         turnId = started.turn.id;

package/dist/runtimes/codex-deepseek-config.js

@@ -7,10 +7,20 @@ export const DEEPSEEK_CODEX_BASE_URL = "https://api.deepseek.com/";
 export const DEEPSEEK_CODEX_KEY_ENV = "NOWCREW_DEEPSEEK_API_KEY";
 export const DEEPSEEK_CODEX_REASONING_LEVELS = ["low", "high", "max"];
 const PRIVATE_CODEX_HOME = ".codex-deepseek";
-export function deepSeekCodexHome(homeDir) {
-    return resolve(homeDir, PRIVATE_CODEX_HOME);
+const SELF_TRAINING_PRIVATE_CODEX_HOME = ".codex-deepseek-self-training";
+export function deepSeekCodexHome(homeDir, selfTraining = false) {
+    return resolve(homeDir, selfTraining ? SELF_TRAINING_PRIVATE_CODEX_HOME : PRIVATE_CODEX_HOME);
 }
-export function renderDeepSeekConfig(codexHome) {
+function normalizedBaseUrl(value) {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new Error("DeepSeek provider base URL must use HTTP(S)");
+    }
+    if (!url.pathname.endsWith("/"))
+        url.pathname = `${url.pathname}/`;
+    return url.toString();
+}
+export function renderDeepSeekConfig(codexHome, baseUrl = DEEPSEEK_CODEX_BASE_URL) {
     const catalogPath = join(codexHome, "models.json");
     return [
         `model = ${JSON.stringify(DEEPSEEK_CODEX_MODEL)}`,
@@ -20,7 +30,7 @@ export function renderDeepSeekConfig(codexHome) {
         "",
         "[model_providers.deepseek]",
         'name = "deepseek"',
-        `base_url = ${JSON.stringify(DEEPSEEK_CODEX_BASE_URL)}`,
+        `base_url = ${JSON.stringify(normalizedBaseUrl(baseUrl))}`,
         'wire_api = "responses"',
         `env_key = ${JSON.stringify(DEEPSEEK_CODEX_KEY_ENV)}`,
         "",
@@ -40,11 +50,11 @@ async function writePrivateAtomic(path, content) {
         await rm(temporary, { force: true });
     }
 }
-export async function materializeDeepSeekCodexHome(homeDir) {
-    const codexHome = deepSeekCodexHome(homeDir);
+export async function materializeDeepSeekCodexHome(homeDir, options = {}) {
+    const codexHome = deepSeekCodexHome(homeDir, options.selfTraining === true);
     await mkdir(codexHome, { recursive: true, mode: 0o700 });
     await chmod(codexHome, 0o700);
     await writePrivateAtomic(join(codexHome, "models.json"), DEEPSEEK_CODEX_CATALOG);
-    await writePrivateAtomic(join(codexHome, "config.toml"), renderDeepSeekConfig(codexHome));
+    await writePrivateAtomic(join(codexHome, "config.toml"), renderDeepSeekConfig(codexHome, options.baseUrl));
     return codexHome;
 }

package/dist/runtimes/codex.js

@@ -36,6 +36,9 @@ export function buildCodexArgs(input) {
     else if (input.effectivePermission === "full_access" || (input.effectivePermission === undefined && input.dangerous)) {
         args.push("--dangerously-bypass-approvals-and-sandbox");
     }
+    if (input.effectivePermission === "workspace_write" && input.networkAccess === true) {
+        args.push("-c", "sandbox_workspace_write.network_access=true");
+    }
     for (const imagePath of input.imagePaths ?? [])
         args.push("--image", imagePath);
     // `-` instructs codex exec to read the prompt from stdin. Keeping the complete prompt out of argv

package/dist/self-training-workspace.js

@@ -0,0 +1,15 @@
+import { rm } from "node:fs/promises";
+import { isAbsolute, relative, sep } from "node:path";
+/** Delete only a concrete child of this Agent's tasks root; never follow an ambiguous target. */
+export async function cleanupSelfTrainingRunDir(tasksRoot, runDir) {
+    const child = relative(tasksRoot, runDir);
+    if (child === "" || isAbsolute(child) || child === ".." || child.startsWith(`..${sep}`))
+        return;
+    try {
+        await rm(runDir, { recursive: true, force: true });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`[execution] failed to remove self-training run dir ${runDir}: ${detail}\n`);
+    }
+}

package/dist/supervised-runtime.js

@@ -46,6 +46,7 @@ export function supervisorLaunch(request) {
                 effectivePermission: request.effectivePermission,
                 ...(request.model === undefined ? {} : { model: request.model }),
                 ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
+                ...(request.networkAccess === undefined ? {} : { networkAccess: request.networkAccess }),
                 ...(request.sessionId === undefined ? {} : { sessionId: request.sessionId }),
                 ...(request.imagePaths === undefined ? {} : { imagePaths: request.imagePaths }),
                 ...(request.agentRoot === undefined ? {} : {

package/dist/workspace.js

@@ -59,12 +59,13 @@ export async function prepareWorkspace(input) {
     const crewDir = join(dir, ".crew");
     await mkdir(crewDir, { recursive: true });
     // 预先创建明细目录,让收尾流程可以按功能创建 notes/<topic>.md。
-    await mkdir(join(dir, "notes"), { recursive: true });
+    if (!input.skipLocalMemory)
+        await mkdir(join(dir, "notes"), { recursive: true });
     // MEMORY.md:首次创建"持久身份 + 知识索引"骨架,之后由 agent 自己维护
     const memoryPath = join(dir, "MEMORY.md");
-    const memorySeedCreated = !(await exists(memoryPath));
+    const memorySeedCreated = !input.skipLocalMemory && !(await exists(memoryPath));
     const localMemoryV2Initialized = await hasLocalMemoryV2Marker(dir);
-    if (memorySeedCreated) {
+    if (!input.skipLocalMemory && memorySeedCreated) {
         try {
             await writeFile(memoryPath, memorySeed(input.handle, input.description), "utf8");
         }
@@ -73,13 +74,15 @@ export async function prepareWorkspace(input) {
             throw error;
         }
     }
-    let memory;
-    try {
-        memory = await readFile(memoryPath, "utf8");
-    }
-    catch (error) {
-        logMemoryPrepareFailure(input, "memory_read", error);
-        throw error;
+    let memory = "";
+    if (!input.skipLocalMemory) {
+        try {
+            memory = await readFile(memoryPath, "utf8");
+        }
+        catch (error) {
+            logMemoryPrepareFailure(input, "memory_read", error);
+            throw error;
+        }
     }
     // 系统提示词按 execution 隔离;省略 identity 的兼容调用每次使用随机路径。
     const promptDir = join(crewDir, "prompts");

package/package.json

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

package/dist/package-manager-env.js

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

package/dist/runtime-env.js

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