@nowcrew/daemon 0.6.91-beta.11 → 0.6.91-beta.13

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"

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,13 @@ 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";
+import { MEMORY_STATE_GUARD_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY } from "./memory-migration-protocol.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -211,37 +214,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 +368,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 +388,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;
@@ -914,6 +894,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 exitCode,
                 workLogPath: executionWorkspace.workLogPath,
                 expectedWorkLogSha256: workLogSha256(executionWorkspace.workLog),
+                ...(input.localMemoryV2Enabled === true ? {
+                    writerCapabilities: [MEMORY_STORAGE_V2_CAPABILITY, MEMORY_STATE_GUARD_CAPABILITY],
+                } : {}),
             });
             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") {

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,

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

@@ -29,14 +29,33 @@ export async function runMemoryInventoryCommand(args, io) {
         const issues = [...scan.issues, ...analysis.issues];
         const referenced = new Set(analysis.entries.map((entry) => entry.sourceFields.file));
         const files = scan.sources.map(({ path, bytes, sha256 }) => ({ path, bytes, sha256 }));
+        const orphanNotes = files.filter((file) => file.path.startsWith("notes/") && !referenced.has(file.path)).map((file) => file.path);
+        const storageVersion = (() => {
+            try {
+                return detectLocalMemoryStorageVersion(scan.sources.find((source) => source.path === "MEMORY.md")?.content ?? "");
+            }
+            catch {
+                return null;
+            }
+        })();
+        const indexedEntries = analysis.entries.filter((entry) => entry.format === "managed").length;
+        const legacyEntries = analysis.entries.length - indexedEntries;
         const report = {
             schemaVersion: 1, mode: "dry-run", agentDir: scan.root, applySupported: false,
             complete, scanComplete, requiresHumanReview: true,
+            // 只读派生观测，不改变资格判断，也不新增持久化状态。
+            // A dry-run does not create a shadow index or server state. Existing
+            // schema1 cards therefore remain legacy; indexedEntries is only coverage
+            // information, not proof that the Agent entered shadow mode.
+            storageMode: storageVersion === 2 ? "v2_write" : "legacy",
+            contextMode: storageVersion === 2 ? "bounded_preview" : "legacy_context",
+            migrationCoverage: { storageVersion, indexedEntries, legacyEntries, unindexedFiles: orphanNotes.length,
+                totalEntries: analysis.entries.length, complete },
             coverage: ["MEMORY.md", "notes/**", ".crew/memory/pending/**", "根目录的 .memory-result.v1-*.json"],
             limitations: ["不扫描历史执行目录；result清单仅覆盖Agent根目录。", "两遍摘要比对不等同跨文件原子快照，正式迁移仍需停止写入并重新核对。"],
             limits: inventoryLimits, totalBytes: scan.totalBytes, files, ...analysis, issues,
             pending: files.filter((file) => file.path.startsWith(".crew/memory/pending/")).map((file) => file.path),
-            orphanNotes: files.filter((file) => file.path.startsWith("notes/") && !referenced.has(file.path)).map((file) => file.path),
+            orphanNotes,
             resultFiles: files.filter((file) => file.path.startsWith(".memory-result.v1-")).map((file) => file.path),
         };
         io.out(JSON.stringify(report, null, 2) + "\n");
@@ -59,3 +78,4 @@ import { parseArgs } from "node:util";
 import { z } from "zod";
 import { inventoryLimits, scanMemorySources } from "./inventory-source.js";
 import { previewMemoryInventory } from "./inventory-preview.js";
+import { detectLocalMemoryStorageVersion } from "./storage-format.js";

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

@@ -73,7 +73,8 @@ export async function readMemoryInventorySource(root, file, budget) {
         await handle.close();
     }
 }
