@nowcrew/daemon 0.6.92 → 0.6.93-beta.1

package/dist/local-memory/storage-format.js

@@ -0,0 +1,152 @@
+import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderGeneratedIndex, renderLocalMemoryIndexCard, selectLocalMemoryIndexEntries, } from "./index-budget.js";
+export const LOCAL_MEMORY_STORAGE_BYTE_CAP = 16 * 1024 * 1024;
+export const LOCAL_MEMORY_STORAGE_ENTRY_CAP = 10_000;
+export const LOCAL_MEMORY_NOTE_BYTE_CAP = 32 * 1024 * 1024;
+export const LOCAL_MEMORY_READ_BYTE_CAP = 64 * 1024 * 1024;
+export const LOCAL_MEMORY_GENERATED_INDEX_PATTERN = /<!--\s*NOWWORK:MEMORY_INDEX:BEGIN\s+schema=[12]\s*-->[\s\S]*?<!--\s*NOWWORK:MEMORY_INDEX:END\s*-->/u;
+const length = (text) => {
+    let count = 0;
+    for (const _character of text)
+        count += 1;
+    return count;
+};
+const TYPES = new Set(["procedural", "semantic", "episodic", "preference"]);
+const STATUSES = new Set(["candidate", "active", "pinned", "stale", "superseded", "archived"]);
+const PRIORITIES = new Set(["high", "medium", "low"]);
+const FIELDS = new Set(["id", "file", "type", "status", "summary", "triggers", "priority", "revision", "anchor", "updated", "review_after"]);
+/** A malformed/unknown marker is never treated as an unmarked legacy file. */
+export function detectLocalMemoryStorageVersion(memory) {
+    const markerCount = (memory.match(/NOWWORK:MEMORY_INDEX:/gu) ?? []).length;
+    if (markerCount === 0)
+        return 0;
+    const block = LOCAL_MEMORY_GENERATED_INDEX_PATTERN.exec(memory);
+    if (markerCount !== 2 || block?.index === undefined)
+        throw new Error("local_memory_storage_version_invalid");
+    const headings = [...memory.matchAll(/^##[\t ]+Knowledge Index[\t ]*\r?$/gmu)];
+    const heading = headings[0];
+    if (headings.length !== 1 || heading?.index === undefined)
+        throw new Error("local_memory_storage_index_invalid");
+    const sectionStart = heading.index + heading[0].length;
+    const nextSection = /^##[\t ]+(?!#)/mu.exec(memory.slice(sectionStart));
+    const sectionEnd = nextSection?.index === undefined ? memory.length : sectionStart + nextSection.index;
+    if (block.index < sectionStart || block.index + block[0].length > sectionEnd) {
+        throw new Error("local_memory_storage_index_invalid");
+    }
+    return /schema=2\s*-->/u.test(block[0].slice(0, block[0].indexOf("\n") + 1) || block[0]) ? 2 : 1;
+}
+function validateEntry(entry) {
+    const singleLine = (value) => !/[\r\n\u0000-\u001f\u007f]/u.test(value)
+        && !/<!--/u.test(value);
+    if (!entry.title.trim() || !entry.summary.trim()
+        || ![entry.title, entry.summary, entry.updated, ...entry.triggers].every(singleLine)
+        || !/^[A-Za-z0-9_-]+$/u.test(entry.id) || entry.anchor !== entry.id
+        || !/^notes\/(?:preferences|project-rules|testing|debugging|git|incidents|lessons)\.md$/u.test(entry.file)
+        || !TYPES.has(entry.type) || !STATUSES.has(entry.status) || !PRIORITIES.has(entry.priority)
+        || !Number.isSafeInteger(entry.revision) || entry.revision < 1
+        || !entry.updated.trim()
+        || (entry.reviewAfter !== null && !singleLine(entry.reviewAfter))) {
+        throw new Error("local_memory_storage_entry_invalid");
+    }
+}
+function validateEntries(entries) {
+    if (entries.length > LOCAL_MEMORY_STORAGE_ENTRY_CAP)
+        throw new Error("local_memory_storage_entry_limit");
+    const ids = new Set();
+    for (const entry of entries) {
+        validateEntry(entry);
+        if (ids.has(entry.id))
+            throw new Error("local_memory_storage_duplicate_id");
+        ids.add(entry.id);
+    }
+}
+export function assertLocalMemoryStorageSize(memory) {
+    if (Buffer.byteLength(memory, "utf8") > LOCAL_MEMORY_STORAGE_BYTE_CAP)
+        throw new Error("local_memory_storage_byte_limit");
+}
+/** schema=2 stores every lifecycle state, unlike the schema=1 prompt projection. */
+export function parseFullMemoryIndex(memory) {
+    assertLocalMemoryStorageSize(memory);
+    if (detectLocalMemoryStorageVersion(memory) !== 2)
+        throw new Error("local_memory_storage_version_invalid");
+    const block = LOCAL_MEMORY_GENERATED_INDEX_PATTERN.exec(memory)[0];
+    const body = block.replace(/^<!--[^>]*-->\s*/u, "").replace(/<!--[^>]*-->$/u, "");
+    const headings = [...body.matchAll(/^###[\t ]+(.+?)[\t ]*\r?$/gmu)];
+    if (headings.length > LOCAL_MEMORY_STORAGE_ENTRY_CAP)
+        throw new Error("local_memory_storage_entry_limit");
+    if (body.slice(0, headings[0]?.index ?? body.length).trim())
+        throw new Error("local_memory_storage_entry_invalid");
+    const entries = headings.map((heading, index) => {
+        const fields = {};
+        const tail = body.slice(heading.index + heading[0].length, headings[index + 1]?.index ?? body.length);
+        for (const line of tail.split(/\r?\n/u)) {
+            if (!line.trim())
+                continue;
+            const field = /^-\s+([a-z][a-z_]*)\s*:\s*(.*?)\s*$/u.exec(line);
+            if (!field || !FIELDS.has(field[1]) || fields[field[1]] !== undefined)
+                throw new Error("local_memory_storage_entry_invalid");
+            fields[field[1]] = field[2];
+        }
+        if ([...FIELDS].filter(field => field !== "review_after").some(field => fields[field] === undefined)) {
+            throw new Error("local_memory_storage_entry_invalid");
+        }
+        if (!/^[1-9][0-9]*$/u.test(fields.revision))
+            throw new Error("local_memory_storage_entry_invalid");
+        return {
+            id: fields.id, title: heading[1], file: fields.file, type: fields.type,
+            status: fields.status, summary: fields.summary,
+            triggers: fields.triggers.split(/[,，、]/u).map(value => value.trim()).filter(Boolean),
+            priority: fields.priority, revision: Number(fields.revision),
+            anchor: fields.anchor, updated: fields.updated, reviewAfter: fields.review_after ?? null,
+        };
+    });
+    validateEntries(entries);
+    const section = memory.slice(memory.indexOf("## Knowledge Index") + "## Knowledge Index".length);
+    const remaining = section.replace(LOCAL_MEMORY_GENERATED_INDEX_PATTERN, "").split(/^##[\t ]+(?!#)/mu)[0] ?? "";
+    if (/^###[\t ]+/mu.test(remaining.replace(/<!--[\s\S]*?-->/gu, "")))
+        throw new Error("local_memory_legacy_index_requires_migration");
+    return entries;
+}
+export function renderFullMemoryIndex(entries) {
+    validateEntries(entries);
+    const block = `<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=2 -->\n${entries.map(renderLocalMemoryIndexCard).join("\n")}<!-- NOWWORK:MEMORY_INDEX:END -->`;
+    assertLocalMemoryStorageSize(block);
+    return block;
+}
+export function replaceFullMemoryIndex(memory, entries) {
+    if (detectLocalMemoryStorageVersion(memory) !== 2)
+        throw new Error("local_memory_storage_version_invalid");
+    const updated = memory.replace(LOCAL_MEMORY_GENERATED_INDEX_PATTERN, () => renderFullMemoryIndex(entries));
+    assertLocalMemoryStorageSize(updated);
+    return updated;
+}
+export function selectLocalMemoryPreview(memory, query = "", options = {}) {
+    const entries = parseFullMemoryIndex(memory);
+    const totalActiveEntries = entries.filter(entry => entry.status === "active" || entry.status === "pinned").length;
+    const emptyIndex = renderGeneratedIndex([]);
+    // Reserve the largest count label before selecting; all discovery text counts toward the same cap.
+    const hint = (shown) => `\nMemory preview: ${shown}/${totalActiveEntries} active entries. Use crew-memory search --query <text> and crew-memory read --file <file> for more.\n`;
+    const base = memory.replace(LOCAL_MEMORY_GENERATED_INDEX_PATTERN, () => `${emptyIndex}${hint(totalActiveEntries)}`);
+    const remaining = Math.min(LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, options.maxCodePoints ?? Infinity) - length(base);
+    const remainingBytes = (options.maxBytes ?? Infinity) - Buffer.byteLength(base, "utf8");
+    if (remaining < 0 || remainingBytes < 0 || Number.isNaN(remaining) || Number.isNaN(remainingBytes)) {
+        throw new Error("local_memory_identity_budget_exceeded");
+    }
+    const terms = query.normalize("NFKC").toLowerCase().split(/\s+/u).filter(Boolean);
+    const selection = selectLocalMemoryIndexEntries(entries, {
+        entryCap: LOCAL_MEMORY_INDEX_ENTRY_CAP,
+        indexCodePointCap: Math.min(LOCAL_MEMORY_INDEX_CODE_POINT_CAP - length(emptyIndex), remaining),
+        indexByteCap: remainingBytes,
+    }, {
+        protectedIds: new Set(entries.filter(entry => entry.status === "pinned").map(entry => entry.id)),
+        relevance: entry => {
+            const searchable = `${entry.title} ${entry.summary} ${entry.triggers.join(" ")}`.normalize("NFKC").toLowerCase();
+            return terms.filter(term => searchable.includes(term)).length;
+        },
+    });
+    if (selection.reason === "index_over_budget_pinned")
+        throw new Error("local_memory_pinned_budget_exceeded");
+    return {
+        ...selection, totalActiveEntries,
+        memory: memory.replace(LOCAL_MEMORY_GENERATED_INDEX_PATTERN, () => `${renderGeneratedIndex(selection.entries)}${hint(selection.entries.length)}`),
+    };
+}

package/dist/local-memory/write.js

@@ -6,6 +6,8 @@ import { dslog } from "../slog.js";
 import { LocalMemoryChangeSchema, LocalMemorySingleLineText, validateLocalMemoryChange, } from "./candidate.js";
 import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderGeneratedIndex, selectLocalMemoryIndexEntries, } from "./index-budget.js";
 import { persistPendingMemoryCandidate, readPendingMemoryCandidates, removePendingMemoryCandidate, } from "./pending.js";
+import { assertLocalMemoryStorageSize, detectLocalMemoryStorageVersion, LOCAL_MEMORY_GENERATED_INDEX_PATTERN, LOCAL_MEMORY_NOTE_BYTE_CAP, LOCAL_MEMORY_READ_BYTE_CAP, parseFullMemoryIndex, replaceFullMemoryIndex, selectLocalMemoryPreview, } from "./storage-format.js";
+import { assertMemoryWriterAllowed, withMemoryAccess } from "./migration-access.js";
 const StatusChangeSchema = z.object({
     memoryId: LocalMemorySingleLineText,
     expectedRevision: z.number().int().positive(),
@@ -90,12 +92,14 @@ function parseCards(section) {
     });
 }
 export function parseLocalMemoryIndex(memory) {
+    if (detectLocalMemoryStorageVersion(memory) === 2)
+        return parseFullMemoryIndex(memory);
     const section = indexSection(memory);
     const generated = GENERATED_INDEX_PATTERN.exec(section)?.[0];
     return parseCards(generated ?? section);
 }
 function parseUnmarkedMemoryIndex(memory) {
-    const section = indexSection(memory).replace(GENERATED_INDEX_PATTERN, "");
+    const section = indexSection(memory).replace(LOCAL_MEMORY_GENERATED_INDEX_PATTERN, "");
     return parseCards(section);
 }
 function replaceGeneratedIndex(memory, entries) {
@@ -122,11 +126,36 @@ function noteSection(id, revision, title, body) {
 }
 function notePattern(id) {
     const escaped = id.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-    return new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:BEGIN\\s+id=${escaped}[^>]*-->[\\s\\S]*?<!--\\s*NOWWORK:MEMORY_ENTRY:END\\s+id=${escaped}\\s*-->\\s*`, "u");
+    return new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:BEGIN\\s+id=${escaped}(?=\\s|-->)[^>]*-->[\\s\\S]*?<!--\\s*NOWWORK:MEMORY_ENTRY:END\\s+id=${escaped}\\s*-->\\s*`, "u");
+}
+function uniqueNoteSection(content, id) {
+    const escaped = id.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    const begins = [...content.matchAll(new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:BEGIN\\s+id=${escaped}(?=\\s|-->)`, "gu"))];
+    const ends = [...content.matchAll(new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:END\\s+id=${escaped}\\s*-->`, "gu"))];
+    if (begins.length === 0 && ends.length === 0)
+        return null;
+    const section = notePattern(id).exec(content)?.[0];
+    if (begins.length !== 1 || ends.length !== 1 || section === undefined
+        || (section.match(/NOWWORK:MEMORY_ENTRY:(?:BEGIN|END)/gu) ?? []).length !== 2) {
+        throw new Error("local_memory_note_anchor_invalid");
+    }
+    return section;
 }
 function replaceNote(content, id, replacement) {
     const pattern = notePattern(id);
-    return pattern.test(content) ? content.replace(pattern, replacement) : null;
+    return uniqueNoteSection(content, id) !== null ? content.replace(pattern, () => replacement) : null;
+}
+function updateNoteRevision(content, id, revision) {
+    const section = uniqueNoteSection(content, id);
+    const beginning = `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id} `;
+    const ending = `<!-- NOWWORK:MEMORY_ENTRY:END id=${id} -->`;
+    if (section === null || content.split(beginning).length !== 2 || content.split(ending).length !== 2) {
+        throw new Error("local_memory_note_anchor_missing");
+    }
+    const updated = section.replace(/^(<!--\s*NOWWORK:MEMORY_ENTRY:BEGIN\s+id=[A-Za-z0-9_-]+\s+revision=)[1-9][0-9]*(\s*-->)/u, (_match, prefix, suffix) => `${prefix}${revision}${suffix}`);
+    if (!updated.startsWith(`${beginning}revision=${revision} -->`))
+        throw new Error("local_memory_note_anchor_missing");
+    return content.replace(notePattern(id), () => updated);
 }
 function validateCandidate(result) {
     if (result.outcome === "no_change" && (result.changes.length > 0 || result.statusChanges.length > 0)) {
@@ -199,14 +228,14 @@ function detailCategoryFromFile(file) {
     return DETAIL_CATEGORIES.has(category) ? category : null;
 }
 function readNoteBody(content, id) {
-    const begin = content.indexOf(`<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id}`);
-    if (begin < 0)
+    const section = uniqueNoteSection(content, id);
+    if (section === null)
         return null;
-    const bodyStart = content.indexOf("\n\n", begin);
-    const bodyEnd = content.indexOf(`\n<!-- NOWWORK:MEMORY_ENTRY:END id=${id}`, bodyStart + 2);
+    const bodyStart = section.indexOf("\n\n");
+    const bodyEnd = section.indexOf(`\n<!-- NOWWORK:MEMORY_ENTRY:END id=${id}`, bodyStart + 2);
     if (bodyStart < 0 || bodyEnd < 0)
         return null;
-    return content.slice(bodyStart + 2, bodyEnd).trim();
+    return section.slice(bodyStart + 2, bodyEnd).trim();
 }
 function archivedChange(entry, detailBody) {
     const detailCategory = detailCategoryFromFile(entry.file);
@@ -244,12 +273,29 @@ async function assertWritablePaths(agentDir, memoryPath) {
     if (!memoryStat.isFile() || memoryStat.isSymbolicLink())
         throw new Error("local_memory_memory_path_invalid");
 }
+async function assertMemoryAccessDirectory(agentDir) {
+    try {
+        const stat = await lstat(join(agentDir, ".crew/memory"));
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error("local_memory_pending_path_invalid");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+}
 async function readNote(path) {
     try {
         const stat = await lstat(path);
         if (!stat.isFile() || stat.isSymbolicLink())
             throw new Error("local_memory_note_path_invalid");
-        return await readFile(path, "utf8");
+        if (stat.size > LOCAL_MEMORY_NOTE_BYTE_CAP)
+            throw new Error("local_memory_note_byte_limit");
+        const content = await readFile(path, "utf8");
+        if (Buffer.byteLength(content, "utf8") > LOCAL_MEMORY_NOTE_BYTE_CAP)
+            throw new Error("local_memory_note_byte_limit");
+        return content;
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -269,6 +315,11 @@ async function atomicWrite(path, content) {
     }
 }
 function projectIndex(memory, entries, protectedIds) {
+    if (detectLocalMemoryStorageVersion(memory) === 2) {
+        const updated = replaceFullMemoryIndex(memory, entries);
+        selectLocalMemoryPreview(updated);
+        return { memory: updated, omittedIds: [], reason: null };
+    }
     const empty = replaceGeneratedIndex(memory, []);
     if (codePointLength(empty) > LOCAL_MEMORY_TOTAL_CODE_POINT_CAP)
         throw new Error("local_memory_memory_over_budget");
@@ -310,8 +361,15 @@ export async function applyLocalMemoryResult(input) {
         return emptyResult();
     const memoryPath = join(input.agentDir, "MEMORY.md");
     await assertWritablePaths(input.agentDir, memoryPath);
-    return withApplyLease(input.agentDir, async () => {
+    await assertMemoryAccessDirectory(input.agentDir);
+    return withApplyLease(input.agentDir, async () => withMemoryAccess(input.agentDir, async () => {
+        await assertMemoryWriterAllowed(input.agentDir, input.writerCapabilities ?? []);
+        const memoryStat = await lstat(memoryPath);
+        if (memoryStat.size > 16 * 1024 * 1024)
+            throw new Error("local_memory_storage_byte_limit");
         const memory = await readFile(memoryPath, "utf8");
+        assertLocalMemoryStorageSize(memory);
+        const fullStorage = detectLocalMemoryStorageVersion(memory) === 2;
         if (parseUnmarkedMemoryIndex(memory).length > 0)
             throw new Error("local_memory_legacy_index_requires_migration");
         let entries = [...parseLocalMemoryIndex(memory)];
@@ -342,6 +400,26 @@ export async function applyLocalMemoryResult(input) {
         const pendingCandidates = [];
         const resolvedPendingIds = new Set();
         const noteUpdates = new Map();
+        const noteCache = new Map();
+        let totalReadBytes = Buffer.byteLength(memory, "utf8");
+        const readStoredNote = async (path) => {
+            const cached = noteUpdates.get(path) ?? noteCache.get(path);
+            if (cached !== undefined)
+                return cached;
+            const stat = await lstat(path).catch((error) => {
+                if (error.code === "ENOENT")
+                    return null;
+                throw error;
+            });
+            if (stat !== null && totalReadBytes + stat.size > LOCAL_MEMORY_READ_BYTE_CAP)
+                throw new Error("local_memory_read_byte_limit");
+            const content = await readNote(path);
+            totalReadBytes += Buffer.byteLength(content, "utf8");
+            if (totalReadBytes > LOCAL_MEMORY_READ_BYTE_CAP)
+                throw new Error("local_memory_read_byte_limit");
+            noteCache.set(path, content);
+            return content;
+        };
         let allowActiveEviction = false;
         const randomId = input.randomId ?? randomUUID;
         const executionId = input.executionId ?? "unknown";
@@ -383,10 +461,21 @@ export async function applyLocalMemoryResult(input) {
                 if (existingCreate !== undefined && !matchesCreateCandidate(existingCreate, change)) {
                     throw new Error("local_memory_duplicate_candidate");
                 }
-                if (existingCreate === undefined && entries.some((entry) => normalize(entry.title) === normalize(change.title)
-                    || normalize(entry.summary) === normalize(change.summary))) {
+                if (existingCreate === undefined && entries.some((entry) => (!fullStorage || entry.status === "active" || entry.status === "pinned")
+                    && (normalize(entry.title) === normalize(change.title) || normalize(entry.summary) === normalize(change.summary)))) {
                     throw new Error("local_memory_duplicate_candidate");
                 }
+                if (existingCreate !== undefined) {
+                    if (existingCreate.revision !== 1 || existingCreate.status !== "active") {
+                        throw new Error("local_memory_create_replay_conflict");
+                    }
+                    const stored = await readStoredNote(resolve(input.agentDir, existingCreate.file));
+                    if (uniqueNoteSection(stored, id)?.trimEnd() !== noteSection(id, 1, change.title, change.detailBody).trimEnd()) {
+                        throw new Error("local_memory_create_replay_conflict");
+                    }
+                    // A proven duplicate is a no-op; it must never rewrite a newer body or status.
+                    continue;
+                }
             }
             const revision = existingCreate?.revision ?? (current === undefined ? 1 : current.revision + 1);
             const entry = existingCreate ?? entryFromChange(change, id, revision, current?.status ?? "active");
@@ -400,7 +489,7 @@ export async function applyLocalMemoryResult(input) {
                             : item),
                         entry,
                     ];
-            const allowEvictionForChange = change.operation === "create" && change.priority === "high";
+            const allowEvictionForChange = !fullStorage && change.operation === "create" && change.priority === "high";
             const protectedIds = new Set(allowEvictionForChange ? pinnedIds(entries) : activeOrPinnedIds(entries));
             if (allowEvictionForChange)
                 allowActiveEviction = true;
@@ -417,7 +506,7 @@ export async function applyLocalMemoryResult(input) {
             const notePath = resolve(input.agentDir, entry.file);
             if (!isWithin(resolve(input.agentDir, "notes"), notePath))
                 throw new Error("local_memory_note_path_invalid");
-            const previous = noteUpdates.get(notePath) ?? await readNote(notePath);
+            const previous = await readStoredNote(notePath);
             const replacement = noteSection(id, revision, change.title, change.detailBody);
             const existingSection = replaceNote(previous, id, replacement);
             const next = existingSection ?? (current === undefined
@@ -435,7 +524,7 @@ export async function applyLocalMemoryResult(input) {
         // Pending create candidates are durable overflow, not dead ends. Promote only
         // when the current catalog has room; supersede/update candidates stay pending
         // until a fresh revision-aware decision can safely replay them.
-        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir }).catch((error) => {
+        const pendingCandidatesOnDisk = fullStorage ? [] : await readPendingMemoryCandidates({ agentDir: input.agentDir }).catch((error) => {
             if (!(error instanceof Error) || error.message !== "memory_pending_directory_over_budget")
                 throw error;
             // 自动提升是可选工作，目录查询预算不应阻断本轮已验证的更新或腾位操作。
@@ -460,7 +549,7 @@ export async function applyLocalMemoryResult(input) {
                     || normalize(entry.summary) === normalize(change.summary)));
             if (duplicate !== undefined) {
                 const duplicatePath = resolve(input.agentDir, duplicate.file);
-                const duplicateBody = readNoteBody(noteUpdates.get(duplicatePath) ?? await readNote(duplicatePath), duplicate.id);
+                const duplicateBody = readNoteBody(await readStoredNote(duplicatePath), duplicate.id);
                 if (duplicateBody === change.detailBody
                     || duplicateBody === unwrappedNoteBody(change.title, change.detailBody).trim()) {
                     resolvedPendingIds.add(pending.pendingId);
@@ -478,7 +567,7 @@ export async function applyLocalMemoryResult(input) {
             const notePath = resolve(input.agentDir, entry.file);
             if (!isWithin(resolve(input.agentDir, "notes"), notePath))
                 throw new Error("local_memory_note_path_invalid");
-            const previous = noteUpdates.get(notePath) ?? await readNote(notePath);
+            const previous = await readStoredNote(notePath);
             const replacement = noteSection(id, 1, change.title, change.detailBody);
             const existingSection = replaceNote(previous, id, replacement);
             const next = existingSection ?? `${previous.trimEnd()}${previous.trimEnd() ? "\n\n" : ""}${replacement}`;
@@ -487,6 +576,17 @@ export async function applyLocalMemoryResult(input) {
             createdIds.push(id);
             resolvedPendingIds.add(pending.pendingId);
         }
+        if (fullStorage) {
+            const changedMetadataIds = new Set([
+                ...statusChangedIds,
+                ...input.result.changes.flatMap(change => change.supersedesMemoryId === null ? [] : [change.supersedesMemoryId]),
+            ]);
+            for (const id of changedMetadataIds) {
+                const entry = entries.find(item => item.id === id);
+                const notePath = resolve(input.agentDir, entry.file);
+                noteUpdates.set(notePath, updateNoteRevision(await readStoredNote(notePath), id, entry.revision));
+            }
+        }
         let finalProjection = projectIndex(memory, entries, allowActiveEviction ? pinnedIds(entries) : activeOrPinnedIds(entries));
         if (finalProjection.reason !== null
             && (!allowActiveEviction || finalProjection.reason === "index_over_budget_pinned")) {
@@ -498,7 +598,7 @@ export async function applyLocalMemoryResult(input) {
                 .filter((entry) => entry?.status === "active");
             for (const entry of omittedActiveEntries) {
                 const notePath = resolve(input.agentDir, entry.file);
-                const content = noteUpdates.get(notePath) ?? await readNote(notePath);
+                const content = await readStoredNote(notePath);
                 const detailBody = readNoteBody(content, entry.id);
                 const change = detailBody === null ? null : archivedChange(entry, detailBody);
                 if (change === null)
@@ -519,6 +619,12 @@ export async function applyLocalMemoryResult(input) {
             if (finalProjection.reason !== null)
                 throw new Error(finalProjection.reason);
         }
+        // Complete every resource check before the first persistent write.
+        assertLocalMemoryStorageSize(finalProjection.memory);
+        for (const content of noteUpdates.values()) {
+            if (Buffer.byteLength(content, "utf8") > LOCAL_MEMORY_NOTE_BYTE_CAP)
+                throw new Error("local_memory_note_byte_limit");
+        }
         for (const candidate of pendingCandidates)
             await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
         for (const [path, content] of noteUpdates)
@@ -535,5 +641,5 @@ export async function applyLocalMemoryResult(input) {
             deferredIds,
             pendingIds: deferredIds,
         };
-    });
+    }));
 }

package/dist/local-memory-diagnostics.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { readFile, stat } from "node:fs/promises";
+import { lstat, readFile, readdir, stat } from "node:fs/promises";
 import { isAbsolute, join, normalize, relative, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { capMemoryForInject, MEMORY_INJECT_CAP } from "./prompt.js";
@@ -39,13 +39,52 @@ async function inspectFile(path, signal) {
         return { ...base, error_code: errorCode(error) };
     }
 }
+async function inspectPendingDirectory(path, signal) {
+    let metadata;
+    try {
+        metadata = await lstat(path);
+    }
+    catch (error) {
+        const code = errorCode(error);
+        return code === "ENOENT" ? { exists: false, entry_count: 0 } : { exists: false, error_code: code };
+    }
+    const base = { exists: true, mtime_ms: metadata.mtimeMs };
+    if (metadata.isSymbolicLink() || !metadata.isDirectory())
+        return { ...base, hash_skipped_reason: "not_regular_file" };
+    try {
+        const names = (await readdir(path, { withFileTypes: true }))
+            .filter(entry => entry.name.endsWith(".json"))
+            .sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+        if (names.length > 128)
+            return { ...base, entry_count: names.length, error_code: "entry_limit" };
+        const hash = createHash("sha256");
+        let size = 0;
+        for (const entry of names) {
+            if (signal.aborted)
+                throw signal.reason;
+            if (!entry.isFile() || entry.isSymbolicLink())
+                return { ...base, entry_count: names.length, error_code: "invalid_entry" };
+            const fact = await inspectFile(join(path, entry.name), signal);
+            if (!fact.exists || fact.sha256 === undefined || fact.error_code !== undefined
+                || fact.hash_skipped_reason !== undefined)
+                return { ...base, entry_count: names.length, error_code: "incomplete_entry" };
+            size += fact.size_bytes ?? 0;
+            hash.update(entry.name).update("\0").update(fact.sha256).update("\0");
+        }
+        return { ...base, size_bytes: size, entry_count: names.length, sha256: hash.digest("hex") };
+    }
+    catch (error) {
+        return { ...base, error_code: errorCode(error) };
+    }
+}
 export async function inspectLocalMemoryFilesWithinDeadline(homeDir, timeoutMs) {
     const controller = new AbortController();
     let timer;
     const inspection = Promise.all([
         inspectFile(join(homeDir, "MEMORY.md"), controller.signal),
         inspectFile(join(homeDir, "notes", "lessons.md"), controller.signal),
-    ]).then(([memory, lessons]) => ({ memory, lessons }));
+        inspectPendingDirectory(join(homeDir, ".crew", "memory", "pending"), controller.signal),
+    ]).then(([memory, lessons, pending]) => ({ memory, lessons, pending }));
     const timeout = new Promise((_resolve, reject) => {
         timer = setTimeout(() => {
             controller.abort();

package/dist/local-memory-telemetry.js

@@ -38,6 +38,7 @@ export function logLocalMemoryDiagnosticsFailure(identity, phase, error) {
 function snapshotFields(snapshot) {
     if (snapshot === null)
         return {};
+    const pending = snapshot.pending ?? { exists: false, entry_count: 0 };
     return {
         memory_exists: snapshot.memory.exists,
         memory_size_bytes: snapshot.memory.size_bytes,
@@ -54,6 +55,12 @@ function snapshotFields(snapshot) {
         lessons_hash_skipped_reason: snapshot.lessons.hash_skipped_reason,
         lessons_error_code: snapshot.lessons.error_code,
         lessons_markdown_heading_count: snapshot.lessons.markdown_heading_count,
+        pending_exists: pending.exists,
+        pending_size_bytes: pending.size_bytes,
+        pending_mtime_ms: pending.mtime_ms,
+        pending_sha256: pending.sha256,
+        pending_error_code: pending.error_code,
+        pending_entry_count: pending.entry_count,
     };
 }
 function promptDelivery(runtime, stableProtocolRuntime) {
@@ -183,10 +190,13 @@ export function createLocalMemoryTelemetry(options) {
             const lessonsChanged = beforeSnapshot !== null && afterSnapshot !== null
                 ? localMemoryFileChanged(beforeSnapshot.lessons, afterSnapshot.lessons)
                 : undefined;
+            const pendingChanged = beforeSnapshot !== null && afterSnapshot !== null
+                ? localMemoryFileChanged(beforeSnapshot.pending ?? { exists: false }, afterSnapshot.pending ?? { exists: false })
+                : undefined;
             const accessSummary = accessObserver.summary();
-            const sharedFilesChanged = memoryChanged === undefined || lessonsChanged === undefined
+            const sharedFilesChanged = memoryChanged === undefined || lessonsChanged === undefined || pendingChanged === undefined
                 ? undefined
-                : memoryChanged || lessonsChanged;
+                : memoryChanged || lessonsChanged || pendingChanged;
             safeLog("local_memory.execution_observed", "本地记忆执行观察已完成", {
                 execution_id: options.executionId,
                 agent_handle: options.agentHandle,
@@ -200,6 +210,7 @@ export function createLocalMemoryTelemetry(options) {
                 executor_outcome: executorCompleted ? "succeeded" : "failed",
                 memory_changed: memoryChanged,
                 lessons_changed: lessonsChanged,
+                pending_changed: pendingChanged,
                 shared_files_changed_during_execution: sharedFilesChanged,
                 unexpected_shared_write: options.isMemoryPrune
                     ? undefined
@@ -224,6 +235,12 @@ export function createLocalMemoryTelemetry(options) {
                     lessons_after_hash_skipped_reason: afterSnapshot.lessons.hash_skipped_reason,
                     lessons_after_error_code: afterSnapshot.lessons.error_code,
                     lessons_after_markdown_heading_count: afterSnapshot.lessons.markdown_heading_count,
+                    pending_after_exists: afterSnapshot.pending?.exists ?? false,
+                    pending_after_size_bytes: afterSnapshot.pending?.size_bytes,
+                    pending_after_mtime_ms: afterSnapshot.pending?.mtime_ms,
+                    pending_after_sha256: afterSnapshot.pending?.sha256,
+                    pending_after_error_code: afterSnapshot.pending?.error_code,
+                    pending_after_entry_count: afterSnapshot.pending?.entry_count ?? 0,
                 }),
             });
         },

package/dist/machine-info.js

@@ -25,6 +25,7 @@ import { RUNTIME_HEALTH_PROBE_CAPABILITY } from "./runtime-health.js";
 import { probeDeepSeekHarnessAcp, deepSeekHarnessLauncher } from "./runtimes/deepseek-harness.js";
 import { daemonHome } from "./computer-profile.js";
 import { daemonReleaseProvenance } from "./release-provenance.js";
+import { MEMORY_MIGRATION_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY, MEMORY_STATE_GUARD_CAPABILITY } from "./memory-migration-protocol.js";
 export { executableRuntimes } from "./runtime-capabilities.js";
 const execFileP = promisify(execFile);
 export const PROJECT_WORKSPACES_CAPABILITY = "project_workspaces_v1";
@@ -39,6 +40,7 @@ export const NATIVE_PROJECT_WORKSPACE_READINESS = Object.freeze({
 });
 export const DAEMON_CAPABILITIES = Object.freeze([
     MARKETPLACE_CAPABILITY,
+    MEMORY_MIGRATION_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY, MEMORY_STATE_GUARD_CAPABILITY,
     "scheduled_job_v1",
     "reply_origin_v1",
     "origin_decision_v1",
@@ -73,6 +75,7 @@ export const daemonCapabilities = (runtimePlatform = process.platform, readiness
     return Object.freeze(DAEMON_CAPABILITIES.filter((capability) => ((capability !== MARKETPLACE_CAPABILITY || nativeWorkspacePlatform)
         && (capability !== PROJECT_WORKSPACES_CAPABILITY || nativeWorkspaceReady)
         && (capability !== "message_file_preview_v1" || nativeWorkspacePlatform)
+        && (nativeWorkspacePlatform || ![MEMORY_MIGRATION_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY, MEMORY_STATE_GUARD_CAPABILITY].includes(capability))
         && (nativeWorkspacePlatform
             || (capability !== "project_skills_v1"
                 && capability !== "project_skill_projection_v2"