@nowcrew/daemon 0.6.87 → 0.6.88-beta.10

package/dist/local-memory/pending.js

@@ -1,34 +1,11 @@
 import { randomUUID } from "node:crypto";
-import { lstat, mkdir, readdir, realpath, rename, rm, writeFile, readFile } from "node:fs/promises";
+import { lstat, mkdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
-import { z } from "zod";
+import { isRecallablePending, parsePendingMemoryCandidate } from "./pending-schema.js";
+import { pendingFileNames, pendingReadDirectory, PENDING_FILE_BYTES, readPendingSource } from "./pending-source.js";
+import { pendingRecallScore } from "./pending-match.js";
 export const LOCAL_MEMORY_PENDING_SCAN_FILE_CAP = 128;
 export const LOCAL_MEMORY_PENDING_SCAN_BYTE_CAP = 1_000_000;
-const CandidateSchema = z.object({
-    operation: z.enum(["create", "update", "supersede"]),
-    memoryId: z.string().nullable(),
-    baseRevision: z.number().int().nonnegative().nullable(),
-    supersedesMemoryId: z.string().nullable(),
-    title: z.string().min(1),
-    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
-    summary: z.string().min(1),
-    triggers: z.array(z.string()).min(1),
-    priority: z.enum(["high", "medium", "low"]),
-    detailCategory: z.enum(["preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons"]),
-    detailBody: z.string().min(1),
-    reviewAfter: z.string().nullable(),
-}).strict();
-const PendingSchema = z.object({
-    schemaVersion: z.literal(1),
-    pendingId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
-    createdAt: z.string().min(1),
-    reason: z.literal("index_over_budget"),
-    source: z.object({
-        executionId: z.string().min(1),
-        pruneTraceId: z.string().min(1).nullable(),
-    }).strict(),
-    candidate: CandidateSchema,
-}).strict();
 function within(root, candidate) {
     const path = relative(root, candidate);
     return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
@@ -122,13 +99,11 @@ async function atomicWrite(path, content) {
     }
 }
 export async function persistPendingMemoryCandidate(input) {
-    const parsed = PendingSchema.safeParse(input.candidate);
-    if (!parsed.success)
-        throw new Error("local_memory_pending_invalid");
+    const parsed = parsePendingMemoryCandidate(input.candidate);
     const directory = await pendingDirectory(input.agentDir);
-    const target = join(directory, `${parsed.data.pendingId}.json`);
+    const target = join(directory, `${parsed.pendingId}.json`);
     await assertRegularFile(target);
-    await atomicWrite(target, `${JSON.stringify(parsed.data, null, 2)}\n`);
+    await atomicWrite(target, `${JSON.stringify(parsed, null, 2)}\n`);
     return target;
 }
 export async function removePendingMemoryCandidate(input) {
@@ -140,73 +115,44 @@ export async function removePendingMemoryCandidate(input) {
     await rm(target, { force: true });
 }
 export async function readPendingMemoryCandidates(input) {
-    const directory = await existingPendingDirectory(input.agentDir);
-    if (directory === null)
-        return [];
-    const names = (await readdir(directory)).filter((name) => name.endsWith(".json")).sort();
+    const { directory } = await pendingReadDirectory(input.agentDir).catch((error) => {
+        if (error instanceof Error && error.message === "memory_pending_path_invalid") {
+            throw new Error("local_memory_pending_path_invalid");
+        }
+        throw error;
+    });
+    const names = await pendingFileNames(directory);
     const maxFiles = Math.max(0, input.maxFiles ?? LOCAL_MEMORY_PENDING_SCAN_FILE_CAP);
     const maxBytes = Math.max(0, input.maxBytes ?? LOCAL_MEMORY_PENDING_SCAN_BYTE_CAP);
     const result = [];
     let scannedBytes = 0;
-    for (const name of names) {
-        if (result.length >= maxFiles || scannedBytes >= maxBytes)
+    for (const name of names.slice(0, maxFiles)) {
+        if (scannedBytes >= maxBytes)
             break;
-        const path = join(directory, name);
         try {
-            await assertRegularFile(path);
-            const stat = await lstat(path);
-            if (!stat.isFile() || stat.isSymbolicLink())
-                throw new Error("local_memory_pending_path_invalid");
-            if (scannedBytes + stat.size > maxBytes)
-                break;
-            const raw = await readFile(path, "utf8");
-            const size = Buffer.byteLength(raw, "utf8");
-            if (scannedBytes + size > maxBytes)
-                break;
-            scannedBytes += size;
-            const parsed = PendingSchema.safeParse(JSON.parse(raw));
-            if (parsed.success && `${parsed.data.pendingId}.json` === name)
-                result.push(parsed.data);
+            const source = await readPendingSource(input.agentDir, name, maxBytes - scannedBytes);
+            scannedBytes += source.bytes;
+            result.push(source.candidate);
         }
         catch {
-            // A damaged pending item is diagnosable and must not hide other candidates.
+            // 失败读取也消耗预算，显式分页命令负责返回诊断和继续扫描。
+            scannedBytes += Math.min(PENDING_FILE_BYTES, maxBytes - scannedBytes);
         }
     }
     return result;
 }
-function normalize(value) {
-    return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
-}
 function priorityRank(priority) {
     return priority === "high" ? 0 : priority === "medium" ? 1 : 2;
 }
-function candidateText(candidate) {
-    return [
-        candidate.candidate.title,
-        candidate.candidate.summary,
-        ...candidate.candidate.triggers,
-        candidate.candidate.detailCategory,
-        candidate.candidate.detailBody,
-    ].join("\n");
-}
-function recallScore(candidate, query) {
-    const normalizedQuery = normalize(query);
-    if (normalizedQuery === "")
-        return 1;
-    const text = normalize(candidateText(candidate));
-    if (text.includes(normalizedQuery))
-        return 100;
-    const terms = normalizedQuery.split(/[\s,，、。！？；：:()[\]{}"'`]+/u).filter((term) => term.length > 0);
-    return terms.reduce((score, term) => score + (text.includes(term) ? 1 : 0), 0);
-}
 export async function searchPendingMemoryCandidates(input) {
     const candidates = await readPendingMemoryCandidates({ agentDir: input.agentDir });
     const limit = Math.max(0, input.limit ?? 5);
     if (limit === 0)
         return [];
     return candidates
-        .map((candidate) => ({ candidate, score: recallScore(candidate, input.query) }))
-        .filter((item) => normalize(input.query) === "" || item.score > 0)
+        .filter(isRecallablePending)
+        .map((candidate) => ({ candidate, score: pendingRecallScore(candidate, input.query) }))
+        .filter((item) => item.score > 0)
         .sort((left, right) => right.score - left.score
         || priorityRank(left.candidate.candidate.priority) - priorityRank(right.candidate.candidate.priority)
         || right.candidate.createdAt.localeCompare(left.candidate.createdAt)
@@ -218,25 +164,29 @@ function truncateCodePoints(value, maxCodePoints) {
     return Array.from(value).slice(0, Math.max(0, maxCodePoints)).join("");
 }
 export function renderPendingMemoryContext(candidates, maxCodePoints = 2_000) {
-    if (candidates.length === 0 || maxCodePoints <= 0)
+    const recallable = candidates.filter(isRecallablePending);
+    if (recallable.length === 0 || maxCodePoints <= 0)
         return "";
-    const header = `\n\n## Archived memory candidates (daemon-managed)\n这些记忆已持久化，但尚未进入常驻热索引；只在当前请求相关时参考，必要时再由 memory-prune 提升。\n`;
+    const header = `\n\n## Archived memory candidates (daemon-managed)\n容量暂存的新增资料，仅为部分预览，不代表完整检索；可参考但不能覆盖现行规则，未包含内容请按需查询。\n`;
     let remaining = maxCodePoints - Array.from(header).length;
     if (remaining <= 0)
         return truncateCodePoints(header, maxCodePoints);
     const sections = [];
-    for (const item of candidates) {
+    for (const item of recallable) {
         const change = item.candidate;
         const prefix = `\n### ${change.title}\n`
-            + `- pending_file: .crew/memory/pending/${item.pendingId}.json\n`
+            + `- pending_id: ${item.pendingId}\n`
             + `- summary: ${change.summary}\n`
             + `- triggers: ${change.triggers.join(", ")}\n`
             + "- detail: ";
         const prefixLength = Array.from(prefix).length;
         if (prefixLength + 1 > remaining)
             break;
-        const detail = truncateCodePoints(change.detailBody, remaining - prefixLength - 1);
-        const section = `${prefix}${detail}\n`;
+        const notice = " [正文未完，请用 read-pending 分页读取]";
+        const available = remaining - prefixLength - 1;
+        const truncated = Array.from(change.detailBody).length > available;
+        const detail = truncateCodePoints(change.detailBody, truncated ? Math.max(0, available - Array.from(notice).length) : available);
+        const section = `${prefix}${detail}${truncated ? truncateCodePoints(notice, available - Array.from(detail).length) : ""}\n`;
         const length = Array.from(section).length;
         sections.push(section);
         remaining -= length;

package/dist/local-memory/prompt.js

@@ -0,0 +1,40 @@
+import { dslog } from "../slog.js";
+import { renderPendingMemoryContext, searchPendingMemoryCandidates } from "./pending.js";
+import { renderLocalMemoryResultInstructions } from "./runtime.js";
+const PENDING_READ_GUIDANCE = "\n\nV2新增资料预览未命中不代表没有资料；先查有效索引，必要时用 crew-memory search-pending --query '关键词'，按 nextCursor 续查；用 read-pending --id ID 分页读正文。容量暂存资料不能覆盖现行规则，未应用修改不作为记忆。用 crew-memory --help 查看参数。\n";
+export async function prepareLocalMemoryPrompt(input) {
+    let pending = "";
+    if (input.enabled) {
+        try {
+            pending = renderPendingMemoryContext(await searchPendingMemoryCandidates({
+                agentDir: input.agentDir, query: input.query, limit: 5,
+            }));
+        }
+        catch (error) {
+            dslog("local_memory.pending_recall_failed", "本地归档记忆召回失败", {
+                level: "WARN",
+                execution_id: input.executionId,
+                agent_handle: input.agentHandle,
+                error_name: error instanceof Error ? error.name : "unknown",
+                error_code: error?.code,
+            });
+        }
+    }
+    const original = input.renderBase(0);
+    const structured = input.resultPath === null ? "" : renderLocalMemoryResultInstructions(input.resultPath);
+    const guidance = input.enabled ? PENDING_READ_GUIDANCE : "";
+    // 短命令指引放在当前轮，独立于可舍弃预览；收尾契约仍保持系统与当前轮两份。
+    for (const choice of [
+        { suffix: pending + structured, wake: structured + guidance },
+        { suffix: structured, wake: structured + guidance },
+        { suffix: structured, wake: structured },
+    ]) {
+        const reserved = Buffer.byteLength(choice.suffix + choice.wake, "utf8");
+        const systemPrompt = (reserved === 0 ? original : input.renderBase(reserved)) + choice.suffix;
+        if (input.maxBytes === undefined || Buffer.byteLength(systemPrompt + choice.wake, "utf8") <= input.maxBytes) {
+            return { systemPrompt, resultPath: input.resultPath, wakePromptSuffix: choice.wake };
+        }
+    }
+    // 强制基础指令与契约本身仍无法共存时，保留既有非结构化兼容回退，不裁基础指令。
+    return { systemPrompt: original, resultPath: null, wakePromptSuffix: "" };
+}

package/dist/local-memory/read-cli.js

@@ -0,0 +1,281 @@
+import { constants } from "node:fs";
+import { open, realpath } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs, TextDecoder } from "node:util";
+import { z } from "zod";
+import { readPendingMemoryBody, searchPendingMemoryPage } from "./pending-query.js";
+const OUTPUT_BYTES = 12 * 1024;
+const FILE_BYTES = 32 * 1024 * 1024;
+const FileSchema = z.string().min(1).refine((file) => {
+    if (isAbsolute(file) || /[\\\u0000-\u001f\u007f]/u.test(file))
+        return false;
+    if (Buffer.byteLength(file, "utf8") > 1024)
+        return false;
+    const parts = file.split("/");
+    if (parts.some((part) => part === "" || part === "." || part === ".."))
+        return false;
+    return file === "MEMORY.md" || (parts[0] === "notes" && parts.length > 1 && file.endsWith(".md"));
+}, "memory_path_invalid");
+const Common = {
+    file: FileSchema.default("MEMORY.md"),
+    ifHash: z.string().regex(/^[a-f0-9]{64}$/u).optional(),
+};
+const CommandSchema = z.discriminatedUnion("command", [
+    z.object({
+        command: z.literal("search"), ...Common,
+        query: z.string().trim().min(1).max(256),
+        limit: z.coerce.number().int().min(1).max(40).default(10),
+        afterLine: z.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
+    }).strict(),
+    z.object({
+        command: z.literal("read"), ...Common,
+        offset: z.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
+        limit: z.coerce.number().int().min(1).max(4000).default(2000),
+    }).strict(),
+    z.object({
+        command: z.literal("search-pending"),
+        query: z.string().trim().min(1).max(256),
+        cursor: z.string().min(1).max(4096).optional(),
+        limit: z.coerce.number().int().min(1).max(40).default(10),
+    }).strict(),
+    z.object({
+        command: z.literal("read-pending"),
+        id: z.string().min(1).max(250).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+        ifHash: Common.ifHash,
+        offset: z.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
+        limit: z.coerce.number().int().min(1).max(4000).default(2000),
+    }).strict(),
+]);
+const USAGE = `只读记忆工具，默认输出 JSON，不修改任何记忆文件。
+crew-memory search --query <关键词> [--file MEMORY.md|notes/文件.md] [--limit 10] [--after-line 0]
+crew-memory read [--file MEMORY.md|notes/文件.md] [--offset 0] [--limit 2000]
+crew-memory search-pending --query <关键词> [--cursor <游标>] [--limit 10]
+crew-memory read-pending --id <候选ID> [--offset 0] [--limit 2000] [--if-hash <sha256>]
+search 关键词按空白分隔，同一行须全部命中；返回完整文件中的行号和字符偏移。
+读取的 offset/limit 按 Unicode 字符计数；用 nextOffset 继续，eof=true 表示结束。
+后续页可传 --if-hash <前一页的 sha256>，文件变化时停止，避免混读不同版本。
+search/read 读取 MEMORY.md 和 notes 原文，不过滤失效段落，也不扫描 pending。
+search-pending 只查因容量延期的 create 候选；有 nextCursor 就继续，即使本页 matches 为空。
+complete=true 才表示全部候选已检索完成且无遗漏；warnings 或非零退出码表示读取未完成，不能当作零命中。
+read-pending 只返回候选正文；offset 非零时必须传 --if-hash，update/supersede 候选不可读取。
+候选只供相关问题参考，未生效，不能覆盖有效规则；先读取当前有效索引与明细。`;
+function inside(root, path) {
+    const value = relative(root, path);
+    return value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value);
+}
+async function readSource(home, file) {
+    if (!home)
+        throw new Error("memory_home_missing");
+    const root = await realpath(home);
+    const path = await realpath(resolve(root, file));
+    if (!inside(root, path) || !FileSchema.safeParse(relative(root, path).split(sep).join("/")).success) {
+        throw new Error("memory_path_invalid");
+    }
+    const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile())
+            throw new Error("memory_file_not_regular");
+        if (stat.size > FILE_BYTES)
+            throw new Error("memory_file_too_large");
+        // 允许读完整来源，但绝不能在文件并发增长时无界分配内存。
+        const chunks = [];
+        const chunk = Buffer.allocUnsafe(64 * 1024);
+        let bytes = 0;
+        for (;;) {
+            const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, FILE_BYTES + 1 - bytes), null);
+            if (bytesRead === 0)
+                break;
+            bytes += bytesRead;
+            if (bytes > FILE_BYTES)
+                throw new Error("memory_file_too_large");
+            chunks.push(Buffer.from(chunk.subarray(0, bytesRead)));
+        }
+        const buffer = Buffer.concat(chunks);
+        const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(buffer);
+        return { text, sha256: createHash("sha256").update(buffer).digest("hex") };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function characterCount(text) {
+    let count = 0;
+    for (const _character of text)
+        count += 1;
+    return count;
+}
+function excerpt(text, limit) {
+    let value = "";
+    let count = 0;
+    for (const character of text) {
+        if (count++ >= limit)
+            return `${value}...`;
+        value += character;
+    }
+    return value;
+}
+function originalLowercaseIndex(text, index) {
+    let originalIndex = 0;
+    let lowerIndex = 0;
+    for (const character of text) {
+        // 逐字符只累计小写长度；匹配仍用整行小写，保留长度不变的词尾 sigma 上下文规则。
+        lowerIndex += character.toLowerCase().length;
+        if (index < lowerIndex)
+            return originalIndex;
+        originalIndex += character.length;
+    }
+    return text.length;
+}
+function searchSource(text, sha256, command) {
+    const terms = command.query.toLowerCase().split(/\s+/u);
+    const matches = [];
+    let line = 0;
+    let offset = 0;
+    let heading = "";
+    let matchCount = 0;
+    let hasMore = false;
+    let remaining = OUTPUT_BYTES - Buffer.byteLength(JSON.stringify({ file: command.file, sha256 })) - 512;
+    for (const match of text.matchAll(/[^\n]*(?:\n|$)/gu)) {
+        if (match[0] === "")
+            break;
+        line += 1;
+        const raw = match[0];
+        const content = raw.replace(/\r?\n$/u, "");
+        const title = /^#{1,6}\s+(.+?)\s*$/u.exec(content)?.[1];
+        if (title !== undefined)
+            heading = excerpt(title, 96);
+        const lower = content.toLowerCase();
+        if (terms.every((term) => lower.includes(term))) {
+            matchCount += 1;
+            if (line > command.afterLine) {
+                let start = Math.max(0, originalLowercaseIndex(content, lower.indexOf(terms[0])) - 60);
+                if (start > 0 && /[\uDC00-\uDFFF]/u.test(content[start]))
+                    start -= 1;
+                const item = { line, offset, heading, text: `${start > 0 ? "..." : ""}${excerpt(content.slice(start), 240)}` };
+                const bytes = Buffer.byteLength(JSON.stringify(item), "utf8") + 1;
+                if (hasMore || matches.length >= command.limit || bytes > remaining) {
+                    hasMore = true;
+                }
+                else {
+                    matches.push(item);
+                    remaining -= bytes;
+                }
+            }
+        }
+        offset += characterCount(raw);
+    }
+    return {
+        file: command.file, sha256, matches, matchCount, hasMore,
+        nextAfterLine: hasMore ? matches.at(-1)?.line ?? null : null,
+    };
+}
+function readPage(text, source, command) {
+    const metadata = { ...source, offset: command.offset, nextOffset: Number.MAX_SAFE_INTEGER, eof: false, content: "" };
+    let remaining = OUTPUT_BYTES - Buffer.byteLength(JSON.stringify(metadata), "utf8");
+    let position = 0;
+    let offset = 0;
+    while (position < text.length && offset < command.offset) {
+        position += text.codePointAt(position) > 0xffff ? 2 : 1;
+        offset += 1;
+    }
+    let content = "";
+    let count = 0;
+    while (position < text.length && count < command.limit) {
+        const character = String.fromCodePoint(text.codePointAt(position));
+        const bytes = Buffer.byteLength(JSON.stringify(character), "utf8") - 2;
+        if (bytes > remaining)
+            break;
+        remaining -= bytes;
+        content += character;
+        position += character.length;
+        offset += 1;
+        count += 1;
+    }
+    const eof = position === text.length;
+    if (!eof && count === 0)
+        throw new Error("memory_output_too_large");
+    return { ...metadata, content, eof, nextOffset: eof ? null : offset };
+}
+function writeResult(result, io) {
+    const output = JSON.stringify(result);
+    if (Buffer.byteLength(output, "utf8") > OUTPUT_BYTES)
+        throw new Error("memory_output_too_large");
+    io.out(output);
+}
+export async function runMemoryReadCommand(argv, io) {
+    let command;
+    try {
+        const { values, positionals } = parseArgs({
+            args: [...argv], allowPositionals: true,
+            options: {
+                query: { type: "string", short: "q" }, file: { type: "string" },
+                limit: { type: "string" }, offset: { type: "string" },
+                "after-line": { type: "string" }, "if-hash": { type: "string" },
+                id: { type: "string" }, cursor: { type: "string" },
+                json: { type: "boolean" }, help: { type: "boolean", short: "h" },
+            },
+        });
+        if (values.help) {
+            io.out(USAGE);
+            return 0;
+        }
+        if (positionals.length !== 1)
+            throw new Error("memory_command_invalid");
+        const { help: _help, json: _json, "after-line": afterLine, "if-hash": ifHash, ...options } = values;
+        command = CommandSchema.parse({
+            command: positionals[0], ...options,
+            ...(afterLine === undefined ? {} : { afterLine }),
+            ...(ifHash === undefined ? {} : { ifHash }),
+        });
+        if (command.command === "read-pending" && command.offset > 0 && command.ifHash === undefined) {
+            throw new Error("memory_hash_required");
+        }
+    }
+    catch {
+        io.err(`memory_arguments_invalid: 参数不合法，记忆读取未完成。\n${USAGE}`);
+        return 2;
+    }
+    try {
+        if (!io.env.CREW_HOME)
+            throw new Error("memory_home_missing");
+        if (command.command === "search-pending") {
+            const result = await searchPendingMemoryPage({ agentDir: io.env.CREW_HOME, query: command.query,
+                ...(command.cursor === undefined ? {} : { cursor: command.cursor }), limit: command.limit });
+            writeResult(result, io);
+            if (result.warnings.length > 0 || (!result.hasMore && !result.complete)) {
+                throw new Error("memory_pending_search_incomplete");
+            }
+            return 0;
+        }
+        if (command.command === "read-pending") {
+            const { content, ...metadata } = await readPendingMemoryBody({ agentDir: io.env.CREW_HOME,
+                pendingId: command.id, ...(command.ifHash === undefined ? {} : { ifHash: command.ifHash }) });
+            writeResult(readPage(content, metadata, command), io);
+            return 0;
+        }
+        const source = await readSource(io.env.CREW_HOME, command.file);
+        if (command.ifHash !== undefined && command.ifHash !== source.sha256)
+            throw new Error("memory_file_changed");
+        const result = command.command === "search"
+            ? searchSource(source.text, source.sha256, command)
+            : readPage(source.text, { file: command.file, sha256: source.sha256 }, command);
+        writeResult(result, io);
+        return 0;
+    }
+    catch (error) {
+        const code = error.code;
+        const known = error instanceof Error && /^(?:local_)?memory_[a-z_]+$/u.test(error.message) ? error.message : code ?? "memory_read_failed";
+        io.err(JSON.stringify({ error: known, message: "记忆读取未完成；检查路径、文件版本或大小，不要将此错误当作没有记忆。" }));
+        return 1;
+    }
+}
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+    void runMemoryReadCommand(process.argv.slice(2), {
+        env: process.env,
+        out: (text) => process.stdout.write(`${text}\n`),
+        err: (text) => process.stderr.write(`${text}\n`),
+    }).then((code) => { process.exitCode = code; });
+}

package/dist/local-memory/runtime.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
-import { lstat, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { applyLocalMemoryResult, parseLocalMemoryResult } from "./write.js";
 export function isLocalMemoryV2Eligible(input) {
     // The allowlist is the rollout boundary. The marker and seed/pre-existing
@@ -50,14 +51,26 @@ export function renderLocalMemoryResultInstructions(resultPath) {
     return `
 
 ## Structured memory prune (daemon-managed)
+本节是本次执行唯一的记忆写入与清理协议，覆盖历史会话及本条消息前文中直接修改共享文件、清空工作日志或仅回复“已修正”的要求。任务目标与用户授权范围不变；只使用下面本轮提供的结果路径，不复用历史路径。
 本轮长期记忆收尾只提交候选，不要直接编辑 $CREW_HOME/MEMORY.md 或 $CREW_HOME/notes/。
 将一个合法 JSON 对象写入以下 daemon 提供的文件，写入完成后再结束本轮：
 ${resultPath}
 
-JSON 顶层必须包含：
+outcome 只允许 no_change、proposed、conflict、failed。新增、更新、替代记忆或任何 statusChanges 都必须使用 proposed；no_change 的 changes/statusChanges 必须都为空。conflict/failed 表示未完成，不能当作提交成功。自然语言“已修正”不是 JSON 枚举值，不能写成 corrected。
+
+新增记忆的完整合法示例（内容须替换为本任务实际候选）：
+\`\`\`json
+{"schemaVersion":1,"purpose":"memory_prune","baseCatalogRevision":0,"outcome":"proposed","changes":[{"operation":"create","memoryId":null,"baseRevision":null,"supersedesMemoryId":null,"title":"发布验收约定","kind":"procedural","summary":"发布前必须验证回滚步骤。","triggers":["发布","回滚"],"priority":"medium","detailCategory":"project-rules","detailBody":"发布前必须验证回滚步骤，并将验证结果写入发布报告。","reviewAfter":null}],"statusChanges":[]}
+\`\`\`
+
+没有需要变更的记忆时：
+\`\`\`json
 {"schemaVersion":1,"purpose":"memory_prune","baseCatalogRevision":0,"outcome":"no_change","changes":[],"statusChanges":[]}
-每个 changes 项使用 operation=create|update|supersede、title、kind、summary、triggers、priority、detailCategory、detailBody、reviewAfter；create 的 memoryId/baseRevision/supersedesMemoryId 必须为 null，update/supersede 按现有索引填写版本和 id。
-只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中；后续相关任务会按需召回，索引腾出空间后可自动提升。
+\`\`\`
+
+每个 changes 项须保留示例中的全部字段。operation=create|update|supersede；kind=procedural|semantic|episodic|preference；priority=high|medium|low；detailCategory=preferences|project-rules|testing|debugging|git|incidents|lessons。create 的 memoryId/baseRevision/supersedesMemoryId 必须为 null；update 按现有索引填写 memoryId/baseRevision，supersedesMemoryId 为 null；supersede 填 supersedesMemoryId/baseRevision，memoryId 为 null。
+只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中。容量暂存的 create 可按需检索参考但不能覆盖现行规则；有空间的后续 proposed 提交可提升。未应用的 update/supersede 不进入普通召回，必须重新核对目标版本后处理。
+写入候选文件只表示提交候选，不能提前宣称已经记住或规则已经更新；daemon 在本轮结束后才处理，候选持久化与进入有效索引也不是同一结果。本结构化轮次覆盖前文提前清理工作日志的要求：保留 $CREW_TASK_LOG，不要清空或删除；daemon 将在处理成功后清理，失败时保留日志和候选用于排查或重试。
 `;
 }
 /** Prevent ordinary V2 turns from racing the daemon-managed memory writer. */
@@ -81,16 +94,52 @@ export async function commitLocalMemoryResultAfterExit(input) {
     }
     try {
         const result = parseLocalMemoryResult(raw);
+        if (result.outcome === "conflict" || result.outcome === "failed") {
+            return { status: "failed", error: `local_memory_result_${result.outcome}` };
+        }
         await applyLocalMemoryResult({
             agentDir: input.agentDir,
             result,
             executionId: input.executionId,
             pruneTraceId: input.pruneTraceId,
         });
-        await rm(input.resultPath, { force: true });
-        return { status: "applied" };
     }
     catch (error) {
         return { status: "failed", error: error instanceof Error ? error.message : "apply_failed" };
     }
+    if (input.workLogPath !== undefined) {
+        try {
+            const relativeLogPath = relative(resolve(input.agentDir), resolve(input.workLogPath));
+            if (relativeLogPath === "" || relativeLogPath === ".." || relativeLogPath.startsWith(`..${sep}`)
+                || isAbsolute(relativeLogPath))
+                throw new Error("local_memory_work_log_path_invalid");
+            const expectedLogPath = join(await realpath(input.agentDir), relativeLogPath);
+            const before = await lstat(input.workLogPath);
+            if (!before.isFile() || before.isSymbolicLink())
+                throw new Error("local_memory_work_log_path_invalid");
+            if (await realpath(input.workLogPath) !== expectedLogPath)
+                throw new Error("local_memory_work_log_path_invalid");
+            const handle = await open(input.workLogPath, constants.O_WRONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+            try {
+                const opened = await handle.stat();
+                if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino) {
+                    throw new Error("local_memory_work_log_path_changed");
+                }
+                await handle.truncate(0);
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch {
+            return { status: "failed", error: "local_memory_work_log_cleanup_failed" };
+        }
+    }
+    try {
+        await rm(input.resultPath, { force: true });
+    }
+    catch {
+        return { status: "failed", error: "local_memory_result_cleanup_failed" };
+    }
+    return { status: "applied" };
 }