@nowcrew/daemon 0.6.97 → 0.6.98-beta.2

package/README.md

@@ -413,13 +413,6 @@ discovery is unchanged: Claude may still load `~/.claude/skills`, and Codex may
 and `~/.agents/skills`. The DeepSeek Codex variant keeps its Agent-private `.codex-deepseek` Home for
 provider credentials. Project bindings do not hide or rewrite any of those sources.
 
-Both Codex launchers disable host automatic memories and inherit the execution's prepared environment,
-overriding host `core`, default exclusions, `exclude` and `include_only` filters. These are process-local
-settings: authentication, providers and Skills retain the configured Home, and no other environment
-scope is merged. The policy version in Codex's session fingerprint cold-starts older native sessions
-once, then subsequent runs can resume normally. Explicit `shell_environment_policy.set` entries, shell
-startup scripts and Agent notes remain separate configuration; this change does not correct them.
-
 Binding changes reconcile immediately when the Computer is online. On reconnect the server sends the
 complete binding set for every Agent assigned to that Computer, including empty sets that clear stale
 links left by offline unbinds. Every non-empty execution snapshot is also reconciled immediately before

package/dist/automatic-service-migration.js

@@ -3,6 +3,8 @@ import { posix, win32 } from "node:path";
 import { buildServiceSpec, serviceStatus, windowsCommandArg, } from "./computer-service.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { inspectLegacyServiceInstallationDetails } from "./legacy-service-installation.js";
+import { powershellCommandArgs } from "./powershell-command.js";
+import { windowsTaskPrincipalFields, windowsTaskPrincipalMatches, windowsTaskPrincipalScript, } from "./windows-task-principal.js";
 function encoded(value) {
     return Buffer.from(value, "utf16le").toString("base64");
 }
@@ -142,12 +144,11 @@ async function discoverWindows(input, identity) {
         "$n=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[0]));",
         "$tasks=@(Get-ScheduledTask -ErrorAction Stop|Where-Object{$_.TaskPath -eq '\\' -and $_.TaskName -ceq $n});",
         "if($tasks.Count -ne 1){[pscustomobject]@{count=$tasks.Count}|ConvertTo-Json -Compress;exit 0};",
-        "$task=$tasks[0];$actions=@($task.Actions);$me=[Security.Principal.WindowsIdentity]::GetCurrent().Name;",
-        "[pscustomobject]@{count=1;state=[int]$task.State;actionCount=$actions.Count;execute=if($actions.Count -eq 1){$actions[0].Execute}else{$null};arguments=if($actions.Count -eq 1){$actions[0].Arguments}else{$null};principalMatches=([String]::Equals($task.Principal.UserId,$me,[StringComparison]::OrdinalIgnoreCase)-and [int]$task.Principal.LogonType -eq 3 -and [int]$task.Principal.RunLevel -eq 0)}|ConvertTo-Json -Compress;",
+        "$task=$tasks[0];$actions=@($task.Actions);",
+        windowsTaskPrincipalScript,
+        `[pscustomobject]@{count=1;state=[int]$task.State;actionCount=$actions.Count;execute=if($actions.Count -eq 1){$actions[0].Execute}else{$null};arguments=if($actions.Count -eq 1){$actions[0].Arguments}else{$null};${windowsTaskPrincipalFields}}|ConvertTo-Json -Compress;`,
     ].join("");
