@nowcrew/daemon 0.6.90 → 0.6.91-beta.10

package/dist/agent-ability/types.js

@@ -81,7 +81,7 @@ export const DaemonAbilityManifestSchema = z.object({
             cases: z.array(SafeAbilityPathSchema).max(1_000).default([]),
         }).strict().default({ cases: [] }),
         compatibility: z.object({
-            providers: z.array(z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness"])).min(1),
+            providers: z.array(z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness", "pi"])).min(1),
             minNowCrewVersion: z.string().regex(/^\d+\.\d+\.\d+$/u),
         }).strict().optional(),
         permissions: z.object({

package/dist/console.js

@@ -281,17 +281,18 @@ export function toConsoleLines(event, runtime) {
         return text ? [{ stream: "tool_result", text: clip(text, TOOL_RESULT_CAP) }] : [];
     }
     if (e.type === "system" && e.subtype === "init") {
-        return [{ stream: "system", text: `● ${td("Claude session started")}` }];
+        return [{ stream: "system", text: `● ${td("Claude Code session started")}` }];
     }
     if (e.type === "thread.started") {
         // thread.started is shared by Codex and ACP adapters; its shape does not
         // identify the runtime. Use the executor-owned selection, not event fields.
         const messages = {
-            claude: "Claude session started",
-            codex: "Codex session started",
-            kimi: "Kimi session started",
+            claude: "Claude Code session started",
+            codex: "Codex CLI session started",
+            kimi: "Kimi Code session started",
             hermes: "Hermes session started",
             opencode: "OpenCode session started",
+            pi: "Pi session started",
             "deepseek-harness": "DeepSeek Harness session started",
         };
         const message = runtime && Object.hasOwn(messages, runtime)

package/dist/daemon-update-controller.js

@@ -1,3 +1,4 @@
+import { dslog } from "./slog.js";
 import { z } from "zod";
 import { isDaemonReleaseVersion } from "./daemon-release-version.js";
 const DaemonUpdateMessageSchema = z.object({
@@ -42,15 +43,16 @@ export function createDaemonUpdateController(deps) {
             failed(message.updateId, preparation.errorCode);
             return;
         }
-        let released = false;
-        const releaseOnce = async () => {
-            if (released)
-                return;
-            released = true;
-            await preparation.release();
+        let releaseTask;
+        const releaseOnce = () => {
+            releaseTask ??= preparation.release().catch(error => {
+                releaseTask = undefined;
+                throw error;
+            });
+            return releaseTask;
         };
-        deps.sendStatus({ type: "daemon:update-status", updateId: message.updateId, status: "restarting" });
         try {
+            deps.sendStatus({ type: "daemon:update-status", updateId: message.updateId, status: "restarting" });
             const handoff = deps.scheduleRestart(eligibility.serviceSpec);
             const state = {
                 release: releaseOnce,
@@ -92,7 +94,13 @@ export function createDaemonUpdateController(deps) {
                     failed(message.updateId, "update_in_progress");
                 return true;
             }
-            const done = execute(message).finally(() => {
+            const done = execute(message).catch(error => {
+                dslog("daemon.update_failed", "Daemon 更新或重启准备失败", {
+                    level: "ERROR", update_id: message.updateId, operation: message.type,
+                    error_message: error instanceof Error ? error.message : String(error),
+                });
+                failed(message.updateId, message.type === "daemon:restart" ? "restart_failed" : "install_failed");
+            }).finally(() => {
                 handled.add(message.updateId);
                 if (running?.id === message.updateId)
                     running = null;

package/dist/daemon-updater.js

@@ -1,3 +1,4 @@
+import { dslog } from "./slog.js";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { systemCommandRunner } from "./computer-service.js";
@@ -11,15 +12,14 @@ function registryArgs(registry) {
 function isRegistryAuthFailure(stderr) {
     return /(?:\bE401\b|\b401\b.*\bUnauthorized\b)/iu.test(stderr);
 }
+// Managed eligibility guarantees an exclusive installation and native service per profile.
+// Other profiles share compute capacity, but do not share the package being replaced.
 export async function prepareDaemonRestart(input) {
     const local = input.localSlots.tryAcquireExclusive();
     if (local === null)
         return { ok: false, errorCode: "runtime_busy" };
-    const host = await input.hostCoordinator.tryAcquireExclusiveExecution();
-    if (host === null) {
-        local.release();
-        return { ok: false, errorCode: "runtime_busy" };
-    }
+    const acquiredAt = Date.now();
+    dslog("daemon.maintenance_barrier_acquired", "Daemon 已暂停接收执行，准备维护");
     let released = false;
     return {
         ok: true,
@@ -27,8 +27,8 @@ export async function prepareDaemonRestart(input) {
             if (released)
                 return;
             released = true;
-            await host.release();
             local.release();
+            dslog("daemon.maintenance_barrier_released", "维护屏障已释放", { held_ms: Date.now() - acquiredAt });
         },
     };
 }
@@ -71,22 +71,10 @@ export async function installExactDaemonUpdate(input) {
         || installation.npmPrefix !== input.npmPrefix) {
         return { ok: false, errorCode: "ineligible" };
     }
-    const local = input.localSlots.tryAcquireExclusive();
-    if (local === null)
-        return { ok: false, errorCode: "runtime_busy" };
-    const host = await input.hostCoordinator.tryAcquireExclusiveExecution();
-    if (host === null) {
-        local.release();
-        return { ok: false, errorCode: "runtime_busy" };
-    }
-    let released = false;
-    const release = async () => {
-        if (released)
-            return;
-        released = true;
-        await host.release();
-        local.release();
-    };
+    const barrier = await prepareDaemonRestart(input);
+    if (!barrier.ok)
+        return barrier;
+    const release = barrier.release;
     const lockedInstallation = daemonGlobalInstallation(input.currentEntryPath ?? process.argv[1] ?? "", input.platform ?? process.platform);
     if (lockedInstallation === null
         || lockedInstallation.packageRoot !== input.packageRoot

package/dist/execution-concurrency-telemetry.js

@@ -6,6 +6,7 @@ const RUNTIMES = [
     "hermes",
     "opencode",
     "deepseek-harness",
+    "pi",
 ];
 function snapshotFields(snapshot, tracked) {
     const runtimeFields = {};

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"]);
+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

@@ -13,7 +13,7 @@ const ExitCodeSchema = z.number().int().min(MIN_SIGNED_32_INTEGER).max(MAX_PG_IN
 const ProviderErrorCategorySchema = z.enum(["auth", "quota", "rate_limit", "timeout", "network", "upstream", "cli", "unknown"]);
 const ProviderHttpStatusSchema = z.number().int().min(100).max(599);
 const ProviderErrorCodeSchema = z.string().min(1).max(128).regex(/^[A-Za-z0-9_.:-]+$/u);
-const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness"]);
+const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness", "pi"]);
 const UnsafePathCharacterSchema = /[\p{Cc}<>:"/\\|?*]/u;
 const WindowsReservedNameSchema = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i;
 export const AgentHandleSchema = z.string().min(1).max(64).refine((handle) => handle !== "."
@@ -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";
@@ -285,11 +286,12 @@ function admission(spec, config, dependencies, at) {
         return { rejected: rejection(spec.executionId, "resource_limit", "Local execution capacity is exhausted", at) };
     }
     const permission = effectivePermission(spec, config);
-    if ((spec.runtime.name === "kimi" || spec.runtime.name === "hermes" || spec.runtime.name === "opencode")
+    if ((spec.runtime.name === "kimi" || spec.runtime.name === "hermes" || spec.runtime.name === "opencode" || spec.runtime.name === "pi")
         && permission !== "full_access") {
         const displayName = spec.runtime.name === "kimi"
             ? "Kimi"
-            : spec.runtime.name === "hermes" ? "Hermes" : "OpenCode";
+            : spec.runtime.name === "hermes" ? "Hermes"
+                : spec.runtime.name === "pi" ? "Pi" : "OpenCode";
         return {
             rejected: rejection(spec.executionId, "local_policy_denied", `${displayName} cannot enforce ${permission} permission`, at),
         };
@@ -837,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"

package/dist/external-output.js

@@ -212,7 +212,8 @@ export function decodeExternalOutputEvent(runtime, event, decoder) {
     }
     if ((runtime === "hermes" && candidate.type === "hermes.acp.text_delta")
         || (runtime === "deepseek-harness" && candidate.type === "deepseek-harness.acp.text_delta")
-        || (runtime === "opencode" && candidate.type === "opencode.text_delta")) {
+        || (runtime === "opencode" && candidate.type === "opencode.text_delta")
+        || (runtime === "pi" && candidate.type === "pi.text_delta")) {
         return typeof candidate.text === "string" ? decoder.push(candidate.text) : [];
     }
     return candidate.type === undefined

package/dist/host-execution-coordinator.js

@@ -286,13 +286,19 @@ export function createHostExecutionCoordinator(options = {}) {
                 ...Array.from({ length: executionSlots }, (_, slot) => join(root, "slots", String(slot))),
                 join(root, "memory-prune-slots", "0"),
             ];
-            for (const target of targets) {
-                const lease = await acquireLease(target);
-                if (lease === null) {
-                    await retryRelease("exclusive_execution_partial", () => Promise.all(leases.map((owned) => owned.close())).then(() => undefined));
-                    return null;
+            try {
+                for (const target of targets) {
+                    const lease = await acquireLease(target);
+                    if (lease === null) {
+                        await retryRelease("exclusive_execution_partial", () => Promise.all(leases.map((owned) => owned.close())).then(() => undefined));
+                        return null;
+                    }
+                    leases.push(lease);
                 }
-                leases.push(lease);
+            }
+            catch (error) {
+                await retryRelease("exclusive_execution_partial", () => Promise.all(leases.map(owned => owned.close())).then(() => undefined));
+                throw error;
             }
             let releasePromise = null;
             return {

package/dist/i18n.js

@@ -16,12 +16,13 @@ export function detectDaemonLang(env = process.env) {
         ?? "en";
 }
 const zh = {
-    "Claude session started": "Claude 会话启动",
-    "Codex session started": "Codex 会话启动",
-    "Kimi session started": "Kimi 会话启动",
+    "Claude Code session started": "Claude Code 会话启动",
+    "Codex CLI session started": "Codex CLI 会话启动",
+    "Kimi Code session started": "Kimi Code 会话启动",
     "Hermes session started": "Hermes 会话启动",
     "OpenCode session started": "OpenCode 会话启动",
     "DeepSeek Harness session started": "DeepSeek Harness 会话启动",
+    "Pi session started": "Pi 会话启动",
     "Session started": "会话启动",
     "Plan updated": "计划更新",
     "Thinking (~{{tokens}} tokens, content not streamed by Claude Code)": "思考（约 {{tokens}} tokens，Claude Code 未输出思考正文）",

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";
@@ -42,10 +42,12 @@ import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLoc
 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";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -89,7 +91,7 @@ export function awaitExit(child) {
 }
 export function exitActivity(runtime, exitCode, stderrTail) {
     if ((runtime === "codex" || runtime === "kimi" || runtime === "hermes"
-        || runtime === "opencode" || runtime === "deepseek-harness" || exitCode === -1) && exitCode !== 0) {
+        || runtime === "opencode" || runtime === "deepseek-harness" || runtime === "pi" || exitCode === -1) && exitCode !== 0) {
         return {
             kind: "error",
             label: "运行出错",
@@ -97,7 +99,7 @@ export function exitActivity(runtime, exitCode, stderrTail) {
         };
     }
     if ((runtime === "kimi" || runtime === "hermes" || runtime === "opencode"
-        || runtime === "deepseek-harness") && exitCode === 0) {
+        || runtime === "deepseek-harness" || runtime === "pi") && exitCode === 0) {
         return { kind: "done", label: "本轮结束" };
     }
     return null;
@@ -211,37 +213,11 @@ 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 materialized = null;
     let knownAttachmentDirectory = null;
     const startupReservationState = { current: null };
@@ -391,7 +367,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         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");
+            reportLocalMemoryV2Deferred(input.executionId, input.handle, memoryPruneTraceId !== null || input.maintenancePurpose === "memory_prune", memoryRollout.legacyFallback);
         if (memoryPruneTraceId !== null) {
             executionWorkspace = await resolveMemoryPruneWorkLog(executionWorkspace, input);
             promptContext = { ...promptContext, workspace: executionWorkspace };
@@ -411,8 +387,11 @@ 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",
+            storageVersion: detectLocalMemoryStorageVersion(executionWorkspace.memory),
+            strictRollout: !isolatedMaintenance && !memoryRollout.legacyFallback && (localMemoryV2Environment(input.launch.serverUrl) === "dev"
+                || detectLocalMemoryStorageVersion(executionWorkspace.memory) === 2),
             deferred: memoryRollout.deferred,
+            ...(memoryRollout.legacyFallback ? { legacyFallback: true } : {}),
             renderBase: (reservedPromptBytes) => resolvePrompt(input.systemPrompt, { ...promptContext, reservedPromptBytes }),
         });
         localMemoryResultPath = memoryPrompt.resultPath;

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

@@ -0,0 +1,36 @@
+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";
+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 mode = await resolveLocalMemoryV2Rollout({ workspace, handle: input.handle, serverUrl: input.launch.serverUrl,
+                requested: input.localMemoryV2Enabled === true, selfTraining: isolated,
+                ...(input.launch.description ? { description: input.launch.description } : {}) });
+            const initialized = await initializeLocalMemoryV2ForWorkspace(workspace, mode.enabled);
+            return { workspace: { ...workspace, localMemoryV2Enabled: mode.enabled }, mode, initialized };
+        };
+        return await awaitWithCancellation(isolated ? prepare()
+            : withMemoryAccess(join(input.launch.agentsRoot, input.handle), prepare, { create: true }), cancellation);
+    }
+    catch (error) {
+        logLocalMemoryContextPrepareFailure({ executionId: input.executionId, agentHandle: input.handle,
+            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }) }, "workspace_prepare", error);
+        throw error;
+    }
+}

package/dist/local-memory/full-index-search.js

@@ -0,0 +1,47 @@
+import { parseFullMemoryIndex, LOCAL_MEMORY_GENERATED_INDEX_PATTERN } from "./storage-format.js";
+const excerpt = (text, size) => Array.from(text).slice(0, size).join("");
+/** 查询完整元数据；只在明确的历史入口返回非有效记录。正文仍按引用和哈希分页读取。 */
+export function searchFullMemoryIndex(memory, sha256, input, outputBytes) {
+    const records = parseFullMemoryIndex(memory);
+    const block = LOCAL_MEMORY_GENERATED_INDEX_PATTERN.exec(memory);
+    const prefix = memory.slice(0, block.index);
+    let line = (prefix.match(/\n/gu) ?? []).length + 1;
+    let offset = Array.from(prefix).length;
+    const positions = new Map();
+    for (const part of block[0].matchAll(/[^\n]*(?:\n|$)/gu)) {
+        const id = /^- id: ([A-Za-z0-9_-]+)\r?\n?$/u.exec(part[0])?.[1];
+        if (id)
+            positions.set(id, { line, offset });
+        line += 1;
+        offset += Array.from(part[0]).length;
+    }
+    const terms = input.query.normalize("NFKC").toLowerCase().split(/\s+/u).filter(Boolean);
+    const candidates = records.filter(entry => {
+        const active = entry.status === "active" || entry.status === "pinned";
+        const content = `${entry.id} ${entry.title} ${entry.summary} ${entry.triggers.join(" ")}`.normalize("NFKC").toLowerCase();
+        return active !== input.history && terms.every(term => content.includes(term));
+    });
+    const matches = [];
+    let bytes = 512, hasMore = false;
+    for (const entry of candidates) {
+        const position = positions.get(entry.id);
+        if (!position)
+            throw new Error("memory_storage_position_invalid");
+        if (position.line <= input.afterLine)
+            continue;
+        const item = { ...position, id: entry.id, status: entry.status, revision: entry.revision,
+            file: entry.file, anchor: entry.anchor, heading: excerpt(entry.title, 96),
+            title: excerpt(entry.title, 120), summary: excerpt(entry.summary, 240), text: excerpt(entry.summary, 240) };
+        const size = Buffer.byteLength(JSON.stringify(item), "utf8") + 1;
+        if (matches.length >= input.limit || bytes + size > outputBytes) {
+            hasMore = true;
+            break;
+        }
+        matches.push(item);
+        bytes += size;
+    }
+    if (hasMore && matches.length === 0)
+        throw new Error("memory_output_too_large");
+    return { file: "MEMORY.md", storageVersion: 2, sha256, matches, matchCount: candidates.length,
+        hasMore, complete: !hasMore, nextAfterLine: hasMore ? matches.at(-1).line : null };
+}

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

@@ -50,14 +50,17 @@ export function selectLocalMemoryIndexEntries(entries, budget, options = {}) {
         .map((entry) => entry.id);
     const protectedIds = options.protectedIds ?? new Set();
     const protectedEntries = projectable.filter((entry) => protectedIds.has(entry.id)).sort(compareEntries);
-    const candidates = projectable.filter((entry) => !protectedIds.has(entry.id)).sort(compareEntries);
+    const candidates = projectable.filter((entry) => !protectedIds.has(entry.id)).sort((left, right) => (options.relevance?.(right) ?? 0) - (options.relevance?.(left) ?? 0) || compareEntries(left, right));
     const selected = [];
     let renderedLength = 0;
+    let renderedBytes = 0;
     for (const entry of protectedEntries) {
         selected.push(entry);
         renderedLength += cardLength(entry, selected.length > 1);
+        renderedBytes += Buffer.byteLength(renderLocalMemoryIndexCard(entry), "utf8") + (selected.length > 1 ? 1 : 0);
     }
-    if (selected.length > budget.entryCap || renderedLength > budget.indexCodePointCap) {
+    if (selected.length > budget.entryCap || renderedLength > budget.indexCodePointCap
+        || renderedBytes > (budget.indexByteCap ?? Infinity)) {
         return {
             entries: selected,
             omittedIds: [...omittedIds, ...candidates.map((entry) => entry.id)],
@@ -65,12 +68,15 @@ export function selectLocalMemoryIndexEntries(entries, budget, options = {}) {
         };
     }
     for (const entry of candidates) {
-        if (selected.length >= budget.entryCap || renderedLength + cardLength(entry, selected.length > 0) > budget.indexCodePointCap) {
+        const bytes = Buffer.byteLength(renderLocalMemoryIndexCard(entry), "utf8") + (selected.length > 0 ? 1 : 0);
+        if (selected.length >= budget.entryCap || renderedLength + cardLength(entry, selected.length > 0) > budget.indexCodePointCap
+            || renderedBytes + bytes > (budget.indexByteCap ?? Infinity)) {
             omittedIds.push(entry.id);
             continue;
         }
         selected.push(entry);
         renderedLength += cardLength(entry, selected.length > 1);
+        renderedBytes += bytes;
     }
     return {
         entries: selected,