@nowcrew/daemon 0.6.89 → 0.6.91-beta.1

package/dist/execution-runner.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
-import { resolveReposRoot } from "./config.js";
+import { isLocalMemoryV2Enabled, localMemoryV2Environment, 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";
@@ -210,6 +210,7 @@ function launchProviderConfig(config) {
             ? {}
             : { providerSmallFastModel: config.providerSmallFastModel }),
         ...(config.envVars === undefined ? {} : { envVars: config.envVars }),
+        ...(config.environmentPlan === undefined ? {} : { environmentPlan: config.environmentPlan }),
         ...(config.description === undefined ? {} : { description: config.description }),
     };
 }
@@ -408,7 +409,8 @@ export async function runExecution(config, input, dependencies) {
         ? { permission: effectivePermission(spec, config) }
         : admission(spec, config, dependencies, initialAt);
     if ("rejected" in checked) {
-        const frame = ExecutionRejectedSchema.parse(boundExecutionFrame(checked.rejected, config.executionLimits.maxEventBytes));
+        const proof = await dependencies.confirmPreAdmission?.(checked.rejected).catch(() => false);
+        const frame = ExecutionRejectedSchema.parse(boundExecutionFrame({ ...checked.rejected, ...(proof ? { preAdmissionProof: { specHash } } : {}) }, config.executionLimits.maxEventBytes));
         await dependencies.report(frame);
         return { kind: "rejected", frame };
     }
@@ -745,6 +747,7 @@ export async function runExecution(config, input, dependencies) {
             },
         });
         const localDependencies = {
+            ...(dependencies.machineEnvironment === undefined ? {} : { machineEnvironment: dependencies.machineEnvironment }),
             ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
             ...(dependencies.startupGate === undefined ? {} : { startupGate: dependencies.startupGate }),
             ...(dependencies.startupTimeoutMs === undefined
@@ -829,12 +832,15 @@ 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 localMemoryV2Enabled = config.localMemoryV2Handles?.has(spec.agent.handle) === true;
-        const systemPromptWithLocalFacts = withLocalExecutionFacts(`${spec.instructions.systemPrompt}${localMemoryV2Enabled ? renderLocalMemoryV2WriteGuard() : ""}`, baseSystemPromptBudget, {
-            ...(selfTraining ? { isolateLocalMemory: true } : {}),
-            collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex",
-        });
+        const localMemoryV2Enabled = !selfTraining && isLocalMemoryV2Enabled(config, spec.agent.handle);
+        // 开发环境的系统/当前轮写保护由 prepareLocalMemoryPrompt 统一注入并预留预算。
+        const localMemoryGuardInBase = localMemoryV2Environment(config.serverUrl) === "custom";
         const boundedSystemPrompt = (context) => {
+            const enabled = context.workspace.localMemoryV2Enabled ?? localMemoryV2Enabled;
+            const systemPromptWithLocalFacts = withLocalExecutionFacts(`${spec.instructions.systemPrompt}${enabled && localMemoryGuardInBase ? renderLocalMemoryV2WriteGuard() : ""}`, baseSystemPromptBudget, {
+                ...(selfTraining ? { isolateLocalMemory: true } : {}),
+                collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex",
+            });
             const base = typeof systemPromptWithLocalFacts === "string"
                 ? systemPromptWithLocalFacts
                 : systemPromptWithLocalFacts(context);
@@ -877,7 +883,6 @@ export async function runExecution(config, input, dependencies) {
                 ...(config.qaReportRoot === undefined ? {} : { qaReportRoot: config.qaReportRoot }),
                 cliPath: config.cliPath,
                 providerConfig,
-                codexHomeMode: config.codexHomeMode,
                 ...(providerConfig.description ? { description: providerConfig.description } : {}),
                 ...(spec.reporting.allowBoundImDecision ? {
                     systemEnv: {

package/dist/i18n.js

@@ -18,6 +18,11 @@ export function detectDaemonLang(env = process.env) {
 const zh = {
     "Claude session started": "Claude 会话启动",
     "Codex session started": "Codex 会话启动",
+    "Kimi session started": "Kimi 会话启动",
+    "Hermes session started": "Hermes 会话启动",
+    "OpenCode session started": "OpenCode 会话启动",
+    "DeepSeek Harness session started": "DeepSeek Harness 会话启动",
+    "Session started": "会话启动",
     "Plan updated": "计划更新",
     "Thinking (~{{tokens}} tokens, content not streamed by Claude Code)": "思考（约 {{tokens}} tokens，Claude Code 未输出思考正文）",
     "Thinking (content not streamed by Claude Code)": "思考（Claude Code 未输出思考正文）",
@@ -26,6 +31,20 @@ const zh = {
     "Run finished": "本轮结束",
     "Missing CREW_MACHINE_TOKEN (sk_machine_*, printed by seed)": "缺少 CREW_MACHINE_TOKEN（sk_machine_*，由 seed 打印）",
     "Usage:": "用法：",
+    "Open {{url}}": "打开 {{url}}",
+    "Code {{code}}": "验证码 {{code}}",
+    "Browser open skipped: {{reason}}": "未能自动打开浏览器：{{reason}}",
+    "Starting computer setup pairing...": "正在发起电脑接入授权…",
+    "Workspace: {{value}}": "工作区：{{value}}",
+    "Machine:   {{value}}": "机器：   {{value}}",
+    "Environment: {{value}}": "环境：{{value}}",
+    "Daemon:    profile {{profile}} / v{{version}} / {{status}}": "Daemon：配置 {{profile}} / v{{version}} / {{status}}",
+    "Local:     {{value}}": "本地目录：{{value}}",
+    "Config:    {{value}}": "配置目录：{{value}}",
+    "Agents:    {{value}}": "Agent 目录：{{value}}",
+    "Storage ID: {{value}}": "存储标识：{{value}}",
+    "Status:    connected and ready": "状态：已连接并就绪",
+    "Status:    not ready": "状态：尚未就绪",
     "connect and stay resident": "连接并常驻",
     "run once manually": "手动运行一次",
     "resident, connecting to": "常驻，连接到",

package/dist/list-models.js

@@ -8,8 +8,8 @@ const execFileRaw = promisify(execFile);
 const MODEL_PROBE_TIMEOUT_MS = 8_000;
 const MODEL_PROBE_MAX_BUFFER_BYTES = 1024 * 1024;
 // win32 上 npm CLI 是 .cmd shim,execFile 需 shell 才能执行;参数全是固定字面量,无注入面。
-const execFileP = (bin, args) => execFileRaw(bin, args, {
-    env: { ...process.env, PATH: augmentedPath() },
+const execFileP = (bin, args, env = { ...process.env, PATH: augmentedPath() }) => execFileRaw(bin, args, {
+    env,
     shell: isWin(),
     timeout: MODEL_PROBE_TIMEOUT_MS,
     killSignal: "SIGKILL",
@@ -18,17 +18,17 @@ const execFileP = (bin, args) => execFileRaw(bin, args, {
 export async function listRuntimeModels(runtime, options = {}) {
     switch (runtime) {
         case "claude":
-            return listClaudeModels();
+            return listClaudeModels(undefined, options.env, options.environmentGeneration);
         case "codex":
-            return parseCodexModels((await execFileP("codex", ["debug", "models"])).stdout);
+            return parseCodexModels((await execFileP("codex", ["debug", "models"], options.env)).stdout);
         case "cursor":
-            return parseCursorModels((await execFileP("cursor-agent", ["--list-models"])).stdout);
+            return parseCursorModels((await execFileP("cursor-agent", ["--list-models"], options.env)).stdout);
         case "hermes":
             return listHermesModels(options);
         case "opencode":
-            return listOpencodeModels();
+            return listOpencodeModels(options.env);
         case "pi":
-            return parsePiModels((await execFileP("pi", ["--list-models"])).stdout);
+            return parsePiModels((await execFileP("pi", ["--list-models"], options.env)).stdout);
         default:
             return null;
     }
@@ -84,9 +84,9 @@ function parseCursorModels(stdout) {
         return { id: id.trim(), label: (label || id).trim(), ...(index === 0 ? { default: true } : {}) };
     });
 }
-async function outputEvenOnFailure(bin, args) {
+async function outputEvenOnFailure(bin, args, env) {
     try {
-        return (await execFileP(bin, args)).stdout;
+        return (await execFileP(bin, args, env)).stdout;
     }
     catch (error) {
         const stdout = error.stdout;
@@ -97,11 +97,11 @@ async function outputEvenOnFailure(bin, args) {
         return "";
     }
 }
-async function listOpencodeModels() {
-    const verbose = parseOpencodeModels(await outputEvenOnFailure("opencode", ["models", "--verbose"]));
+async function listOpencodeModels(env) {
+    const verbose = parseOpencodeModels(await outputEvenOnFailure("opencode", ["models", "--verbose"], env));
     if (verbose.length > 0)
         return verbose;
-    return parseOpencodeModels(await outputEvenOnFailure("opencode", ["models"]));
+    return parseOpencodeModels(await outputEvenOnFailure("opencode", ["models"], env));
 }
 const VARIANT_ORDER = new Map([
     ["none", 0], ["minimal", 1], ["low", 2], ["medium", 3],

package/dist/local-execution-lease.js

@@ -0,0 +1,22 @@
+import { awaitWithCancellation } from "./runtime-cancellation.js";
+const leaseTails = new Map();
+/** 同一进程内的短操作或原生会话排队；等待取消也不会越过前一位持有者。 */
+export async function withKeyedLease(key, operation, cancellation) {
+    const predecessor = leaseTails.get(key) ?? Promise.resolve();
+    // 解锁函数在等待 predecessor 前可用，保留取消等待时的队列顺序。
+    let unlock;
+    const current = new Promise(resolve => { unlock = resolve; });
+    const queued = predecessor.then(() => current);
+    leaseTails.set(key, queued);
+    try {
+        await awaitWithCancellation(predecessor, cancellation);
+        return await operation();
+    }
+    finally {
+        unlock();
+        void queued.then(() => {
+            if (leaseTails.get(key) === queued)
+                leaseTails.delete(key);
+        });
+    }
+}

package/dist/local-executor.js

@@ -1,22 +1,26 @@
+import { deepSeekHarnessLauncher } from "./runtimes/deepseek-harness.js";
+import { buildLocalRuntimeEnvironment } from "./local-runtime-environment.js";
+import { environmentForExecution } from "./agent-environments.js";
+import { prepareEnvironmentExecutionSnapshot } from "./agent-environment-execution.js";
 import { createInterface } from "node:readline";
 import { readFile, rm, writeFile } from "node:fs/promises";
-import { delimiter, join } from "node:path";
+import { 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";
 import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
-import { materializeDefaultCodexHome } from "./runtimes/codex-home.js";
-import { materializePrivateCodexHome } from "./codex-home-launch.js";
-import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
+import { spawnKimi } from "./runtimes/kimi.js";
 import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, } from "./provider-env.js";
-import { augmentedPath } from "./runtime-path.js";
 import { deliverCloudReports, prepareCloudReportExecution } from "./cloud-report-uploader.js";
 import { reportDeliveryContext } from "./cloud-report-receipt.js";
 import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
 import { NativeThreadContext, isolateMaintenanceSession } from "./native-thread-context.js";
 import { prepareThreadDelivery } from "./thread-input-delivery.js";
+import { resolveMemoryPruneWorkLog, workLogSha256 } from "./local-memory/work-log.js";
+import { withKeyedLease } from "./local-execution-lease.js";
+import { withWorkLogExecution, withWorkLogCommit, workLogExecutionKey } from "./local-memory/work-log-execution.js";
 import { providerErrorFromExit } from "./provider-error.js";
 import { createConsoleFormatter } from "./console-formatter.js";
 import { withLocalExecutionFacts, } from "./local-execution-prompt.js";
@@ -37,11 +41,11 @@ 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 } from "./package-manager-env.js";
 import { logRuntimeEnvironmentContract } from "./runtime-environment-telemetry.js";
-import { sanitizeEnvVars } from "./runtime-env.js";
 import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
 import { prepareLocalMemoryPrompt } from "./local-memory/prompt.js";
+import { reportLocalMemoryV2Deferred, resolveLocalMemoryV2Rollout } from "./local-memory/rollout.js";
+import { localMemoryV2Environment } from "./config.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -159,28 +163,12 @@ async function launchLegacyRuntime(request) {
 function resolvePrompt(prompt, context) {
     return typeof prompt === "string" ? prompt : prompt(context);
 }
-const nativeSessionLeaseTails = new Map();
 const activeMemoryPrunes = new Map();
-async function withKeyedLease(key, operation, cancellation) {
-    const predecessor = nativeSessionLeaseTails.get(key) ?? Promise.resolve();
-    let release;
-    const current = new Promise((resolve) => { release = resolve; });
-    const tail = predecessor.then(() => current);
-    nativeSessionLeaseTails.set(key, tail);
-    try {
-        await awaitWithCancellation(predecessor, cancellation);
-        return await operation();
-    }
-    finally {
-        release();
-        void tail.then(() => {
-            if (nativeSessionLeaseTails.get(key) === tail)
-                nativeSessionLeaseTails.delete(key);
-        });
-    }
-}
 export async function executeLocal(input, callbacks = {}, dependencies = {}) {
     input = isolateMaintenanceSession(input);
+    return withWorkLogExecution(workLogExecutionKey(input.launch.agentsRoot, input.handle, input.taskKey), () => executeLocalWithSession(input, callbacks, dependencies), dependencies.cancellation);
+}
+async function executeLocalWithSession(input, callbacks, dependencies) {
     const versionedProjectSkills = input.projectSkills !== undefined
         && !Array.isArray(input.projectSkills);
     if (versionedProjectSkills && (input.runtime.name !== "codex" && input.runtime.name !== "claude")) {
@@ -248,7 +236,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }, "workspace_prepare", error);
         throw error;
     }
-    const localMemoryV2Initialized = await initializeLocalMemoryV2ForWorkspace(workspace, input.localMemoryV2Enabled === true);
+    const memoryRollout = await resolveLocalMemoryV2Rollout({ workspace, handle: input.handle,
+        serverUrl: input.launch.serverUrl, requested: input.localMemoryV2Enabled === true,
+        selfTraining: isolatedMaintenance, ...(input.launch.description ? { description: input.launch.description } : {}) });
+    workspace = { ...workspace, localMemoryV2Enabled: memoryRollout.enabled };
+    input = { ...input, localMemoryV2Enabled: memoryRollout.enabled };
+    const localMemoryV2Initialized = await initializeLocalMemoryV2ForWorkspace(workspace, memoryRollout.enabled);
     let materialized = null;
     let knownAttachmentDirectory = null;
     const startupReservationState = { current: null };
@@ -259,10 +252,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let memoryPruneBeforeSnapshot = null;
     let memoryPruneSharedWriteKey = null;
     let localMemoryResultPath = null;
+    let environmentSnapshot;
     let executionWorkspace = workspace;
     let localMemoryTelemetry = null;
     let nativeThreadContext = null;
-    const inheritedEnv = { ...process.env };
+    const machineSnapshot = dependencies.machineEnvironment ? await awaitWithCancellation(dependencies.machineEnvironment.acquire(), dependencies.cancellation) : undefined;
+    const inheritedEnv = { ...(machineSnapshot?.env ?? process.env) };
     const reportRoots = {
         root: workspace.dir,
         ...(input.launch.qaReportRoot === undefined ? {} : { qaReportRoot: input.launch.qaReportRoot }),
@@ -274,8 +269,6 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         if (key.startsWith("CREW_AGENT_MEMORY_") || ["CREW_CLOUD_PROVIDER", "CREW_OSS_UPLOAD_SCRIPT", "CREW_OSS_REPORT_UPLOAD"].includes(key))
             delete inheritedEnv[key];
     }
-    const sourceCodexHome = inheritedEnv.CODEX_HOME
-        ?? (inheritedEnv.HOME === undefined ? undefined : join(inheritedEnv.HOME, ".codex"));
     let materializedDeepSeekHome;
     try {
         if (isDeepSeekCodex && !providerConfig.providerApiKey) {
@@ -356,8 +349,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const launchSessionId = resumeSessionId ?? (rotated
             ? await rotateAgentSession(workspace.sessionDir)
             : workspace.agentSessionId);
-        await materializePrivateCodexHome({ runtime: runtime.name, homeDir: workspace.homeDir, ...(input.launch.codexHomeMode === undefined ? {} : { mode: input.launch.codexHomeMode }), ...(sourceCodexHome === undefined ? {} : { sourceHome: sourceCodexHome }), ...(launchSessionId === undefined ? {} : { sessionId: launchSessionId }), ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }), ...(dependencies.materializeDefaultCodexHome === undefined ? {} : { materialize: dependencies.materializeDefaultCodexHome }) });
-        const promptContext = {
+        let promptContext = {
             workspace: executionWorkspace,
             resuming,
             rotatedForBudget,
@@ -396,8 +388,15 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             }
         }
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
-        const baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
-        memoryPruneTraceId = parseMemoryPruneTraceId(baseWakePrompt);
+        let baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
+        memoryPruneTraceId = isolatedMaintenance ? null : parseMemoryPruneTraceId(baseWakePrompt);
+        if (memoryRollout.deferred)
+            reportLocalMemoryV2Deferred(input.executionId, input.handle, memoryPruneTraceId !== null || input.maintenancePurpose === "memory_prune");
+        if (memoryPruneTraceId !== null) {
+            executionWorkspace = await resolveMemoryPruneWorkLog(executionWorkspace, input);
+            promptContext = { ...promptContext, workspace: executionWorkspace };
+            baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
+        }
         if (input.localMemoryV2Enabled === true && memoryPruneTraceId !== null
             && isLocalMemoryV2Eligible({
                 enabledForHandle: true,
@@ -412,6 +411,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             agentDir: executionWorkspace.dir, executionId: input.executionId, agentHandle: input.handle,
             enabled: input.localMemoryV2Enabled === true, query: baseWakePrompt,
             resultPath: localMemoryResultPath, maxBytes: input.maxSystemPromptBytes,
+            strictRollout: !isolatedMaintenance && localMemoryV2Environment(input.launch.serverUrl) === "dev",
+            deferred: memoryRollout.deferred,
             renderBase: (reservedPromptBytes) => resolvePrompt(input.systemPrompt, { ...promptContext, reservedPromptBytes }),
         });
         localMemoryResultPath = memoryPrompt.resultPath;
@@ -480,48 +481,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             nativeThreadContext = new NativeThreadContext(join(executionWorkspace.runDir, `.crew-context-${input.executionId}.json`), contextThreadId, runtime.name, resumeSessionId, prior);
             await nativeThreadContext.initialize();
         }
-        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: crewHome,
-            // Empty values override any stale inherited hints from an enclosing runtime.
-            CREW_THREAD_ROOT: contextThreadId ?? "",
-            CREW_THREAD_CONTEXT_FILE: nativeThreadContext?.path ?? "",
-            // 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
-            // owned by the training package rather than the NowWork daemon.
-            QA_RUNTIME_ROOT: join(crewHome, "training"),
-            QA_REPORT_DELIVERY_CONTEXT: JSON.stringify(reportContext),
-            CREW_TASK_DIR: executionWorkspace.runDir,
-            CREW_TASK_LOG: executionWorkspace.workLogPath,
-            ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
-            XDG_CONFIG_HOME: join(workspace.homeDir, ".config"),
-            XDG_DATA_HOME: join(workspace.homeDir, ".local", "share"),
-            XDG_CACHE_HOME: join(workspace.homeDir, ".cache"),
-            GH_CONFIG_DIR: join(workspace.homeDir, ".config", "gh"),
-            CLOUDSDK_CONFIG: join(workspace.homeDir, ".config", "gcloud"),
-            ...(runtime.name === "kimi" && runtime.reasoning
-                && KIMI_EFFORT_LEVELS.includes(runtime.reasoning)
-                ? { KIMI_MODEL_THINKING_EFFORT: runtime.reasoning }
-                : {}),
-        };
-        const providerEnv = applyProviderEnv(baseEnv, runtime.name, input.launch.codexHomeMode === undefined
-            ? providerConfig
-            : { ...providerConfig, codexHomeMode: input.launch.codexHomeMode }, workspace.homeDir, materializedDeepSeekHome);
+        const baseEnv = buildLocalRuntimeEnvironment({ input, workspace, executionWorkspace, inheritedEnv, providerConfig,
+            crewHome, contextThreadId, nativeThreadContextPath: nativeThreadContext?.path, reportContext, runtime });
+        const providerEnv = applyProviderEnv(baseEnv, runtime.name, providerConfig, workspace.homeDir, materializedDeepSeekHome);
         const childEnv = runtime.name === "deepseek-harness"
             ? applyDeepSeekHarnessMachineEnv(providerEnv, inheritedEnv)
             : providerEnv;
@@ -538,10 +500,15 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const abilityContext = input.abilityRelease !== undefined && dependencies.abilityRelease !== undefined
             ? await dependencies.abilityRelease.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.abilityRelease, async (context) => context)
             : undefined;
+        if (providerConfig.environmentPlan !== undefined && !isolatedMaintenance) {
+            environmentSnapshot = await prepareEnvironmentExecutionSnapshot({ plan: providerConfig.environmentPlan, agentRoot: workspace.dir, runDir: executionWorkspace.runDir, executionId: input.executionId, ambient: inheritedEnv, runtime: runtime.name, providerConfig, runtimeEnvironment: childEnv, authoritativeKeys: Object.keys(input.launch.systemEnv ?? {}),
+                executionBaseEnvironment: childEnv,
+                ...(machineSnapshot === undefined ? {} : { machineEnvironmentVersion: { bootId: machineSnapshot.status.bootId, generation: machineSnapshot.status.generation } }),
+                selectedEnvironment: environmentForExecution(providerConfig.environmentPlan, workspace.dir, input.projectContext?.primary?.root ?? executionWorkspace.runDir, input.projectContext?.primary?.projectId),
+                projectRoots: [...(input.projectContext?.primary ? [input.projectContext.primary] : []), ...(input.projectContext?.secondary ?? [])] });
+        }
         const prepareRuntimeLaunch = async (runtimeRoot) => {
-            const effectiveSystemPrompt = abilityContext === undefined
-                ? systemPrompt
-                : `${systemPrompt}\n\n${abilityContext.prompt}`;
+            const effectiveSystemPrompt = [systemPrompt, abilityContext?.prompt, environmentSnapshot?.prompt].filter(Boolean).join("\n\n");
             if (Buffer.byteLength(effectiveSystemPrompt, "utf8") + Buffer.byteLength(memoryPrompt.wakePromptSuffix, "utf8")
                 > (input.maxSystemPromptBytes ?? Number.MAX_SAFE_INTEGER)) {
                 throw new Error("ability_runtime_context_size_exceeded");
@@ -577,7 +544,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 });
             }
             const trainingRoots = input.trainingProjectContext?.projects.map((project) => project.root) ?? [];
-            const { codexSkillRoots, claudeAdditionalDirectories } = await projectSkillRuntimeDirectories({
+            const { codexSkillRoots, claudeAdditionalDirectories, harnessSkillRoots } = await projectSkillRuntimeDirectories({
                 runtime: runtime.name,
                 ...(runtimeRoot === undefined ? {} : { runtimeRoot }),
                 agentRoot: workspace.dir,
@@ -615,7 +582,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             const workspaceRoots = [...legacyRoots, ...trainingRoots];
             const launchRequest = {
                 runtime: runtime.name,
-                bin: runtime.name === "deepseek-harness" ? "dsh-acp-demo" : runtime.name,
+                bin: runtime.name === "deepseek-harness" ? deepSeekHarnessLauncher(runtimeEnv).bin : runtime.name,
+                ...(runtime.name === "deepseek-harness" ? { harnessStateRoot: executionWorkspace.runDir, harnessSkillRoots: harnessSkillRoots ?? [] } : {}),
                 cwd: input.projectContext?.primary?.root ?? executionWorkspace.runDir,
                 ...(runtimeRoot !== undefined
                     || (input.projectSkills === undefined && input.abilityRelease === undefined)
@@ -731,7 +699,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         // (incident: 2026-09-02, boss-alarm 排查结论未投递)。所有 runtime 的文本都喂给它。
         const externalOutput = new ExternalAnswerDecoder();
         // 每轮独立:tool_use/result 关联状态不能跨 execution 泄漏。
-        const consoleFormatter = createConsoleFormatter();
+        const consoleFormatter = createConsoleFormatter(runtime.name);
         let runtimeReady = false;
         let runtimeRunning = false;
         let resolveRuntimeReady;
@@ -937,14 +905,17 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         memoryPruneRuntimeExitCode = exitCode;
         if (localMemoryResultPath !== null) {
             memoryPruneFailurePhase = "memory_commit";
-            const committed = await commitLocalMemoryResultAfterExit({
-                resultPath: localMemoryResultPath,
+            const resultPath = localMemoryResultPath;
+            const commit = () => commitLocalMemoryResultAfterExit({
+                resultPath,
                 agentDir: executionWorkspace.dir,
                 executionId: input.executionId,
                 pruneTraceId: memoryPruneTraceId,
                 exitCode,
                 workLogPath: executionWorkspace.workLogPath,
+                expectedWorkLogSha256: workLogSha256(executionWorkspace.workLog),
             });
+            const committed = exitCode !== 0 ? await commit() : await withWorkLogCommit(workLogExecutionKey(input.launch.agentsRoot, input.handle, input.taskKey), commit, dependencies.cancellation);
             if (committed.status === "failed" || committed.status === "missing") {
                 const reason = committed.error ?? "local_memory_result_missing";
                 dslog("local_memory.commit_failed", "结构化本地记忆提交或清理未完成，保留可用恢复材料", {
@@ -1122,6 +1093,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 active_prune_count: activePruneCount,
             });
         }
+        if (environmentSnapshot)
+            await rm(environmentSnapshot.directory, { recursive: true, force: true }).catch(() => { });
         const attachmentDirectories = new Set([
             ...(knownAttachmentDirectory === null ? [] : [knownAttachmentDirectory]),
             ...(materialized === null ? [] : [materialized.directory]),

package/dist/local-memory/candidate.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { containsLikelySecret } from "../agent-memory/policy.js";
+const CategorySchema = z.enum([
+    "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
+]);
+export const LocalMemorySingleLineText = z.string().trim().min(1).max(500).regex(/^[^\r\n]+$/u);
+export const LocalMemoryChangeSchema = z.object({
+    operation: z.enum(["create", "update", "supersede"]),
+    memoryId: LocalMemorySingleLineText.regex(/^[^<>]+$/u).nullable(),
+    baseRevision: z.number().int().nonnegative().nullable(),
+    supersedesMemoryId: LocalMemorySingleLineText.regex(/^[^<>]+$/u).nullable(),
+    title: LocalMemorySingleLineText.max(120),
+    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
+    summary: LocalMemorySingleLineText,
+    triggers: z.array(LocalMemorySingleLineText.max(80)).min(1).max(16),
+    priority: z.enum(["high", "medium", "low"]),
+    detailCategory: CategorySchema,
+    detailBody: z.string().trim().min(1).max(12_000),
+    reviewAfter: LocalMemorySingleLineText.nullable(),
+}).strict();
+const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
+const RESERVED_MEMORY_MARKER = /NOWWORK:(?:MEMORY_ENTRY|MEMORY_INDEX):/iu;
+export function validateLocalMemoryChange(change) {
+    const text = [change.title, change.summary, ...change.triggers, change.detailBody].join("\n");
+    if (containsLikelySecret(text))
+        throw new Error("local_memory_secret_candidate");
+    if (CONTROL_CHARACTER_PATTERN.test(text))
+        throw new Error("local_memory_control_character");
+    if (RESERVED_MEMORY_MARKER.test(text))
+        throw new Error("local_memory_reserved_marker");
+    if (change.operation === "create"
+        && (change.memoryId !== null || change.baseRevision !== null || change.supersedesMemoryId !== null)) {
+        throw new Error("local_memory_create_revision_invalid");
+    }
+    if (change.operation === "update"
+        && (change.memoryId === null || change.baseRevision === null || change.supersedesMemoryId !== null)) {
+        throw new Error("local_memory_update_revision_missing");
+    }
+    if (change.operation === "supersede"
+        && (change.memoryId !== null || change.baseRevision === null || change.supersedesMemoryId === null)) {
+        throw new Error("local_memory_supersede_revision_missing");
+    }
+}

package/dist/local-memory/index-budget.js

@@ -19,6 +19,14 @@ export function renderLocalMemoryIndexCard(entry) {
         + `- updated: ${entry.updated}\n`
         + (entry.reviewAfter === null ? "" : `- review_after: ${entry.reviewAfter}\n`);
 }
+/** 写入和预演共用完整索引，预算包含起止标记与分隔换行。 */
+export function renderGeneratedIndex(entries) {
+    const cards = entries
+        .filter(entry => PROJECTABLE_STATUSES.has(entry.status))
+        .map(renderLocalMemoryIndexCard)
+        .join("\n");
+    return `<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=1 -->\n${cards}<!-- NOWWORK:MEMORY_INDEX:END -->`;
+}
 function compareEntries(left, right) {
     const statusRank = (status) => status === "pinned" ? 0 : 1;
     const priorityRank = (priority) => (priority === "high" ? 0 : priority === "medium" ? 1 : 2);

package/dist/local-memory/inventory-cli.js

@@ -0,0 +1,61 @@
+const CommandSchema = z.object({
+    "agent-dir": z.string().min(1).refine(isAbsolute),
+    "dry-run": z.literal(true),
+}).strict();
+const USAGE = "只读记忆盘点与转换预演，不写文件，不支持 --apply。\n"
+    + "pnpm --filter @nowcrew/daemon exec tsx src/local-memory/inventory-cli.ts --agent-dir <单个Agent绝对路径> --dry-run\n"
+    + "报告包含原始记忆，需作为敏感本地资料保存；退出码0仅代表盘点及格式预演无阻塞，不代表批准迁移。\n";
+export async function runMemoryInventoryCommand(args, io) {
+    if (args.length === 1 && args[0] === "--help") {
+        io.out(USAGE);
+        return 0;
+    }
+    let command;
+    try {
+        const parsed = parseArgs({ args, allowPositionals: false, options: {
+                "agent-dir": { type: "string" }, "dry-run": { type: "boolean" },
+            } });
+        command = CommandSchema.parse(parsed.values);
+    }
+    catch {
+        io.err(USAGE);
+        return 2;
+    }
+    try {
+        const scan = await scanMemorySources(command["agent-dir"]);
+        const scanComplete = scan.issues.length === 0;
+        const analysis = previewMemoryInventory(scan.sources, scanComplete);
+        const complete = scanComplete && !analysis.issues.some((issue) => issue.code === "missing_detail");
+        const issues = [...scan.issues, ...analysis.issues];
+        const referenced = new Set(analysis.entries.map((entry) => entry.sourceFields.file));
+        const files = scan.sources.map(({ path, bytes, sha256 }) => ({ path, bytes, sha256 }));
+        const report = {
+            schemaVersion: 1, mode: "dry-run", agentDir: scan.root, applySupported: false,
+            complete, scanComplete, requiresHumanReview: true,
+            coverage: ["MEMORY.md", "notes/**", ".crew/memory/pending/**", "根目录的 .memory-result.v1-*.json"],
+            limitations: ["不扫描历史执行目录；result清单仅覆盖Agent根目录。", "两遍摘要比对不等同跨文件原子快照，正式迁移仍需停止写入并重新核对。"],
+            limits: inventoryLimits, totalBytes: scan.totalBytes, files, ...analysis, issues,
+            pending: files.filter((file) => file.path.startsWith(".crew/memory/pending/")).map((file) => file.path),
+            orphanNotes: files.filter((file) => file.path.startsWith("notes/") && !referenced.has(file.path)).map((file) => file.path),
+            resultFiles: files.filter((file) => file.path.startsWith(".memory-result.v1-")).map((file) => file.path),
+        };
+        io.out(JSON.stringify(report, null, 2) + "\n");
+        return issues.length ? 1 : 0;
+    }
+    catch (error) {
+        const code = error instanceof Error ? error.code ?? error.message : "inventory_failed";
+        io.err(`记忆盘点失败：${code}\n`);
+        return 1;
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+    process.exitCode = await runMemoryInventoryCommand(process.argv.slice(2), {
+        out: (text) => process.stdout.write(text), err: (text) => process.stderr.write(text),
+    });
+}
+import { isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+import { z } from "zod";
+import { inventoryLimits, scanMemorySources } from "./inventory-source.js";
+import { previewMemoryInventory } from "./inventory-preview.js";