-export async function scanMemorySources(agentDir) {
+export async function scanMemorySources(agentDir, options = {}) {
+    const includeOperationalFiles = options.includeOperationalFiles ?? true;
     const root = await realpath(agentDir);
     if ((await lstat(agentDir)).isSymbolicLink())
         throw new Error("agent_root_symlink");
@@ -124,10 +125,14 @@ export async function scanMemorySources(agentDir) {
     }
     await visit("MEMORY.md");
     await visit("notes", true);
-    await visit(".crew/memory/pending", true);
-    const resultNames = (await readdir(root)).filter((name) => /^\.memory-result\.v1-.*\.json$/u.test(name)).sort();
-    for (const name of resultNames)
-        await visit(name);
+    const resultNames = includeOperationalFiles
+        ? (await readdir(root)).filter((name) => /^\.memory-result\.v1-.*\.json$/u.test(name)).sort()
+        : [];
+    if (includeOperationalFiles) {
+        await visit(".crew/memory/pending", true);
+        for (const name of resultNames)
+            await visit(name);
+    }
     // 第二遍比对摘要和目录清单，发现扫描期间的变化就拒绝完整性结论；这不是跨文件事务锁。
     for (const source of sources) {
         try {
@@ -150,9 +155,11 @@ export async function scanMemorySources(agentDir) {
                 addIssue("source_changed", file);
         }
     }
-    const currentResults = (await readdir(root)).filter((name) => /^\.memory-result\.v1-.*\.json$/u.test(name)).sort();
-    if (JSON.stringify(currentResults) !== JSON.stringify(resultNames))
-        addIssue("source_changed", ".memory-result.v1-*.json");
+    if (includeOperationalFiles) {
+        const currentResults = (await readdir(root)).filter((name) => /^\.memory-result\.v1-.*\.json$/u.test(name)).sort();
+        if (JSON.stringify(currentResults) !== JSON.stringify(resultNames))
+            addIssue("source_changed", ".memory-result.v1-*.json");
+    }
     if (await realpath(agentDir) !== root)
         addIssue("source_changed", "agent_root");
     return { root, sources: sources.sort((a, b) => a.path.localeCompare(b.path)), issues, totalBytes };

package/dist/local-memory/legacy-adapter.js

@@ -0,0 +1,221 @@
+import { Buffer } from "node:buffer";
+import { realpath } from "node:fs/promises";
+import { inventoryLimits, readMemoryInventorySource, scanMemorySources } from "./inventory-source.js";
+import { LOCAL_MEMORY_GENERATED_INDEX_PATTERN } from "./storage-format.js";
+const CURSOR_VERSION = 1;
+const MAX_METADATA_PATH_BYTES = 4 * 1024;
+const MAX_METADATA_WARNING_BYTES = 2 * 1024;
+const excerpt = (text, size) => {
+    const characters = Array.from(text);
+    return characters.length > size ? `${characters.slice(0, size).join("")}...` : text;
+};
+function originalLowercaseIndex(text, index) {
+    let originalIndex = 0;
+    let lowerIndex = 0;
+    for (const character of text) {
+        lowerIndex += character.toLowerCase().length;
+        if (index < lowerIndex)
+            return originalIndex;
+        originalIndex += character.length;
+    }
+    return text.length;
+}
+function encodeCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeCursor(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    }
+    catch {
+        throw new Error("memory_cursor_invalid");
+    }
+    if (!parsed || typeof parsed !== "object")
+        throw new Error("memory_cursor_invalid");
+    const record = parsed;
+    if (record.version !== CURSOR_VERSION || typeof record.file !== "string"
+        || !/^[a-f0-9]{64}$/u.test(String(record.sha256))
+        || typeof record.afterLine !== "number" || !Number.isSafeInteger(record.afterLine) || record.afterLine < 0) {
+        throw new Error("memory_cursor_invalid");
+    }
+    return { version: 1, file: record.file, sha256: String(record.sha256), afterLine: record.afterLine };
+}
+function boundStringList(values, maxBytes) {
+    const bounded = [];
+    for (const value of values) {
+        const candidate = [...bounded, value];
+        if (Buffer.byteLength(JSON.stringify(candidate), "utf8") > maxBytes)
+            break;
+        bounded.push(value);
+    }
+    return { values: bounded, truncated: bounded.length < values.length };
+}
+function sourceMatches(source, query, afterLine, limit, outputBytes) {
+    const terms = query.normalize("NFKC").toLowerCase().split(/\s+/u).filter(Boolean);
+    const matches = [];
+    let line = 0;
+    let offset = 0;
+    let heading = "";
+    let matchCount = 0;
+    let hasMore = false;
+    let outputTooLarge = false;
+    let firstMatchLine = null;
+    let remaining = outputBytes;
+    const generatedIndex = source.path === "MEMORY.md"
+        ? LOCAL_MEMORY_GENERATED_INDEX_PATTERN.exec(source.content)
+        : null;
+    const generatedStart = generatedIndex === null ? -1 : Array.from(source.content.slice(0, generatedIndex.index)).length;
+    const generatedEnd = generatedIndex === null ? -1 : generatedStart + Array.from(generatedIndex[0]).length;
+    for (const match of source.content.matchAll(/[^\n]*(?:\n|$)/gu)) {
+        if (match[0] === "")
+            break;
+        line += 1;
+        const raw = match[0];
+        const lineStart = offset;
+        const lineEnd = offset + Array.from(raw).length;
+        const content = raw.replace(/\r?\n$/u, "");
+        const title = /^#{1,6}\s+(.+?)\s*$/u.exec(content)?.[1];
+        if (title !== undefined)
+            heading = excerpt(title, 96);
+        const lower = content.normalize("NFKC").toLowerCase();
+        const insideGeneratedIndex = generatedStart >= 0 && lineStart < generatedEnd && lineEnd > generatedStart;
+        if (!insideGeneratedIndex && terms.every(term => lower.includes(term))) {
+            matchCount += 1;
+            if (line > afterLine) {
+                firstMatchLine ??= line;
+                const matchIndex = lower.indexOf(terms[0] ?? "");
+                let start = Math.max(0, originalLowercaseIndex(content, matchIndex) - 60);
+                if (start > 0 && /[\uDC00-\uDFFF]/u.test(content[start]))
+                    start -= 1;
+                const item = { file: source.path, sourceSha256: source.sha256, legacy: true, opaque: true,
+                    line, offset, heading, text: `${start > 0 ? "..." : ""}${excerpt(content.slice(start), 240)}` };
+                const bytes = Buffer.byteLength(JSON.stringify(item), "utf8") + 1;
+                if (matches.length >= limit)
+                    hasMore = true;
+                else if (bytes > remaining) {
+                    hasMore = true;
+                    outputTooLarge = matches.length === 0;
+                }
+                else {
+                    matches.push(item);
+                    remaining -= bytes;
+                }
+            }
+        }
+        offset += Array.from(raw).length;
+    }
+    return { matches, matchCount, hasMore, outputTooLarge, firstMatchLine,
+        bytesUsed: outputBytes - remaining,
+        nextAfterLine: hasMore ? matches.at(-1)?.line ?? null : null };
+}
+function issueCode(error) {
+    if (error instanceof TypeError)
+        return "invalid_utf8";
+    if (error instanceof Error)
+        return error.code ?? error.message;
+    return "read_failed";
+}
+async function readRequestedSources(agentDir, files, excludeFiles) {
+    const root = await realpath(agentDir);
+    const sources = [];
+    const issues = [];
+    let remaining = inventoryLimits.totalBytes;
+    for (const file of [...new Set(files)].sort((left, right) => left.localeCompare(right))) {
+        if (excludeFiles?.has(file))
+            continue;
+        try {
+            const source = await readMemoryInventorySource(root, file, remaining);
+            remaining -= source.bytes;
+            sources.push(source);
+        }
+        catch (error) {
+            issues.push({ code: issueCode(error), path: file });
+        }
+    }
+    return { sources, issues };
+}
+/**
+ * Read-only adapter for old MEMORY.md/notes content. It is only called from
+ * explicit search commands; prompt preparation never invokes it.
+ */
+export async function searchLegacyMemorySources(input) {
+    const scan = input.files === undefined
+        ? await scanMemorySources(input.agentDir, { includeOperationalFiles: false })
+        : null;
+    const requestedResult = input.files === undefined
+        ? null
+        : await readRequestedSources(input.agentDir, input.files, input.excludeFiles);
+    const requested = input.files === undefined
+        ? scan.sources.filter(source => source.path === "MEMORY.md" || source.path.startsWith("notes/"))
+        : requestedResult.sources;
+    const sources = input.files === undefined
+        ? requested.filter(source => !(input.excludeFiles?.has(source.path) ?? false))
+        : requested;
+    const relevantIssues = input.files === undefined
+        ? scan.issues.filter(issue => issue.path === "MEMORY.md" || issue.path.startsWith("notes/"))
+        : requestedResult.issues;
+    const cursor = input.cursor === undefined ? null : decodeCursor(input.cursor);
+    if (cursor !== null && !sources.some(source => source.path === cursor.file))
+        throw new Error("memory_cursor_invalid");
+    const ordered = [...sources].sort((left, right) => left.path.localeCompare(right.path));
+    const matches = [];
+    let matchCount = 0;
+    let hasMore = false;
+    let nextCursor = null;
+    let started = cursor === null;
+    let pageFull = false;
+    const allUnindexedFiles = ordered.map(source => source.path);
+    const boundedFiles = boundStringList(allUnindexedFiles, MAX_METADATA_PATH_BYTES);
+    const allWarnings = relevantIssues.map(issue => ({ code: issue.code, path: issue.path }));
+    const boundedWarnings = boundStringList(allWarnings.map(warning => `${warning.code}\u0000${warning.path}`), MAX_METADATA_WARNING_BYTES);
+    const warnings = boundedWarnings.values.map(value => {
+        const separator = value.indexOf("\u0000");
+        return { code: separator < 0 ? value : value.slice(0, separator), path: separator < 0 ? "" : value.slice(separator + 1) };
+    });
+    const outputReservation = Buffer.byteLength(JSON.stringify({
+        source: "legacy", legacy: true, opaque: true, storageVersion: 0,
+        ...(ordered.length === 1 ? { file: ordered[0].path, sha256: ordered[0].sha256 } : {}),
+        matches: [], matchCount: 0, hasMore: false, complete: false, nextAfterLine: null,
+        unindexedFiles: boundedFiles.values, unindexedFileCount: allUnindexedFiles.length,
+        unindexedFilesTruncated: boundedFiles.truncated, nextCursor: null,
+        warnings, warningCount: allWarnings.length, warningsTruncated: boundedWarnings.truncated,
+    }), "utf8") + 256;
+    let remainingOutputBytes = Math.max(0, input.outputBytes - outputReservation);
+    for (const source of ordered) {
+        if (!started) {
+            if (source.path !== cursor.file)
+                continue;
+            if (source.sha256 !== cursor.sha256)
+                throw new Error("memory_file_changed");
+            started = true;
+        }
+        const afterLine = source.path === cursor?.file ? cursor.afterLine
+            : cursor === null && source.path === ordered[0]?.path ? input.afterLine ?? 0 : 0;
+        const result = sourceMatches(source, input.query, afterLine, pageFull ? 0 : Math.max(0, input.limit - matches.length), remainingOutputBytes);
+        matches.push(...result.matches);
+        matchCount += result.matchCount;
+        remainingOutputBytes -= result.bytesUsed;
+        if (result.hasMore) {
+            hasMore = true;
+            pageFull = true;
+            if (result.outputTooLarge && matches.length === 0)
+                throw new Error("memory_output_too_large");
+            if (nextCursor === null) {
+                const last = result.matches.at(-1);
+                nextCursor = encodeCursor({ version: 1, file: source.path, sha256: source.sha256,
+                    afterLine: Number(last?.line ?? Math.max(0, result.firstMatchLine ?? 1) - 1) });
+            }
+        }
+    }
+    const complete = !hasMore && relevantIssues.length === 0;
+    return {
+        source: "legacy", legacy: true, opaque: true, storageVersion: 0,
+        ...(ordered.length === 1 ? { file: ordered[0].path, sha256: ordered[0].sha256 } : {}),
+        matches, matchCount, hasMore, complete, nextAfterLine: hasMore && ordered.length === 1
+            ? Number(matches.at(-1)?.line ?? 0) : null,
+        unindexedFiles: boundedFiles.values, unindexedFileCount: allUnindexedFiles.length,
+        unindexedFilesTruncated: boundedFiles.truncated, nextCursor, warnings,
+        warningCount: allWarnings.length, warningsTruncated: boundedWarnings.truncated,
+    };
+}