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

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 { assertMemoryWriterAllowed, withMemoryAccess } from "./migration-access.js";
 const StatusChangeSchema = z.object({
     memoryId: LocalMemorySingleLineText,
     expectedRevision: z.number().int().positive(),
@@ -92,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) {
@@ -126,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)) {
@@ -228,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);
@@ -273,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")
@@ -315,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");
@@ -357,27 +306,12 @@ async function withApplyLease(agentDir, operation) {
 }
 export async function applyLocalMemoryResult(input) {
     validateCandidate(input.result);
-    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)];
@@ -408,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";
@@ -469,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");
@@ -497,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;
@@ -514,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
@@ -532,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;
             // 自动提升是可选工作，目录查询预算不应阻断本轮已验证的更新或腾位操作。
@@ -557,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);
@@ -575,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}`;
@@ -584,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")) {
@@ -606,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)
@@ -627,12 +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");
-        }
         for (const candidate of pendingCandidates)
             await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
         for (const [path, content] of noteUpdates)
@@ -649,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)) {
@@ -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

@@ -38,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,
@@ -55,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) {
@@ -190,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,
@@ -210,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
@@ -235,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

@@ -25,7 +25,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";
@@ -40,7 +39,6 @@ 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,7 +73,6 @@ 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({

package/dist/marketplace-remote.js

@@ -10,7 +10,7 @@ const Target = z.object({
     version: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._+-]{0,79}$/),
     source: z.object({ source: z.literal("git-subdir"),
         url: z.literal("git@codeup.aliyun.com:6128d2e757e7cd986dfae5ab/pm/AIinterview-agent-skill.git"),
-        path: z.literal("plugins/aiinterview-plugin"), sha: z.string().regex(/^[a-f0-9]{40}$/) }),
+        path: z.literal("plugins/AIinterview-plugin"), sha: z.string().regex(/^[a-f0-9]{40}$/) }),
 });
 export async function readRemoteMarketplace(runtime, registered, env, command) {
     const source = validateMarketplaceSource(registered.url, registered.ref);

package/dist/marketplace-runner.js

@@ -12,7 +12,7 @@ import { readMarketplaceSource } from "./marketplace-source.js";
 export { MarketplaceFailure, runMarketplaceCommand } from "./marketplace-command.js";
 const SELECTOR = `${PLUGIN}@${MARKETPLACE}`;
 const SOURCE = "git@codeup.aliyun.com:6128d2e757e7cd986dfae5ab/pm/AIinterview-agent-skill.git";
-const SOURCE_PATH = "plugins/aiinterview-plugin";
+const SOURCE_PATH = "plugins/AIinterview-plugin";
 const obj = (x) => x !== null && typeof x === "object" && !Array.isArray(x) ? x : {};
 const parse = (text) => { try {
     return JSON.parse(text);