@nowcrew/daemon 0.6.93-beta.7 → 0.6.93-beta.8

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");
@@ -306,12 +357,27 @@ async function withApplyLease(agentDir, operation) {
 }
 export async function applyLocalMemoryResult(input) {
     validateCandidate(input.result);
-    if (input.result.outcome !== "proposed")
+    if (input.result.outcome !== "proposed" && input.requiredStorageVersion !== 2)
         return emptyResult();
     const memoryPath = join(input.agentDir, "MEMORY.md");
-    await assertWritablePaths(input.agentDir, memoryPath);
-    return withApplyLease(input.agentDir, async () => {
+    if (input.result.outcome === "proposed")
+        await assertWritablePaths(input.agentDir, memoryPath);
+    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 (input.requiredStorageVersion === 2 && !fullStorage) {
+            throw new Error("local_memory_v2_state_invalid_before_commit");
+        }
+        // A V2 no-op is still a commit decision.  Return only after the access
+        // lock and committed-state writer gate have validated the same snapshot.
+        if (input.result.outcome !== "proposed")
+            return emptyResult();
         if (parseUnmarkedMemoryIndex(memory).length > 0)
             throw new Error("local_memory_legacy_index_requires_migration");
         let entries = [...parseLocalMemoryIndex(memory)];
@@ -342,6 +408,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 +469,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 +497,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 +514,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 +532,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 +557,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 +575,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 +584,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 +606,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 +627,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 +649,5 @@ export async function applyLocalMemoryResult(input) {
             deferredIds,
             pendingIds: deferredIds,
         };
-    });
+    }));
 }

package/dist/local-memory/writer-mode.js

@@ -0,0 +1,13 @@
+import { detectLocalMemoryStorageVersion } from "./storage-format.js";
+/** Resolve format and rollout into one writer decision before a prune result is requested. */
+export function resolveLocalMemoryWriterMode(workspace, rollout) {
+    if (rollout.legacyFallback)
+        return "legacy";
+    if (!rollout.enabled)
+        return rollout.deferred ? "blocked" : "legacy";
+    // Production workspaces always report this fact. Historical partial unit
+    // callers retain their already-resolved rollout witness.
+    if (workspace.localMemoryV2Initialized === undefined)
+        return "v2";
+    return detectLocalMemoryStorageVersion(workspace.memory) === 2 ? "v2" : "blocked";
+}

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";
@@ -8,6 +8,7 @@ const INJECTION_MARKERS = [
     "## [注入] 你的 MEMORY.md(索引,只读参考)\n",
 ];
 const LOCAL_MEMORY_HASH_CAP_BYTES = 10 * 1024 * 1024;
+export const LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS = 2_000;
 function errorCode(error) {
     const code = error?.code;
     return typeof code === "string" ? code : error instanceof Error ? error.name : "unknown";
@@ -39,30 +40,75 @@ async function inspectFile(path, signal) {
         return { ...base, error_code: errorCode(error) };
     }
 }
-export async function inspectLocalMemoryFilesWithinDeadline(homeDir, timeoutMs) {
+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 withinLocalMemoryDiagnosticsDeadline(operation, 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 }));
     const timeout = new Promise((_resolve, reject) => {
         timer = setTimeout(() => {
-            controller.abort();
-            reject(Object.assign(new Error("local memory diagnostics timed out"), {
+            const error = Object.assign(new Error("local memory diagnostics timed out"), {
                 code: "diagnostics_timeout",
-            }));
+            });
+            controller.abort(error);
+            reject(error);
         }, Math.max(1, timeoutMs));
         timer.unref?.();
     });
     try {
-        return await Promise.race([inspection, timeout]);
+        return await Promise.race([operation(controller.signal), timeout]);
     }
     finally {
         if (timer !== undefined)
             clearTimeout(timer);
     }
 }
+export async function inspectLocalMemoryFilesWithinDeadline(homeDir, timeoutMs) {
+    return withinLocalMemoryDiagnosticsDeadline(async (signal) => {
+        const [memory, lessons, pending] = await Promise.all([
+            inspectFile(join(homeDir, "MEMORY.md"), signal),
+            inspectFile(join(homeDir, "notes", "lessons.md"), signal),
+            inspectPendingDirectory(join(homeDir, ".crew", "memory", "pending"), signal),
+        ]);
+        return { memory, lessons, pending };
+    }, timeoutMs);
+}
 export function localMemoryContentFacts(content, maxScanBytes = LOCAL_MEMORY_HASH_CAP_BYTES) {
     const sizeBytes = Buffer.byteLength(content, "utf8");
     if (sizeBytes > Math.max(0, maxScanBytes)) {
@@ -217,15 +263,50 @@ function crewMemoryReadAccess(command, paths) {
         return null;
     }
 }
+/**
+ * Decode only the shell wrapper shape emitted by supported runtimes. The body must be one complete
+ * quoted argument. Double-quoted bodies may escape only a quote or backslash; shell expansion and
+ * concatenated quoting stay unknown so telemetry never guesses what the shell actually executed.
+ */
+function unwrapLiteralShellCommand(command) {
+    const trimmed = command.trim();
+    const wrapper = /^\/bin\/(?:(?:zsh|bash)\s+-lc|sh\s+-c)\s+([\s\S]+)$/u.exec(trimmed);
+    if (wrapper === null)
+        return trimmed;
+    const quoted = wrapper[1];
+    const quote = quoted[0];
+    if ((quote !== "'" && quote !== '"') || quoted.at(-1) !== quote || quoted.length < 2)
+        return null;
+    const body = quoted.slice(1, -1);
+    if (quote === "'")
+        return body.includes("'") ? null : body;
+    let decoded = "";
+    for (let index = 0; index < body.length; index += 1) {
+        const character = body[index];
+        if (character === '"' || character === "$" || character === "`")
+            return null;
+        if (character !== "\\") {
+            decoded += character;
+            continue;
+        }
+        const escaped = body[index + 1];
+        if (escaped !== '"' && escaped !== "\\")
+            return null;
+        decoded += escaped;
+        index += 1;
+    }
+    return decoded;
+}
 function commandAccesses(command, paths) {
-    if (/[;|&\n]/.test(command))
+    const unwrapped = unwrapLiteralShellCommand(command);
+    if (unwrapped === null || /[;|&\n]/.test(unwrapped))
         return [];
     const accesses = new Map();
-    const memoryRead = crewMemoryReadAccess(command, paths);
+    const memoryRead = crewMemoryReadAccess(unwrapped, paths);
     if (memoryRead !== null) {
         accesses.set(`${memoryRead.target}:${memoryRead.relative_path ?? ""}:read`, memoryRead);
     }
-    const expanded = command
+    const expanded = unwrapped
         .replaceAll("${CREW_HOME}", paths.homeDir)
         .replaceAll("$CREW_HOME", paths.homeDir)
         .replace(/["']/g, "");