-    const result = await input.runner("powershell.exe", [
-        "-NoProfile", "-NonInteractive", "-Command", script, encoded(identity.id),
-    ]);
+    const result = await input.runner("powershell.exe", powershellCommandArgs(script, [encoded(identity.id)]));
     if (result.exitCode !== 0) {
         throw new Error(`Unable to inspect legacy scheduled task: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
     }
@@ -165,7 +166,7 @@ async function discoverWindows(input, identity) {
         : null;
     if (definition.count !== 1
         || definition.actionCount !== 1
-        || definition.principalMatches !== true
+        || !windowsTaskPrincipalMatches(definition)
         || !win32.isAbsolute(definition.execute ?? "")
         || match === null
         || match[2] !== input.desired.profile

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/computer-service.js

@@ -6,7 +6,9 @@ import { promisify } from "node:util";
 import { dirname, resolve } from "node:path";
 import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
 import { daemonRegistryCandidates } from "./daemon-registry.js";
+import { windowsTaskPrincipalFields, windowsTaskPrincipalMatches, windowsTaskPrincipalScript, } from "./windows-task-principal.js";
 import { npmInvocation } from "./npm-command.js";
+import { powershellCommandArgs } from "./powershell-command.js";
 const execFileAsync = promisify(execFile);
 const WINDOWS_STOP_TIMEOUT_MS = 5_000;
 const WINDOWS_STOP_POLL_MS = 100;
@@ -195,12 +197,11 @@ async function windowsTaskDefinitionMatches(spec, runner) {
         "$n=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[0]));",
         "$tasks=@(Get-ScheduledTask -ErrorAction Stop|Where-Object{$_.TaskPath -eq '\\' -and $_.TaskName -ceq $n});",
         "if($tasks.Count -ne 1){[pscustomobject]@{count=$tasks.Count}|ConvertTo-Json -Compress;exit 0};",
-        "$task=$tasks[0];$actions=@($task.Actions);$me=[Security.Principal.WindowsIdentity]::GetCurrent().Name;",
-        "[pscustomobject]@{count=1;actionCount=$actions.Count;execute=if($actions.Count -eq 1){$actions[0].Execute}else{$null};arguments=if($actions.Count -eq 1){$actions[0].Arguments}else{$null};principalMatches=([String]::Equals($task.Principal.UserId,$me,[StringComparison]::OrdinalIgnoreCase)-and [int]$task.Principal.LogonType -eq 3 -and [int]$task.Principal.RunLevel -eq 0)}|ConvertTo-Json -Compress;",
+        "$task=$tasks[0];$actions=@($task.Actions);",
+        windowsTaskPrincipalScript,
+        `[pscustomobject]@{count=1;actionCount=$actions.Count;execute=if($actions.Count -eq 1){$actions[0].Execute}else{$null};arguments=if($actions.Count -eq 1){$actions[0].Arguments}else{$null};${windowsTaskPrincipalFields}}|ConvertTo-Json -Compress;`,
     ].join("");
-    const result = await runner("powershell.exe", [
-        "-NoProfile", "-NonInteractive", "-Command", script, encodedName,
-    ]);
+    const result = await runner("powershell.exe", powershellCommandArgs(script, [encodedName]));
     if (result.exitCode !== 0) {
         throw new Error(`Unable to inspect scheduled task definition: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
     }
@@ -214,7 +215,7 @@ async function windowsTaskDefinitionMatches(spec, runner) {
     const expectedArguments = spec.daemonCommand.slice(1).map(windowsCommandArg).join(" ");
     return definition.count === 1
         && definition.actionCount === 1
-        && definition.principalMatches === true
+        && windowsTaskPrincipalMatches(definition)
         && sameWindowsPath(definition.execute, spec.daemonCommand[0])
         && definition.arguments === expectedArguments;
 }
@@ -226,9 +227,7 @@ async function windowsTaskState(spec, runner) {
         "$tasks=@(Get-ScheduledTask -ErrorAction Stop|Where-Object{$_.TaskPath -eq '\\' -and $_.TaskName -ceq $n});",
         "if($tasks.Count -eq 0){'missing'}elseif($tasks.Count -eq 1){'state:'+([int]$tasks[0].State)}else{throw 'duplicate scheduled tasks'}",
     ].join("");
-    const result = await runner("powershell.exe", [
-        "-NoProfile", "-NonInteractive", "-Command", script, encodedName,
-    ]);
+    const result = await runner("powershell.exe", powershellCommandArgs(script, [encodedName]));
     if (result.exitCode !== 0) {
         throw new Error(`Unable to query scheduled task: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
     }
@@ -279,10 +278,9 @@ export async function installService(spec, runner = systemCommandRunner) {
             "$principal=New-ScheduledTaskPrincipal -UserId $identity -LogonType Interactive -RunLevel Limited;",
             "Register-ScheduledTask -TaskName $name -TaskPath '\\' -Action $action -Trigger $trigger -Settings $settings -Principal $principal -ErrorAction Stop|Out-Null;",
         ].join("");
-        await checked(runner, "powershell.exe", [
-            "-NoProfile", "-NonInteractive", "-Command", script,
+        await checked(runner, "powershell.exe", powershellCommandArgs(script, [
             encodedName, encodedExecutable, encodedArguments,
-        ], "Scheduled task installation");
+        ]), "Scheduled task installation");
         return;
     }
     if (spec.descriptorPath === null || spec.descriptor === null)
@@ -418,6 +416,33 @@ export async function serviceAction(spec, action, runner = systemCommandRunner)
     }
 }
 const systemDetachedSpawn = (command, args, options) => spawn(command, [...args], options);
+function windowsRestartCommandArgs(spec) {
+    if (!spec.runtimeProcessIdentity)
+        throw new Error("Windows daemon process identity is required for restart");
+    const encodedName = Buffer.from(spec.id, "utf16le").toString("base64");
+    const encodedExecutable = Buffer.from(spec.daemonCommand[0], "utf16le").toString("base64");
+    const encodedArguments = Buffer.from(spec.daemonCommand.slice(1).map(windowsCommandArg).join(" "), "utf16le").toString("base64");
+    const script = [
+        "$ErrorActionPreference='Stop';",
+        "$n=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[1]));",
+        "$exe=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[2]));",
+        "$argv=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[3]));",
+        "$task=@(Get-ScheduledTask -ErrorAction Stop|Where-Object{$_.TaskPath -eq '\\' -and $_.TaskName -ceq $n});if($task.Count -ne 1){throw 'scheduled task identity changed'};",
+        "$actions=@($task[0].Actions);if($actions.Count -ne 1 -or -not [String]::Equals($actions[0].Execute,$exe,[StringComparison]::OrdinalIgnoreCase) -or $actions[0].Arguments -cne $argv){throw 'scheduled task action changed'};",
+        "$p=Get-Process -Id ([int]$args[0]) -ErrorAction Stop;",
+        "if($p.StartTime.ToUniversalTime().ToFileTimeUtc().ToString() -cne $args[4]){throw 'daemon process identity changed'};",
+        "$p.Kill();",
+        "if(-not $p.WaitForExit(10000)){throw 'daemon exit timeout'};",
+        "$deadline=[DateTime]::UtcNow.AddSeconds(10);",
+        "do{$task=@(Get-ScheduledTask -ErrorAction Stop|Where-Object{$_.TaskPath -eq '\\' -and $_.TaskName -ceq $n});if($task.Count -ne 1){throw 'scheduled task identity changed'};if([int]$task[0].State -ne 4){break};Start-Sleep -Milliseconds 100}while([DateTime]::UtcNow -lt $deadline);",
+        "if([int]$task[0].State -eq 4){throw 'scheduled task stop timeout'};",
+        "$actions=@($task[0].Actions);if($actions.Count -ne 1 -or -not [String]::Equals($actions[0].Execute,$exe,[StringComparison]::OrdinalIgnoreCase) -or $actions[0].Arguments -cne $argv){throw 'scheduled task action changed'};",
+        "& schtasks.exe /Run /TN $n | Out-Null;if($LASTEXITCODE -ne 0){throw 'scheduled task start failed'};",
+    ].join("");
+    return powershellCommandArgs(script, [
+        String(process.pid), encodedName, encodedExecutable, encodedArguments, spec.runtimeProcessIdentity,
+    ]);
+}
 const RESTART_HELPER_SOURCE = String.raw `
 const { spawnSync } = require("node:child_process");
 const spec = JSON.parse(process.argv[1]);
@@ -428,27 +453,7 @@ setTimeout(() => {
   } else if (spec.platform === "linux") {
     restarted = spawnSync("systemctl", ["--user", "--no-block", "restart", spec.id], { stdio: "ignore", shell: false });
   } else {
-    const encodedName = Buffer.from(spec.id, "utf16le").toString("base64");
-    const encodedExecutable = Buffer.from(spec.executable, "utf16le").toString("base64");
-    const encodedArguments = Buffer.from(spec.arguments, "utf16le").toString("base64");
-    const script = [
-      "$ErrorActionPreference='Stop';",
-      "$n=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[1]));",
-      "$exe=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[2]));",
-      "$argv=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[3]));",
-      "$task=@(Get-ScheduledTask -ErrorAction Stop|Where-Object{$_.TaskPath -eq '\\' -and $_.TaskName -ceq $n});if($task.Count -ne 1){throw 'scheduled task identity changed'};",
-      "$actions=@($task[0].Actions);if($actions.Count -ne 1 -or -not [String]::Equals($actions[0].Execute,$exe,[StringComparison]::OrdinalIgnoreCase) -or $actions[0].Arguments -cne $argv){throw 'scheduled task action changed'};",
-      "$p=Get-Process -Id ([int]$args[0]) -ErrorAction Stop;",
-      "if($p.StartTime.ToUniversalTime().ToFileTimeUtc().ToString() -cne $args[4]){throw 'daemon process identity changed'};",
-      "$p.Kill();",
-      "if(-not $p.WaitForExit(10000)){throw 'daemon exit timeout'};",
-      "$deadline=[DateTime]::UtcNow.AddSeconds(10);",
-      "do{$task=@(Get-ScheduledTask -ErrorAction Stop|Where-Object{$_.TaskPath -eq '\\' -and $_.TaskName -ceq $n});if($task.Count -ne 1){throw 'scheduled task identity changed'};if([int]$task[0].State -ne 4){break};Start-Sleep -Milliseconds 100}while([DateTime]::UtcNow -lt $deadline);",
-      "if([int]$task[0].State -eq 4){throw 'scheduled task stop timeout'};",
-      "$actions=@($task[0].Actions);if($actions.Count -ne 1 -or -not [String]::Equals($actions[0].Execute,$exe,[StringComparison]::OrdinalIgnoreCase) -or $actions[0].Arguments -cne $argv){throw 'scheduled task action changed'};",
-      "& schtasks.exe /Run /TN $n | Out-Null;if($LASTEXITCODE -ne 0){throw 'scheduled task start failed'};",
-    ].join("");
-    restarted = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script, String(spec.daemonPid), encodedName, encodedExecutable, encodedArguments, spec.processIdentity], { stdio: "ignore", shell: false });
+    restarted = spawnSync("powershell.exe", spec.powershellArgs, { stdio: "ignore", shell: false });
   }
   if (restarted.status !== 0) process.send?.({ type: "restart-failed", status: restarted.status });
   setTimeout(() => {
@@ -470,15 +475,8 @@ export function scheduleServiceRestart(spec, spawnDetached = systemDetachedSpawn
             ? { platform: spec.platform, id: spec.id }
             : {
                 platform: spec.platform,
-                id: spec.id,
-                daemonPid: process.pid,
-                executable: spec.daemonCommand[0],
-                arguments: spec.daemonCommand.slice(1).map(windowsCommandArg).join(" "),
-                processIdentity: spec.runtimeProcessIdentity,
+                powershellArgs: windowsRestartCommandArgs(spec),
             };
-    if (spec.platform === "win32" && !payload.processIdentity) {
-        throw new Error("Windows daemon process identity is required for restart");
-    }
     const child = spawnDetached(process.execPath, ["-e", RESTART_HELPER_SOURCE, JSON.stringify(payload)], { detached: true, stdio: ["ignore", "ignore", "ignore", "ipc"], shell: false });
     child.unref();
     let settleFailure;
@@ -627,7 +625,7 @@ export async function windowsProfileIsPrivate(path, runner = systemCommandRunner
         "$unsafe=$rules|Where-Object { $_.AccessControlType -eq 'Allow' -and $safe -notcontains $_.IdentityReference.Translate([Security.Principal.SecurityIdentifier]).Value };",
         "if($unsafe){'false'}else{'true'}",
     ].join("");
-    const result = await runner("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script, encodedPath]);
+    const result = await runner("powershell.exe", powershellCommandArgs(script, [encodedPath]));
     if (result.exitCode !== 0)
         throw new Error(`Profile ACL inspection failed: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
     if (result.stdout.trim() === "true")

package/dist/computer-setup-client.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { hostname } from "node:os";
 import { MachineTokenSchema } from "./computer-profile.js";
+import { powershellCommandArgs } from "./powershell-command.js";
 import { systemCommandRunner, } from "./computer-service.js";
 const HttpUrlSchema = z.string().url().refine((value) => {
     const url = new URL(value);
@@ -309,8 +310,10 @@ export function createComputerSetupClient(options) {
     };
 }
 export async function openSetupBrowser(url, platform = process.platform, runner = systemCommandRunner) {
-    const command = platform === "win32" ? "explorer.exe" : platform === "darwin" ? "open" : "xdg-open";
-    const args = [url];
+    const command = platform === "win32" ? "powershell.exe" : platform === "darwin" ? "open" : "xdg-open";
+    const args = platform === "win32"
+        ? powershellCommandArgs("Start-Process -FilePath $args[0] -ErrorAction Stop | Out-Null", [url])
+        : [url];
     const result = await runner(command, args);
     if (result.exitCode !== 0) {
         throw new Error(`Unable to open the computer setup browser: ${redactSetupSecrets(result.stderr.trim() || `exit ${result.exitCode}`)}`);

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";
@@ -838,8 +839,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"
@@ -879,6 +881,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/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";
@@ -39,13 +39,20 @@ import { projectSkillRuntimeDirectories, } from "./project-skills/runtime-launch
 import { logIdentityRosterRuntimePrepared } from "./identity-roster-telemetry.js";
 import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, logMemoryPruneDiagnosticsFailure, memoryPruneSnapshotFields, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
+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 +66,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 +217,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 +233,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 +372,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;
@@ -909,6 +903,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 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") {
@@ -922,6 +921,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 = [
@@ -1045,6 +1052,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,62 @@
+import { prepareWorkspace } from "../workspace.js";
+import { awaitWithCancellation } from "../runtime-cancellation.js";
+import { 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;
+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);
+        throw error;
+    }
+}