@nowcrew/daemon 0.6.101-beta.3 → 0.6.101-beta.5

package/dist/cloud-report-upload.js

@@ -1,6 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir, hostname, platform } from "node:os";
-import { join } from "node:path";
 const ALIYUN_MARKER = /alibaba|aliyun|alicloud/iu;
 function readMarker(path) {
     try {
@@ -29,15 +28,7 @@ export function detectCloudProvider(env = process.env, platformName = platform()
 }
 export function findOssUploadScript(env = process.env, exists = existsSync) {
     const explicit = env.CREW_OSS_UPLOAD_SCRIPT?.trim();
-    if (explicit)
-        return exists(explicit) ? explicit : undefined;
-    const home = env.HOME?.trim() || homedir();
-    const candidates = [
-        join(home, ".claude", "skills", "oss-upload", "scripts", "oss_upload.py"),
-        join(home, ".codex", "skills", "oss-upload", "scripts", "oss_upload.py"),
-        join(home, ".agents", "skills", "oss-upload", "scripts", "oss_upload.py"),
-    ];
-    return candidates.find(exists);
+    return explicit && exists(explicit) ? explicit : undefined;
 }
 export function cloudReportUploadFacts(env = process.env, platformName = platform(), hostName = hostname(), readMarkerValue, exists) {
     const provider = detectCloudProvider(env, platformName, hostName, readMarkerValue);

package/dist/execution-journal-lock.js

@@ -3,10 +3,25 @@ import { renameSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join, resolve } from "node:path";
 import { z } from "zod";
+const ProtectedGroupSchema = z.object({ pid: z.number().int().positive(), processIdentity: z.string().min(1) }).strict();
+export async function inspectProtectedProcessGroup(pid) {
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ESRCH")
+            return false;
+        if (error.code === "EPERM")
+            return true;
+        throw error;
+    }
+}
 const OwnerSchema = z.object({
     pid: z.number().int().positive(),
     processIdentity: z.string().min(1),
     token: z.string().uuid(),
+    protectedGroup: ProtectedGroupSchema.optional(),
 }).strict();
 export class JournalLockedError extends Error {
     journalPath;
@@ -144,7 +159,8 @@ export async function inspectJournalLock(options) {
         let inspection;
         try {
             const identity = await options.inspectIdentity(owner.pid);
-            inspection = identity === owner.processIdentity
+            const protectedAlive = owner.protectedGroup !== undefined && await (options.inspectProcessGroup ?? inspectProtectedProcessGroup)(owner.protectedGroup.pid);
+            inspection = identity === owner.processIdentity || protectedAlive
                 ? {
                     status: "owned",
                     ownerPid: owner.pid,
@@ -333,7 +349,9 @@ export function createJournalLease(options) {
                 if (observed === null)
                     continue;
                 const identity = await options.inspectIdentity(observed.owner.pid);
-                if (identity === observed.owner.processIdentity) {
+                const protectedAlive = observed.owner.protectedGroup !== undefined
+                    && await (options.inspectProcessGroup ?? inspectProtectedProcessGroup)(observed.owner.protectedGroup.pid);
+                if (identity === observed.owner.processIdentity || protectedAlive) {
                     throw new JournalLockedError(`Execution journal is locked by process ${observed.owner.pid}`, { journalPath, ownerPid: observed.owner.pid });
                 }
                 await options.hooks?.beforeRemoveObservedOwner?.(observed.owner);
@@ -408,6 +426,9 @@ export function createJournalLease(options) {
             status = "closed";
             return;
         }
+        if (lease.owner.protectedGroup && await (options.inspectProcessGroup ?? inspectProtectedProcessGroup)(lease.owner.protectedGroup.pid)) {
+            throw new JournalLockedError("Protected maintenance process group is still alive", { journalPath, ownerPid: lease.owner.protectedGroup.pid });
+        }
         status = "closing";
         lease.releasing = true;
         await awaitAbortable((async () => {
@@ -426,8 +447,36 @@ export function createJournalLease(options) {
         status = "closed";
         void cleanupReleasedDirectory(releasedDirectory);
     };
+    const protectProcessGroup = async (raw) => {
+        const group = ProtectedGroupSchema.parse(raw);
+        const lease = registry.get(options.directory);
+        if (!attached || status !== "open" || !lease || lease.releasing || lease.refs !== 1)
+            throw new JournalLockedError("Lease cannot protect a worker", { journalPath });
+        await validateInstalledOwner(lease);
+        if (await options.inspectIdentity(group.pid) !== group.processIdentity
+            || !await (options.inspectProcessGroup ?? inspectProtectedProcessGroup)(group.pid))
+            throw new JournalLockedError("Worker identity is absent", { journalPath });
+        if (lease.owner.protectedGroup) {
+            if (JSON.stringify(lease.owner.protectedGroup) === JSON.stringify(group))
+                return;
+            throw new JournalLockedError("Lease already protects a worker", { journalPath });
+        }
+        const owner = { ...lease.owner, protectedGroup: group };
+        const temp = join(options.directory, `.journal-owner.${lease.owner.token}.${randomUUID()}.tmp`);
+        try {
+            await fileSystem.writeDurableFile(temp, `${JSON.stringify(owner)}\n`);
+            await fileSystem.rename(temp, join(lockDirectory, lease.ownerFile));
+            lease.owner = owner;
+            await options.syncDirectory(lockDirectory);
+            await options.syncDirectory(options.directory);
+        }
+        finally {
+            await fileSystem.rm(temp, { force: true }).catch(() => undefined);
+        }
+    };
     return {
         acquire,
+        protectProcessGroup,
         assertUsable: () => {
             if (status !== "open") {
                 throw new JournalLockedError(`Execution journal lease is ${status}`, { journalPath });

package/dist/execution-journal.js

@@ -8,7 +8,7 @@ import { provePosixProcessGroupStopped } from "./execution-posix-stop-proof.js";
 export { JournalLockedError, JournalLockCorruptionError } from "./execution-journal-lock.js";
 const ExecutionIdSchema = z.string().uuid();
 const TimestampSchema = z.string().datetime({ offset: true });
-const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness", "pi"]);
+const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness", "memory_migration", "pi"]);
 const RUNTIME_READY_SUFFIX = ".runtime-ready";
 const RawJournalEntrySchema = z.object({
     executionId: ExecutionIdSchema,
@@ -523,6 +523,8 @@ export function createExecutionJournal(agentsRoot, options = {}) {
         }
     };
     const pruneInternal = async () => {
+        if (options.retainCompleted)
+            return;
         const protectedExecutionIds = new Set(options.protectedExecutionIds?.() ?? []);
         const entries = await readAll();
         const acknowledged = entries

package/dist/execution-protocol.js

@@ -319,7 +319,7 @@ const RawExecutionCompletedSchema = z.object({
     providerErrorCategory: ProviderErrorCategorySchema.optional(),
     providerHttpStatus: ProviderHttpStatusSchema.optional(),
     providerErrorCode: ProviderErrorCodeSchema.optional(),
-    runtime: RuntimeSchema,
+    runtime: z.union([RuntimeSchema, z.literal("memory_migration")]),
     model: z.string().optional(),
     resumed: z.boolean(),
     finalText: z.string().optional(),

package/dist/execution-runner.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
 import { isLocalMemoryV2Enabled, localMemoryV2Environment, resolveReposRoot } from "./config.js";
+import { detectLocalMemoryStorageVersion } from "./local-memory/storage-format.js";
 import { DaemonToServerExecutionFrameSchema, ExecutionCompletedSchema, ExecutionRejectedSchema, ExecutionStartSchema, } from "./execution-protocol.js";
 import { JournalConflictError } from "./execution-journal.js";
 import { boundExecutionFrame } from "./execution-event-limit.js";
@@ -846,8 +847,9 @@ export async function runExecution(config, input, dependencies) {
         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, {
+            const systemPromptWithLocalFacts = withLocalExecutionFacts(`${spec.instructions.systemPrompt}${enabled && localMemoryGuardInBase && detectLocalMemoryStorageVersion(context.workspace.memory) !== 2 ? renderLocalMemoryV2WriteGuard() : ""}`, baseSystemPromptBudget, {
                 ...(selfTraining ? { isolateLocalMemory: true } : {}),
+                memoryQuery: spec.instructions.wakePrompt,
                 collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex",
             });
             const base = typeof systemPromptWithLocalFacts === "string"
@@ -887,6 +889,7 @@ export async function runExecution(config, input, dependencies) {
                 serverUrl: config.serverUrl,
                 token: credential.token,
                 agentId: credential.agentId,
+                ...(dependencies.controlIdentity === undefined ? {} : dependencies.controlIdentity),
                 agentsRoot: config.agentsRoot,
                 reposRoot: resolveReposRoot(config.agentsRoot, config.reposRoot),
                 ...(config.qaReportRoot === undefined ? {} : { qaReportRoot: config.qaReportRoot }),

package/dist/host-execution-coordinator.js

@@ -302,6 +302,16 @@ export function createHostExecutionCoordinator(options = {}) {
             }
             let releasePromise = null;
             return {
+                protectProcessGroup: async (pid) => {
+                    const processIdentity = await defaultProcessController.inspectIdentity(pid);
+                    if (processIdentity === null)
+                        throw new Error("maintenance worker identity is absent");
+                    for (const lease of leases) {
+                        if (!lease.protectProcessGroup)
+                            throw new Error("lease process-group protection is unavailable");
+                        await lease.protectProcessGroup({ pid, processIdentity });
+                    }
+                },
                 release: () => {
                     if (releasePromise !== null)
                         return releasePromise;

package/dist/local-execution-prompt.js

@@ -2,8 +2,9 @@
  * 本机执行提示词的合成与预算裁剪。
  *
  * server 提示词是权威部分,绝不裁剪;项目工作区提示词是绑定执行的强制部分,放不下就直接失败;
- * 只有本机事实(CREW_HOME / work-log / MEMORY 注入)是可选增强,按整段丢弃或按字节截断。
+ * 本机事实与旧格式预览可按预算省略；schema2身份和置顶规则必须保留，放不下则拒绝执行。
  */
+import { detectLocalMemoryStorageVersion } from "./local-memory/storage-format.js";
 import { buildCollaborationToolsPrompt, buildRuntimeWorkspacePrompt, capMemoryForInject, capWorkLogForInject, } from "./prompt.js";
 const trainingProjectJson = (project) => JSON.stringify({
     repositoryKey: project.repositoryKey,
@@ -57,10 +58,14 @@ export function withLocalExecutionFacts(serverPrompt, maxBytes, options = {}) {
         }
         const remaining = maxBytes - requiredBytes - Math.max(0, reservedPromptBytes);
         const factsBytes = Buffer.byteLength(localFacts, "utf8");
-        if (factsBytes > remaining)
+        if (factsBytes > remaining) {
+            if (!options.isolateLocalMemory && detectLocalMemoryStorageVersion(workspace.memory) === 2) {
+                throw new Error("local_memory_identity_budget_exceeded");
+            }
             return `${serverPrompt}${collaborationPrompt}${mandatoryWorkspacePrompt}`;
+        }
         const memoryHeading = "\n\n## Injected MEMORY.md (bounded local context)\n";
-        const memory = options.isolateLocalMemory ? "" : capMemoryForInject(workspace.memory, undefined, remaining - factsBytes - Buffer.byteLength(memoryHeading, "utf8"));
+        const memory = options.isolateLocalMemory ? "" : capMemoryForInject(workspace.memory, undefined, remaining - factsBytes - Buffer.byteLength(memoryHeading, "utf8"), options.memoryQuery);
         const memorySection = memory === "" ? "" : memoryHeading + memory;
         const workLogSection = workLog === "" ? "" : `\n\n## Injected work-log (bounded local context)\n${workLog}`;
         const workLogBudget = remaining - factsBytes - Buffer.byteLength(memorySection, "utf8");

package/dist/local-executor.js

@@ -6,7 +6,7 @@ import { createInterface } from "node:readline";
 import { readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { cleanupSelfTrainingRunDir } from "./self-training-workspace.js";
-import { prepareWorkspace, rotateAgentSession, safeKey, } from "./workspace.js";
+import { 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";
@@ -38,14 +38,22 @@ import { formatProjectSkillRuntimeWarning } from "./project-skills/runtime-warni
 import { projectSkillRuntimeDirectories, } from "./project-skills/runtime-launch.js";
 import { logIdentityRosterRuntimePrepared } from "./identity-roster-telemetry.js";
 import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, logMemoryPruneDiagnosticsFailure, memoryPruneSnapshotFields, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
+import { checkReleaseArtifactGuardBeforeCommit, throwReleaseArtifactGuardFailure } from "./local-memory/release-artifact-guard.js";
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
+import { LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS } from "./local-memory-diagnostics.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
 import { formatRuntimeStartupError } from "./runtime-startup-error.js";
 import { logRuntimeEnvironmentContract } from "./runtime-environment-telemetry.js";
-import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
+import { commitLocalMemoryResultAfterExit, 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 { reportLocalMemoryV2Deferred } from "./local-memory/rollout.js";
+import { prepareExecutionMemoryWorkspace } from "./local-memory/execution-workspace.js";
 import { localMemoryV2Environment } from "./config.js";
+import { detectLocalMemoryStorageVersion } from "./local-memory/storage-format.js";
+import { MEMORY_STATE_GUARD_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY } from "./memory-migration-protocol.js";
+import { resolveLocalMemoryWriterMode } from "./local-memory/writer-mode.js";
+import { logLocalMemoryCommitApplied } from "./local-memory/commit-telemetry.js";
+import { shouldUseMigrationDeferredPending } from "./local-memory/migration-pending.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -59,7 +67,6 @@ const STDERR_TAIL_CAP = 2_000;
 // the old failure mode where a callback could hold execution slots forever.
 const RUNTIME_RUNNING_CALLBACK_TIMEOUT_MS = 30_000;
 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";
 function withoutClaudeInstructionFlag(env) {
@@ -211,37 +218,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             : "high"
         : runtime.reasoning;
     const providerFp = providerFingerprint(runtime.name, providerConfig);
-    let workspace;
-    try {
-        workspace = await awaitWithCancellation(prepareWorkspace({
-            agentsRoot: input.launch.agentsRoot,
-            handle: input.handle,
-            cliPath: input.launch.cliPath,
-            executionId: input.executionId,
-            ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
-            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-            ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
-            ...(input.sessionContextFingerprint === undefined
-                ? {}
-                : { sessionContextFingerprint: input.sessionContextFingerprint }),
-            ...(input.launch.description ? { description: input.launch.description } : {}),
-            ...(isolatedMaintenance ? { skipLocalMemory: true } : {}),
-        }), dependencies.cancellation);
-    }
-    catch (error) {
-        logLocalMemoryContextPrepareFailure({
-            executionId: input.executionId,
-            agentHandle: input.handle,
-            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-        }, "workspace_prepare", error);
-        throw error;
-    }
-    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 };
+    const preparedMemory = await prepareExecutionMemoryWorkspace(input, isolatedMaintenance, dependencies.cancellation);
+    let workspace = preparedMemory.workspace;
+    const memoryRollout = preparedMemory.mode;
     input = { ...input, localMemoryV2Enabled: memoryRollout.enabled };
-    const localMemoryV2Initialized = await initializeLocalMemoryV2ForWorkspace(workspace, memoryRollout.enabled);
+    const localMemoryV2Initialized = preparedMemory.initialized;
+    let localMemoryWriterMode = resolveLocalMemoryWriterMode(workspace, memoryRollout);
     let materialized = null;
     let knownAttachmentDirectory = null;
     const startupReservationState = { current: null };
@@ -252,6 +234,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let memoryPruneBeforeSnapshot = null;
     let memoryPruneSharedWriteKey = null;
     let localMemoryResultPath = null;
+    let migrationDeferredPending = false;
     let environmentSnapshot;
     let executionWorkspace = workspace;
     let localMemoryTelemetry = null;
@@ -390,29 +373,41 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
         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");
+        localMemoryWriterMode = resolveLocalMemoryWriterMode(executionWorkspace, memoryRollout);
+        migrationDeferredPending = shouldUseMigrationDeferredPending({ pruneTraceId: memoryPruneTraceId,
+            writerMode: localMemoryWriterMode, rolloutEnabled: memoryRollout.enabled,
+            legacyFallback: memoryRollout.legacyFallback,
+            failure: memoryRollout.failure, memory: executionWorkspace.memory });
+        if (memoryRollout.deferred || migrationDeferredPending)
+            reportLocalMemoryV2Deferred(input.executionId, input.handle, memoryPruneTraceId !== null || input.maintenancePurpose === "memory_prune", memoryRollout.legacyFallback, memoryRollout.failure, migrationDeferredPending);
+        if (memoryPruneTraceId !== null && localMemoryWriterMode === "blocked" && !migrationDeferredPending) {
+            throw new Error(memoryRollout.failure === "inspection_failed" ? "local_memory_inspection_failed" : "local_memory_v2_requires_migration");
+        }
         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
+        if ((localMemoryWriterMode === "v2" && memoryPruneTraceId !== null
             && isLocalMemoryV2Eligible({
                 enabledForHandle: true,
                 agentHomePreexisted: workspace.agentHomePreexisted === true,
                 memorySeedCreated: executionWorkspace.memorySeedCreated === true && (localMemoryV2Initialized || workspace.localMemoryV2Initialized !== false),
                 localMemoryV2Initialized,
                 memoryPrune: true,
-            })) {
+            })) || migrationDeferredPending) {
             localMemoryResultPath = makeLocalMemoryResultPath(executionWorkspace.runDir, input.executionId);
         }
         const memoryPrompt = await prepareLocalMemoryPrompt({
             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",
+            storageVersion: detectLocalMemoryStorageVersion(executionWorkspace.memory),
+            strictRollout: !isolatedMaintenance && !memoryRollout.legacyFallback && (localMemoryV2Environment(input.launch.serverUrl) === "dev"
+                || detectLocalMemoryStorageVersion(executionWorkspace.memory) === 2),
             deferred: memoryRollout.deferred,
+            ...(memoryRollout.legacyFallback ? { legacyFallback: true } : {}),
+            ...(migrationDeferredPending ? { migrationDeferred: true } : {}),
             renderBase: (reservedPromptBytes) => resolvePrompt(input.systemPrompt, { ...promptContext, reservedPromptBytes }),
         });
         localMemoryResultPath = memoryPrompt.resultPath;
@@ -528,6 +523,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             localMemoryTelemetry?.contextPrepared({
                 systemPrompt: effectiveSystemPrompt,
                 memory: executionWorkspace.memory,
+                memoryQuery: baseWakePrompt,
                 resumed: resuming,
                 ...(executionWorkspace.memorySeedCreated === undefined
                     ? {}
@@ -901,15 +897,21 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         if (localMemoryResultPath !== null) {
             memoryPruneFailurePhase = "memory_commit";
             const resultPath = localMemoryResultPath;
-            const commit = () => commitLocalMemoryResultAfterExit({
-                resultPath,
-                agentDir: executionWorkspace.dir,
-                executionId: input.executionId,
-                pruneTraceId: memoryPruneTraceId,
-                exitCode,
-                workLogPath: executionWorkspace.workLogPath,
-                expectedWorkLogSha256: workLogSha256(executionWorkspace.workLog),
-            });
+            const commit = async () => {
+                if (exitCode === 0) {
+                    const releaseGuard = await checkReleaseArtifactGuardBeforeCommit({ runDir: executionWorkspace.runDir, scopeKey: memoryPruneTraceId, before: memoryPruneBeforeSnapshot, inspectAfter: () => inspectMemoryPruneFilesWithinDeadline(executionWorkspace.dir, executionWorkspace.runDir, executionWorkspace.workLogPath, dependencies.memoryPruneDiagnosticsTimeoutMs ?? MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS) });
+                    if (releaseGuard.blocked) {
+                        memoryPruneFailurePhase = "memory_artifact_guard";
+                        throwReleaseArtifactGuardFailure({ result: releaseGuard, executionId: input.executionId,
+                            agentHandle: input.handle, taskKey: input.taskKey, pruneTraceId: memoryPruneTraceId });
+                    }
+                }
+                return commitLocalMemoryResultAfterExit({ resultPath, agentDir: executionWorkspace.dir, executionId: input.executionId,
+                    pruneTraceId: memoryPruneTraceId, exitCode, workLogPath: executionWorkspace.workLogPath,
+                    expectedWorkLogSha256: workLogSha256(executionWorkspace.workLog),
+                    ...(localMemoryWriterMode === "v2" ? { writerCapabilities: [MEMORY_STORAGE_V2_CAPABILITY, MEMORY_STATE_GUARD_CAPABILITY], requiredStorageVersion: 2 } : {}),
+                    ...(migrationDeferredPending ? { migrationDeferredPending: true } : {}) });
+            };
             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";
@@ -922,6 +924,14 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 });
                 throw new Error(`local_memory_commit_failed: ${reason}`);
             }
+            if (committed.status === "applied") {
+                if (localMemoryWriterMode === "v2" && (committed.storageVersionBefore !== 2 || committed.storageVersionAfter !== 2
+                    || committed.committedState !== true)) {
+                    throw new Error("local_memory_commit_failed: local_memory_v2_commit_state_invalid");
+                }
+                logLocalMemoryCommitApplied({ executionId: input.executionId, agentHandle: input.handle,
+                    pruneTraceId: memoryPruneTraceId, committed });
+            }
             memoryPruneFailurePhase = "runtime_finalize";
         }
         const errorTail = [
@@ -962,13 +972,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 await writeFile(legacyCwdMarker, "1", "utf8");
             }
         }
-        const externalAnswer = runtime.name === "pi"
-            ? externalOutput.lastClosedBlock
-            : externalOutput.lastClosedBlock
-                ?? (finalText === null ? null : extractExternalAnswer(finalText));
-        const reportFinalText = runtime.name === "pi" && externalAnswer === null
-            ? null
-            : finalText;
+        const externalAnswer = runtime.name === "pi" ? externalOutput.lastClosedBlock : externalOutput.lastClosedBlock
+            ?? (finalText === null ? null : extractExternalAnswer(finalText));
+        const reportFinalText = runtime.name === "pi" && externalAnswer === null ? null : finalText;
         const cloudReportResult = exitCode === 0
             ? await deliverCloudReports({
                 facts: cloudReportUpload, ...reportRoots, before: reportSnapshot, finalText: reportFinalText,
@@ -1052,6 +1058,23 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                         after_incomplete_file_count: noteDiff.after_manifest.incomplete_file_count,
                         changes: serializedChanges.json,
                     });
+                    const pendingDiff = diffMemoryPruneNotes(memoryPruneBeforeSnapshot.pending_manifest
+                        ?? { files: [], total_count: 0, omitted_count: 0, truncated: false }, snapshot.pending_manifest
+                        ?? { files: [], total_count: 0, omitted_count: 0, truncated: false });
+                    const serializedPendingChanges = boundedDiagnosticJsonArray(pendingDiff.changes);
+                    const pendingChangesTruncated = pendingDiff.truncated || serializedPendingChanges.truncated;
+                    dslog("memory_prune.pending_changed", "长期记忆 pending 候选变化已评估", {
+                        execution_id: input.executionId,
+                        agent_handle: input.handle,
+                        task_key: input.taskKey,
+                        prune_trace_id: memoryPruneTraceId,
+                        change_count: pendingDiff.change_count,
+                        changes_truncated: pendingChangesTruncated,
+                        evidence_complete: pendingDiff.evidence_complete && !pendingChangesTruncated,
+                        before_total_count: pendingDiff.before_manifest.total_count,
+                        after_total_count: pendingDiff.after_manifest.total_count,
+                        changes: serializedPendingChanges.json,
+                    });
                     const postcondition = evaluateMemoryPrunePostcondition(memoryPruneBeforeSnapshot, snapshot, {
                         executorCompleted: memoryPruneExecutorCompleted,
                         ...(memoryPruneRuntimeExitCode === undefined

package/dist/local-memory/commit-telemetry.js

@@ -0,0 +1,30 @@
+import { dslog } from "../slog.js";
+function boundedIds(ids) {
+    return {
+        value: (ids ?? []).slice(0, 100).join(","),
+        count: ids?.length ?? 0,
+        truncated: (ids?.length ?? 0) > 100,
+    };
+}
+export function logLocalMemoryCommitApplied(input) {
+    const { committed } = input;
+    const created = boundedIds(committed.createdIds);
+    const updated = boundedIds(committed.updatedIds);
+    const statusChanged = boundedIds(committed.statusChangedIds);
+    const pending = boundedIds(committed.pendingIds);
+    dslog("local_memory.commit_applied", "结构化本地记忆提交已验证", {
+        execution_id: input.executionId, agent_handle: input.agentHandle, prune_trace_id: input.pruneTraceId,
+        storage_version_before: committed.storageVersionBefore,
+        storage_version_after: committed.storageVersionAfter,
+        committed_state: committed.committedState,
+        writer_mode: committed.pendingReason === "legacy_requires_migration"
+            ? "pending_only"
+            : committed.storageVersionAfter === 2 && committed.committedState ? "v2" : "legacy",
+        created_id_count: created.count, created_ids: created.value, created_ids_truncated: created.truncated,
+        updated_id_count: updated.count, updated_ids: updated.value, updated_ids_truncated: updated.truncated,
+        status_changed_id_count: statusChanged.count, status_changed_ids: statusChanged.value,
+        status_changed_ids_truncated: statusChanged.truncated,
+        pending_id_count: pending.count, pending_ids: pending.value, pending_ids_truncated: pending.truncated,
+        pending_reason: committed.pendingReason,
+    });
+}

package/dist/local-memory/execution-workspace.js

@@ -0,0 +1,117 @@
+import { LocalMemoryWorkspacePrepareError, prepareWorkspace } from "../workspace.js";
+import { awaitWithCancellation } from "../runtime-cancellation.js";
+import { logLocalMemoryContextDegraded, logLocalMemoryContextPrepareFailure } from "../local-memory-telemetry.js";
+import { resolveLocalMemoryV2Rollout } from "./rollout.js";
+import { initializeLocalMemoryV2ForWorkspace } from "./runtime.js";
+import { withMemoryAccess } from "./migration-access.js";
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+// A fresh Agent may receive the daemon's full ten-wide execution burst.  The
+// first turn publishes schema2 durably; the remaining turns must wait to reuse
+// that committed fact instead of timing out on the generic short IO window.
+const EXECUTION_MEMORY_ACCESS_WAIT_MS = 30_000;
+function errorCode(error) {
+    const code = error?.code;
+    return typeof code === "string" ? code : error instanceof Error ? error.message : undefined;
+}
+function canSafelyDisableLocalMemory(error) {
+    if (error instanceof Error && error.name === "RuntimeCancelledError")
+        return false;
+    const code = errorCode(error);
+    if (code === undefined)
+        return false;
+    if (code === "memory_migration_access_busy"
+        || code === "memory_migration_in_progress"
+        || code === "memory_migration_path_invalid"
+        || code === "memory_migration_process_unknown"
+        || code === "local_memory_v2_initialization_residue_invalid")
+        return false;
+    return error instanceof LocalMemoryWorkspacePrepareError
+        || code.startsWith("local_memory_v2_initialization_")
+        || code.startsWith("memory_migration_")
+        || code.startsWith("migration_");
+}
+async function prepareWithoutLocalMemory(input, cancellation) {
+    const workspace = await awaitWithCancellation(prepareWorkspace({
+        agentsRoot: input.launch.agentsRoot, handle: input.handle, cliPath: input.launch.cliPath,
+        executionId: input.executionId,
+        ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
+        ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+        ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
+        ...(input.sessionContextFingerprint === undefined ? {} : { sessionContextFingerprint: input.sessionContextFingerprint }),
+        ...(input.launch.description ? { description: input.launch.description } : {}),
+        skipLocalMemory: true,
+    }), cancellation);
+    return {
+        workspace: {
+            ...workspace,
+            memory: "",
+            localMemoryV2Initialized: false,
+            localMemoryV2Enabled: false,
+        },
+        mode: { enabled: false, deferred: true, failure: "inspection_failed" },
+        initialized: false,
+    };
+}
+export async function prepareExecutionMemoryWorkspace(input, isolated, cancellation) {
+    try {
+        const prepare = async (context) => {
+            const prepared = await prepareWorkspace({
+                agentsRoot: input.launch.agentsRoot, handle: input.handle, cliPath: input.launch.cliPath,
+                executionId: input.executionId,
+                ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
+                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+                ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
+                ...(input.sessionContextFingerprint === undefined ? {} : { sessionContextFingerprint: input.sessionContextFingerprint }),
+                ...(input.launch.description ? { description: input.launch.description } : {}),
+                ...(isolated ? { skipLocalMemory: true } : {}),
+            });
+            const workspace = context?.created ? { ...prepared, agentHomePreexisted: false } : prepared;
+            const initialMode = await resolveLocalMemoryV2Rollout({ workspace, handle: input.handle, serverUrl: input.launch.serverUrl,
+                agentId: input.launch.agentId, requested: input.localMemoryV2Enabled === true, selfTraining: isolated,
+                ...(input.launch.description ? { description: input.launch.description } : {}) });
+            const initializationBinding = input.launch.workspaceId !== undefined && input.launch.machineId !== undefined
+                ? { workspaceId: input.launch.workspaceId, machineId: input.launch.machineId }
+                : undefined;
+            const initialized = await initializeLocalMemoryV2ForWorkspace(workspace, initialMode.enabled, input.launch.agentId, initializationBinding);
+            const memory = initialized && !workspace.localMemoryV2Initialized
+                ? await readFile(join(workspace.dir, "MEMORY.md"), "utf8")
+                : workspace.memory;
+            const currentWorkspace = { ...workspace, memory };
+            const mode = initialized && !workspace.localMemoryV2Initialized
+                ? await resolveLocalMemoryV2Rollout({ workspace: currentWorkspace, handle: input.handle,
+                    serverUrl: input.launch.serverUrl, agentId: input.launch.agentId,
+                    requested: input.localMemoryV2Enabled === true, selfTraining: isolated,
+                    ...(input.launch.description ? { description: input.launch.description } : {}) })
+                : initialMode;
+            return { workspace: { ...currentWorkspace, localMemoryV2Enabled: mode.enabled }, mode, initialized };
+        };
+        return await awaitWithCancellation(isolated ? prepare()
+            : withMemoryAccess(join(input.launch.agentsRoot, input.handle), prepare, {
+                create: true,
+                waitMs: EXECUTION_MEMORY_ACCESS_WAIT_MS,
+                initializedRecoveryIdentity: {
+                    agentId: input.launch.agentId,
+                    ...(input.launch.workspaceId === undefined ? {} : { workspaceId: input.launch.workspaceId }),
+                    ...(input.launch.machineId === undefined ? {} : { machineId: input.launch.machineId }),
+                },
+            }), cancellation);
+    }
+    catch (error) {
+        logLocalMemoryContextPrepareFailure({ executionId: input.executionId, agentHandle: input.handle,
+            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }) }, "workspace_prepare", error);
+        if (!isolated && canSafelyDisableLocalMemory(error)) {
+            try {
+                const degraded = await prepareWithoutLocalMemory(input, cancellation);
+                logLocalMemoryContextDegraded({ executionId: input.executionId, agentHandle: input.handle,
+                    ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }) }, error);
+                return degraded;
+            }
+            catch (fallbackError) {
+                logLocalMemoryContextPrepareFailure({ executionId: input.executionId, agentHandle: input.handle,
+                    ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }) }, "workspace_prepare", fallbackError);
+            }
+        }
+        throw error;
+    }
+}