@nowcrew/daemon 0.6.99-beta.2 → 0.6.99-beta.3

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 { assertMemoryInventoryHealth, 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)) {
@@ -180,6 +209,25 @@ function stableId(executionId, index, change) {
     const input = [executionId, String(index), change.operation, change.title, change.summary, change.detailBody].join("\0");
     return `mem_${createHash("sha256").update(input, "utf8").digest("hex").slice(0, 12)}`;
 }
+function migrationPendingId(change) {
+    // Keep the digest independent of object insertion order for callers that
+    // reach applyLocalMemoryResult directly instead of the JSON/Zod boundary.
+    const canonicalChange = {
+        operation: change.operation,
+        memoryId: change.memoryId,
+        baseRevision: change.baseRevision,
+        supersedesMemoryId: change.supersedesMemoryId,
+        title: change.title,
+        kind: change.kind,
+        summary: change.summary,
+        triggers: change.triggers,
+        priority: change.priority,
+        detailCategory: change.detailCategory,
+        detailBody: change.detailBody,
+        reviewAfter: change.reviewAfter,
+    };
+    return `pending-migration-${createHash("sha256").update(JSON.stringify(canonicalChange), "utf8").digest("hex").slice(0, 12)}`;
+}
 function normalize(value) {
     return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
 }
@@ -199,14 +247,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);
@@ -230,6 +278,34 @@ function archivedChange(entry, detailBody) {
 function emptyResult() {
     return { createdIds: [], updatedIds: [], statusChangedIds: [], deferredIds: [], pendingIds: [] };
 }
+async function stageMigrationDeferredPending(input) {
+    if (input.result.outcome !== "proposed")
+        return emptyResult();
+    if (input.result.statusChanges.length > 0 || input.result.changes.some((change) => change.operation !== "create")) {
+        throw new Error("local_memory_migration_pending_create_only");
+    }
+    const executionId = input.executionId ?? "unknown";
+    const pending = input.result.changes.map((change) => ({
+        schemaVersion: 1,
+        pendingId: migrationPendingId(change),
+        createdAt: new Date().toISOString(),
+        reason: "legacy_requires_migration",
+        source: { executionId, pruneTraceId: input.pruneTraceId ?? null },
+        candidate: change,
+    }));
+    await assertMemoryAccessDirectory(input.agentDir);
+    await withMemoryAccess(input.agentDir, async () => {
+        const memory = await readFile(join(input.agentDir, "MEMORY.md"), "utf8").catch(() => null);
+        if (memory === null || detectLocalMemoryStorageVersion(memory) !== 1) {
+            throw new Error("local_memory_migration_pending_storage_invalid");
+        }
+        for (const candidate of pending) {
+            await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
+        }
+    }, { pendingOnly: true });
+    const pendingIds = [...new Set(pending.map((candidate) => candidate.pendingId))];
+    return { createdIds: [], updatedIds: [], statusChangedIds: [], deferredIds: pendingIds, pendingIds };
+}
 function isWithin(root, candidate) {
     const path = relative(root, candidate);
     return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
@@ -244,12 +320,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 +362,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 +404,29 @@ async function withApplyLease(agentDir, operation) {
 }
 export async function applyLocalMemoryResult(input) {
     validateCandidate(input.result);
-    if (input.result.outcome !== "proposed")
+    if (input.migrationDeferredPending)
+        return stageMigrationDeferredPending(input);
+    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 +457,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 +518,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 +546,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 +563,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 +581,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;
             // 自动提升是可选工作，目录查询预算不应阻断本轮已验证的更新或腾位操作。
@@ -446,6 +592,10 @@ export async function applyLocalMemoryResult(input) {
             return [];
         });
         for (const pending of pendingCandidatesOnDisk) {
+            // Migration-deferred candidates require reviewed import; only capacity
+            // overflow is eligible for the existing automatic promotion path.
+            if (pending.reason !== "index_over_budget")
+                continue;
             const change = pending.candidate;
             if (change.operation !== "create")
                 continue;
@@ -460,7 +610,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 +628,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 +637,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 +659,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 +680,13 @@ 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");
+        }
+        await assertMemoryInventoryHealth(input.agentDir);
         for (const candidate of pendingCandidates)
             await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
         for (const [path, content] of noteUpdates)
@@ -535,5 +703,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)) {
@@ -76,12 +122,12 @@ export function localMemoryContentFacts(content, maxScanBytes = LOCAL_MEMORY_HAS
         lessons_reference_count: content.match(/\bnotes[\\/]lessons\.md\b/gi)?.length ?? 0,
     };
 }
-export function analyzeLocalMemoryInjection(systemPrompt, sourceMemory) {
+export function analyzeLocalMemoryInjection(systemPrompt, sourceMemory, query = "") {
     const sourceBytes = Buffer.byteLength(sourceMemory, "utf8");
     if (sourceMemory.length === 0) {
         return { state: "empty_source", source_bytes: 0, bounded_bytes: 0, injected_bytes: 0 };
     }
-    const bounded = capMemoryForInject(sourceMemory);
+    const bounded = capMemoryForInject(sourceMemory, undefined, Number.POSITIVE_INFINITY, query);
     const marker = INJECTION_MARKERS.find((candidate) => systemPrompt.includes(candidate));
     if (marker === undefined) {
         return {
@@ -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, "");

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) {
@@ -103,7 +110,7 @@ export function createLocalMemoryTelemetry(options) {
         contextPrepared(context) {
             try {
                 const sourceFacts = localMemoryContentFacts(context.memory);
-                const injectionFacts = analyzeLocalMemoryInjection(context.systemPrompt, context.memory);
+                const injectionFacts = analyzeLocalMemoryInjection(context.systemPrompt, context.memory, context.memoryQuery);
                 safeLog("local_memory.context_prepared", "本地记忆上下文已准备", {
                     execution_id: options.executionId,
                     agent_handle: options.agentHandle,
@@ -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";
@@ -40,6 +41,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",
@@ -75,6 +77,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"

package/dist/marketplace-protocol.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 // 与另一个进程中的 marketplace-protocol.ts 保持一致；跨进程契约测试校验摘要。
 export const MARKETPLACE_CAPABILITY = "marketplace_update_v1";
 export const MARKETPLACE = "nowwork-pm";
-export const PLUGIN = "AIinterview-plugin";
+export const PLUGIN = "aiinterview-plugin";
 export const MarketplaceModeSchema = z.enum(["inspect", "refresh", "update"]);
 export const MarketplaceStatusSchema = z.enum(["queued", "running", "completed", "partial", "failed", "unknown"]);
 export const MarketplaceTargetSchema = z.object({