@nowcrew/daemon 0.6.101-beta.6 → 0.6.101-beta.8

package/dist/local-memory/write.js

@@ -6,8 +6,6 @@ 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(),
@@ -22,7 +20,6 @@ const ResultSchema = z.object({
     outcome: z.enum(["no_change", "proposed", "conflict", "failed"]),
     changes: z.array(LocalMemoryChangeSchema).max(50),
     statusChanges: z.array(StatusChangeSchema).max(50),
-    workLogDisposition: z.enum(["clear", "preserve"]).optional(),
 }).strict();
 const GENERATED_INDEX_PATTERN = /<!--\s*NOWWORK:MEMORY_INDEX:BEGIN\s+schema=1\s*-->[\s\S]*?<!--\s*NOWWORK:MEMORY_INDEX:END\s*-->/u;
 const INDEX_HEADING = /^##\s+Knowledge Index\s*$/mu;
@@ -93,14 +90,12 @@ 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(LOCAL_MEMORY_GENERATED_INDEX_PATTERN, "");
+    const section = indexSection(memory).replace(GENERATED_INDEX_PATTERN, "");
     return parseCards(section);
 }
 function replaceGeneratedIndex(memory, entries) {
@@ -127,36 +122,11 @@ 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]*?<!--\\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;
+    return new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:BEGIN\\s+id=${escaped}[^>]*-->[\\s\\S]*?<!--\\s*NOWWORK:MEMORY_ENTRY:END\\s+id=${escaped}\\s*-->\\s*`, "u");
 }
 function replaceNote(content, id, replacement) {
     const pattern = notePattern(id);
-    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);
+    return pattern.test(content) ? content.replace(pattern, replacement) : null;
 }
 function validateCandidate(result) {
     if (result.outcome === "no_change" && (result.changes.length > 0 || result.statusChanges.length > 0)) {
@@ -210,25 +180,6 @@ 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();
 }
@@ -248,14 +199,14 @@ function detailCategoryFromFile(file) {
     return DETAIL_CATEGORIES.has(category) ? category : null;
 }
 function readNoteBody(content, id) {
-    const section = uniqueNoteSection(content, id);
-    if (section === null)
+    const begin = content.indexOf(`<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id}`);
+    if (begin < 0)
         return null;
-    const bodyStart = section.indexOf("\n\n");
-    const bodyEnd = section.indexOf(`\n<!-- NOWWORK:MEMORY_ENTRY:END id=${id}`, bodyStart + 2);
+    const bodyStart = content.indexOf("\n\n", begin);
+    const bodyEnd = content.indexOf(`\n<!-- NOWWORK:MEMORY_ENTRY:END id=${id}`, bodyStart + 2);
     if (bodyStart < 0 || bodyEnd < 0)
         return null;
-    return section.slice(bodyStart + 2, bodyEnd).trim();
+    return content.slice(bodyStart + 2, bodyEnd).trim();
 }
 function archivedChange(entry, detailBody) {
     const detailCategory = detailCategoryFromFile(entry.file);
@@ -279,34 +230,6 @@ 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}`));
@@ -321,29 +244,12 @@ 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");
-        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;
+        return await readFile(path, "utf8");
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -363,11 +269,6 @@ 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");
@@ -405,29 +306,12 @@ async function withApplyLease(agentDir, operation) {
 }
 export async function applyLocalMemoryResult(input) {
     validateCandidate(input.result);
-    if (input.migrationDeferredPending)
-        return stageMigrationDeferredPending(input);
-    if (input.result.outcome !== "proposed" && input.requiredStorageVersion !== 2)
+    if (input.result.outcome !== "proposed")
         return emptyResult();
     const memoryPath = join(input.agentDir, "MEMORY.md");
-    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");
+    await assertWritablePaths(input.agentDir, memoryPath);
+    return withApplyLease(input.agentDir, async () => {
         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)];
@@ -458,26 +342,6 @@ 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";
@@ -519,21 +383,10 @@ export async function applyLocalMemoryResult(input) {
                 if (existingCreate !== undefined && !matchesCreateCandidate(existingCreate, change)) {
                     throw new Error("local_memory_duplicate_candidate");
                 }
-                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)))) {
+                if (existingCreate === undefined && entries.some((entry) => 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");
@@ -547,7 +400,7 @@ export async function applyLocalMemoryResult(input) {
                             : item),
                         entry,
                     ];
-            const allowEvictionForChange = !fullStorage && change.operation === "create" && change.priority === "high";
+            const allowEvictionForChange = change.operation === "create" && change.priority === "high";
             const protectedIds = new Set(allowEvictionForChange ? pinnedIds(entries) : activeOrPinnedIds(entries));
             if (allowEvictionForChange)
                 allowActiveEviction = true;
@@ -564,7 +417,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 = await readStoredNote(notePath);
+            const previous = noteUpdates.get(notePath) ?? await readNote(notePath);
             const replacement = noteSection(id, revision, change.title, change.detailBody);
             const existingSection = replaceNote(previous, id, replacement);
             const next = existingSection ?? (current === undefined
@@ -582,7 +435,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 = fullStorage ? [] : await readPendingMemoryCandidates({ agentDir: input.agentDir }).catch((error) => {
+        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir }).catch((error) => {
             if (!(error instanceof Error) || error.message !== "memory_pending_directory_over_budget")
                 throw error;
             // 自动提升是可选工作，目录查询预算不应阻断本轮已验证的更新或腾位操作。
@@ -593,10 +446,6 @@ 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;
@@ -611,7 +460,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(await readStoredNote(duplicatePath), duplicate.id);
+                const duplicateBody = readNoteBody(noteUpdates.get(duplicatePath) ?? await readNote(duplicatePath), duplicate.id);
                 if (duplicateBody === change.detailBody
                     || duplicateBody === unwrappedNoteBody(change.title, change.detailBody).trim()) {
                     resolvedPendingIds.add(pending.pendingId);
@@ -629,7 +478,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 = await readStoredNote(notePath);
+            const previous = noteUpdates.get(notePath) ?? await readNote(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}`;
@@ -638,17 +487,6 @@ 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")) {
@@ -660,7 +498,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 = await readStoredNote(notePath);
+                const content = noteUpdates.get(notePath) ?? await readNote(notePath);
                 const detailBody = readNoteBody(content, entry.id);
                 const change = detailBody === null ? null : archivedChange(entry, detailBody);
                 if (change === null)
@@ -681,13 +519,6 @@ 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)
@@ -704,5 +535,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 { lstat, readFile, readdir, stat } from "node:fs/promises";
+import { readFile, 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,7 +8,6 @@ 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";
@@ -40,75 +39,30 @@ 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 withinLocalMemoryDiagnosticsDeadline(operation, timeoutMs) {
+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 }));
     const timeout = new Promise((_resolve, reject) => {
         timer = setTimeout(() => {
-            const error = Object.assign(new Error("local memory diagnostics timed out"), {
+            controller.abort();
+            reject(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([operation(controller.signal), timeout]);
+        return await Promise.race([inspection, 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)) {
@@ -122,12 +76,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, query = "") {
+export function analyzeLocalMemoryInjection(systemPrompt, sourceMemory) {
     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, undefined, Number.POSITIVE_INFINITY, query);
+    const bounded = capMemoryForInject(sourceMemory);
     const marker = INJECTION_MARKERS.find((candidate) => systemPrompt.includes(candidate));
     if (marker === undefined) {
         return {
@@ -263,50 +217,15 @@ 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) {
-    const unwrapped = unwrapLiteralShellCommand(command);
-    if (unwrapped === null || /[;|&\n]/.test(unwrapped))
+    if (/[;|&\n]/.test(command))
         return [];
     const accesses = new Map();
-    const memoryRead = crewMemoryReadAccess(unwrapped, paths);
+    const memoryRead = crewMemoryReadAccess(command, paths);
     if (memoryRead !== null) {
         accesses.set(`${memoryRead.target}:${memoryRead.relative_path ?? ""}:read`, memoryRead);
     }
-    const expanded = unwrapped
+    const expanded = command
         .replaceAll("${CREW_HOME}", paths.homeDir)
         .replaceAll("$CREW_HOME", paths.homeDir)
         .replace(/["']/g, "");

package/dist/local-memory-telemetry.js

@@ -25,17 +25,6 @@ export function logLocalMemoryContextPrepareFailure(identity, phase, error) {
         ...errorFields(error),
     });
 }
-export function logLocalMemoryContextDegraded(identity, error) {
-    safeLog("local_memory.context_degraded", "本地记忆准备失败，已安全降级为无记忆执行", {
-        level: "WARN",
-        execution_id: identity.executionId,
-        agent_handle: identity.agentHandle,
-        task_key: identity.taskKey,
-        memory_read_enabled: false,
-        memory_write_enabled: false,
-        ...errorFields(error),
-    });
-}
 export function logLocalMemoryDiagnosticsFailure(identity, phase, error) {
     safeLog("local_memory.diagnostics_failed", "本地记忆诊断失败并已放行", {
         level: "WARN",
@@ -49,7 +38,6 @@ 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,
@@ -66,12 +54,6 @@ 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) {
@@ -121,7 +103,7 @@ export function createLocalMemoryTelemetry(options) {
         contextPrepared(context) {
             try {
                 const sourceFacts = localMemoryContentFacts(context.memory);
-                const injectionFacts = analyzeLocalMemoryInjection(context.systemPrompt, context.memory, context.memoryQuery);
+                const injectionFacts = analyzeLocalMemoryInjection(context.systemPrompt, context.memory);
                 safeLog("local_memory.context_prepared", "本地记忆上下文已准备", {
                     execution_id: options.executionId,
                     agent_handle: options.agentHandle,
@@ -201,13 +183,10 @@ 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 || pendingChanged === undefined
+            const sharedFilesChanged = memoryChanged === undefined || lessonsChanged === undefined
                 ? undefined
-                : memoryChanged || lessonsChanged || pendingChanged;
+                : memoryChanged || lessonsChanged;
             safeLog("local_memory.execution_observed", "本地记忆执行观察已完成", {
                 execution_id: options.executionId,
                 agent_handle: options.agentHandle,
@@ -221,7 +200,6 @@ 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
@@ -246,12 +224,6 @@ 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

@@ -27,7 +27,6 @@ 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";
@@ -44,7 +43,6 @@ export const NATIVE_PROJECT_WORKSPACE_READINESS = Object.freeze({
 export const DAEMON_CAPABILITIES = Object.freeze([
     RUNTIME_TOOL_UPDATES_CAPABILITY,
     MARKETPLACE_CAPABILITY,
-    MEMORY_MIGRATION_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY, MEMORY_STATE_GUARD_CAPABILITY,
     MAINTENANCE_CAPABILITY,
     "scheduled_job_v1",
     "reply_origin_v1",
@@ -81,7 +79,6 @@ export const daemonCapabilities = (runtimePlatform = process.platform, readiness
     return Object.freeze(DAEMON_CAPABILITIES.filter((capability) => (((capability !== MARKETPLACE_CAPABILITY && capability !== MAINTENANCE_CAPABILITY && capability !== RUNTIME_TOOL_UPDATES_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({