@nowcrew/daemon 0.6.88 → 0.6.90

package/dist/local-memory/prompt.js

@@ -1,6 +1,8 @@
 import { dslog } from "../slog.js";
 import { renderPendingMemoryContext, searchPendingMemoryCandidates } from "./pending.js";
-import { renderLocalMemoryResultInstructions } from "./runtime.js";
+import { renderLocalMemoryResultInstructions, renderLocalMemoryV2WriteGuard } from "./runtime.js";
+import { LOCAL_MEMORY_V2_DEFERRED_GUIDANCE } from "./rollout.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) {
@@ -20,19 +22,24 @@ export async function prepareLocalMemoryPrompt(input) {
         }
     }
     const original = input.renderBase(0);
+    const guard = input.deferred ? LOCAL_MEMORY_V2_DEFERRED_GUIDANCE
+        : input.strictRollout && input.enabled && input.resultPath === null ? renderLocalMemoryV2WriteGuard() : "";
     const structured = input.resultPath === null ? "" : renderLocalMemoryResultInstructions(input.resultPath);
-    const wakeBytes = Buffer.byteLength(structured, "utf8");
-    const fits = (prompt) => input.maxBytes === undefined || Buffer.byteLength(prompt, "utf8") + wakeBytes <= input.maxBytes;
-    const render = (suffix) => (suffix === "" ? original : input.renderBase(Buffer.byteLength(suffix, "utf8") + wakeBytes)) + suffix;
-    // 系统及当前消息各保留一份契约，避免 resume 沿用旧指令；两份均先占预算，再裁可选预览。
-    const complete = render(pending + structured);
-    if (fits(complete))
-        return { systemPrompt: complete, resultPath: input.resultPath, wakePromptSuffix: structured };
-    if (pending !== "") {
-        const withoutPending = render(structured);
-        if (fits(withoutPending))
-            return { systemPrompt: withoutPending, resultPath: input.resultPath, wakePromptSuffix: structured };
+    const guidance = input.enabled ? PENDING_READ_GUIDANCE : "";
+    // 短命令指引放在当前轮，独立于可舍弃预览；收尾契约仍保持系统与当前轮两份。
+    for (const choice of [
+        { suffix: pending + guard + structured, wake: guard + structured + guidance },
+        { suffix: guard + structured, wake: guard + structured + guidance },
+        { suffix: guard + structured, wake: guard + 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 };
+        }
     }
+    if (input.strictRollout)
+        throw new Error("local_memory_v2_prompt_over_budget");
     // 强制基础指令与契约本身仍无法共存时，保留既有非结构化兼容回退，不裁基础指令。
     return { systemPrompt: original, resultPath: null, wakePromptSuffix: "" };
 }

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

@@ -5,8 +5,13 @@ 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 READ_LIMIT_MAX = 4_000;
+const READ_LIMIT_SAFE = 2_000;
+const SEARCH_LIMIT_MAX = 40;
+const SEARCH_LIMIT_SAFE = 10;
 const FileSchema = z.string().min(1).refine((file) => {
     if (isAbsolute(file) || /[\\\u0000-\u001f\u007f]/u.test(file))
         return false;
@@ -25,22 +30,43 @@ 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),
+        limit: z.coerce.number().int().min(1).max(Number.MAX_SAFE_INTEGER).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),
+        limit: z.coerce.number().int().min(1).max(Number.MAX_SAFE_INTEGER).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(Number.MAX_SAFE_INTEGER).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(Number.MAX_SAFE_INTEGER).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>]
+read/read-pending 的有效页长为 1—4000，默认 2000；search/search-pending 的有效页长为 1—40，默认 10。超出上限时工具自动使用安全页长并返回 warning（recovered=true），不把它当作读取失败。
+search 关键词按空白分隔，同一行须全部命中；返回完整文件中的行号和字符偏移。
 读取的 offset/limit 按 Unicode 字符计数；用 nextOffset 继续，eof=true 表示结束。
+读取的 --limit 超出范围时，工具会自动降到 2000 并在结果中标记 warning；保留原文件或候选 ID 及 offset，按 nextOffset 分页，不要一次读完整文件。
 后续页可传 --if-hash <前一页的 sha256>，文件变化时停止，避免混读不同版本。
-搜索结果是原始资料定位，不代表候选已生效；按当前有效索引读取明细，不扫描 pending。`;
+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);
@@ -109,7 +135,15 @@ function originalLowercaseIndex(text, index) {
     }
     return text.length;
 }
-function searchSource(text, sha256, command) {
+function normalizeLimit(requestedLimit, max, safe) {
+    if (requestedLimit <= max)
+        return { limit: requestedLimit };
+    return {
+        limit: safe,
+        warning: { code: "memory_limit_clamped", requestedLimit, appliedLimit: safe, recovered: true },
+    };
+}
+function searchSource(text, sha256, command, warning) {
     const terms = command.query.toLowerCase().split(/\s+/u);
     const matches = [];
     let line = 0;
@@ -150,10 +184,22 @@ function searchSource(text, sha256, command) {
     return {
         file: command.file, sha256, matches, matchCount, hasMore,
         nextAfterLine: hasMore ? matches.at(-1)?.line ?? null : null,
+        ...(warning === undefined ? {} : { warning, requestedLimit: warning.requestedLimit, limit: warning.appliedLimit }),
     };
 }
-function readPage(text, sha256, command) {
-    const metadata = { file: command.file, sha256, offset: command.offset, nextOffset: Number.MAX_SAFE_INTEGER, eof: false, content: "" };
+function readPage(text, source, command, warning) {
+    const metadata = {
+        ...source,
+        ...(warning === undefined ? {} : {
+            warning,
+            requestedLimit: warning.requestedLimit,
+            limit: warning.appliedLimit,
+        }),
+        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;
@@ -175,8 +221,16 @@ function readPage(text, sha256, command) {
         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 {
@@ -186,6 +240,7 @@ export async function runMemoryReadCommand(argv, io) {
                 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" },
             },
         });
@@ -201,24 +256,54 @@ export async function runMemoryReadCommand(argv, io) {
             ...(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}`);
+        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 normalized = normalizeLimit(command.limit, SEARCH_LIMIT_MAX, SEARCH_LIMIT_SAFE);
+            const result = await searchPendingMemoryPage({ agentDir: io.env.CREW_HOME, query: command.query,
+                ...(command.cursor === undefined ? {} : { cursor: command.cursor }), limit: normalized.limit });
+            writeResult({ ...result, ...(normalized.warning === undefined ? {} : {
+                    warning: normalized.warning, requestedLimit: normalized.warning.requestedLimit, limit: normalized.warning.appliedLimit,
+                }) }, 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 normalized = normalizeLimit(command.limit, READ_LIMIT_MAX, READ_LIMIT_SAFE);
+            const { content, ...metadata } = await readPendingMemoryBody({ agentDir: io.env.CREW_HOME,
+                pendingId: command.id, ...(command.ifHash === undefined ? {} : { ifHash: command.ifHash }) });
+            writeResult(readPage(content, metadata, { ...command, limit: normalized.limit }, normalized.warning), 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, source.sha256, command);
-        io.out(JSON.stringify(result));
+            ? (() => {
+                const normalized = normalizeLimit(command.limit, SEARCH_LIMIT_MAX, SEARCH_LIMIT_SAFE);
+                return searchSource(source.text, source.sha256, { ...command, limit: normalized.limit }, normalized.warning);
+            })()
+            : (() => {
+                const normalized = normalizeLimit(command.limit, READ_LIMIT_MAX, READ_LIMIT_SAFE);
+                return readPage(source.text, { file: command.file, sha256: source.sha256 }, { ...command, limit: normalized.limit }, normalized.warning);
+            })();
+        writeResult(result, io);
         return 0;
     }
     catch (error) {
         const code = error.code;
-        const known = error instanceof Error && /^memory_[a-z_]+$/u.test(error.message) ? error.message : code ?? "memory_read_failed";
+        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;
     }

package/dist/local-memory/rollout.js

@@ -0,0 +1,82 @@
+import { lstat, readdir, realpath } from "node:fs/promises";
+import { join } from "node:path";
+import { localMemoryV2Environment } from "../config.js";
+import { memorySeed } from "../workspace.js";
+import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP } from "./index-budget.js";
+import { inventoryLimits, readMemoryInventorySource } from "./inventory-source.js";
+import { previewMemoryInventory } from "./inventory-preview.js";
+import { parseLocalMemoryIndex } from "./write.js";
+import { dslog } from "../slog.js";
+export const LOCAL_MEMORY_V2_DEFERRED_GUIDANCE = `
+
+## 本轮本地记忆兼容状态
+开发环境已开放 V2，但该 Agent 的旧记忆尚未通过格式兼容检查，本轮未启用结构化 V2。
+本节覆盖前文和旧会话中直接改写共享记忆的要求：本轮 MEMORY.md 与 notes 只读，不得改写、迁移或清空。
+用户要求新增或更新长期规则时，内容和授权均只记录到本任务的 $CREW_TASK_LOG；保留日志，不要清空，不要宣称长期记忆已生效。旧资料兼容处理完成前，记忆收尾会明确报告需要处理。`;
+export function reportLocalMemoryV2Deferred(executionId, handle, memoryPrune) {
+    dslog("local_memory.v2_deferred", "旧记忆尚未通过兼容检查，保留原资料和待处理日志", {
+        execution_id: executionId, agent_handle: handle, reason: "requires_migration"
+    });
+    if (memoryPrune)
+        throw new Error("local_memory_v2_requires_migration");
+}
+/** 只核对小型索引和其引用；不扫描全部历史任务、不迁移或生成新存储。 */
+export async function resolveLocalMemoryV2Rollout(input) {
+    const environment = localMemoryV2Environment(input.serverUrl);
+    if (input.selfTraining || environment === "production")
+        return { enabled: false, deferred: false };
+    if (environment === "custom")
+        return { enabled: input.requested, deferred: false };
+    const deferred = { enabled: false, deferred: true };
+    const { workspace } = input;
+    if (Array.from(workspace.memory).length > LOCAL_MEMORY_TOTAL_CODE_POINT_CAP)
+        return deferred;
+    try {
+        const root = await realpath(workspace.dir);
+        const notesStat = await lstat(join(root, "notes"));
+        if (!notesStat.isDirectory() || notesStat.isSymbolicLink())
+            return deferred;
+        const memory = await readMemoryInventorySource(root, "MEMORY.md", inventoryLimits.fileBytes);
+        if (memory.content !== workspace.memory)
+            return deferred;
+        // 完整种子且无旧明细才可按空记忆接入；marker 不能替代这项核对。
+        const seededRole = /^## Role\n([\s\S]*?)\n\n## Core Goals\n/mu.exec(memory.content)?.[1];
+        if (seededRole !== undefined && memory.content === memorySeed(input.handle, seededRole)) {
+            return (await readdir(join(root, "notes"))).length === 0 ? { enabled: true, deferred: false } : deferred;
+        }
+        const generated = /<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=1 -->[\s\S]*?<!-- NOWWORK:MEMORY_INDEX:END -->/u.exec(memory.content)?.[0];
+        if (!generated || Array.from(generated).length > LOCAL_MEMORY_INDEX_CODE_POINT_CAP)
+            return deferred;
+        const entries = parseLocalMemoryIndex(memory.content);
+        if (entries.length > LOCAL_MEMORY_INDEX_ENTRY_CAP)
+            return deferred;
+        const sources = [memory];
+        let remaining = inventoryLimits.totalBytes - memory.bytes;
+        for (const file of new Set(entries.map(entry => entry.file))) {
+            if (!/^notes\/(preferences|project-rules|testing|debugging|git|incidents|lessons)\.md$/u.test(file))
+                return deferred;
+            const source = await readMemoryInventorySource(root, file, Math.min(inventoryLimits.fileBytes, remaining));
+            sources.push(source);
+            remaining -= source.bytes;
+        }
+        const preview = previewMemoryInventory(sources, true, "existing_v2");
+        // 此处只放行现有V2；旧格式和未标记混合卡片都留待显式兼容处理。
+        if (preview.entries.some(entry => entry.format !== "managed")
+            || preview.issues.some(issue => !["managed_anchor_invalid", "projection_over_budget"].includes(issue.code)))
+            return deferred;
+        // 现有writer只改状态时不会重写正文块的revision；兼容门槛不能因此拒绝合法置顶。
+        for (const entry of entries) {
+            if (!/^[A-Za-z0-9_-]+$/u.test(entry.id))
+                return deferred;
+            const detail = sources.find(source => source.path === entry.file)?.content ?? "";
+            const begins = [...detail.matchAll(new RegExp(`<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${entry.id} revision=[1-9][0-9]* -->`, "gu"))];
+            const end = `<!-- NOWWORK:MEMORY_ENTRY:END id=${entry.id} -->`;
+            if (begins.length !== 1 || detail.split(end).length !== 2 || detail.indexOf(end) < begins[0].index)
+                return deferred;
+        }
+        return { enabled: true, deferred: false };
+    }
+    catch {
+        return deferred;
+    }
+}

package/dist/local-memory/runtime.js

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
 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 { lstat, mkdir, open, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
 import { applyLocalMemoryResult, parseLocalMemoryResult } from "./write.js";
+import { verifyWorkLogSource } from "./work-log.js";
 export function isLocalMemoryV2Eligible(input) {
     // The allowlist is the rollout boundary. The marker and seed/pre-existing
     // state are retained as diagnostics and for backward-compatible marker
@@ -69,8 +70,8 @@ outcome 只允许 no_change、proposed、conflict、failed。新增、更新、
 \`\`\`
 
 每个 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 归档中；后续相关任务会按需召回，索引腾出空间后可自动提升。
-写入候选文件不等于已经记住，只有 daemon 校验并提交成功后记忆才生效。本结构化轮次覆盖前文提前清理工作日志的要求：保留 $CREW_TASK_LOG，不要清空或删除；daemon 将在提交成功后清理，失败时保留日志和候选用于排查或重试。
+只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、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. */
@@ -80,6 +81,11 @@ export function renderLocalMemoryV2WriteGuard() {
 ## V2 shared memory write safety
 本节覆盖前文关于普通任务直接更新共享记忆的例外规则。本 Agent 已启用结构化本地记忆 V2。普通任务不得直接编辑共享的 $CREW_HOME/MEMORY.md 或 $CREW_HOME/notes/ 文件；即使用户明确要求记住内容，也只把候选、用户授权和分类理由记录到本任务的 $CREW_TASK_LOG，留给任务结束后的 memory-prune 结构化收尾应用。只有 memory-prune 收尾提示明确要求写入 daemon 提供的 result 文件时，才按该协议提交候选。`;
 }
+function workLogFailure(error) {
+    const reason = error instanceof Error ? error.message : "";
+    return { status: "failed", error: reason === "local_memory_work_log_source_changed"
+            || reason === "local_memory_work_log_version_missing" ? reason : "local_memory_work_log_cleanup_failed" };
+}
 export async function commitLocalMemoryResultAfterExit(input) {
     if (input.exitCode !== 0)
         return { status: "skipped" };
@@ -97,6 +103,14 @@ export async function commitLocalMemoryResultAfterExit(input) {
         if (result.outcome === "conflict" || result.outcome === "failed") {
             return { status: "failed", error: `local_memory_result_${result.outcome}` };
         }
+        if (input.workLogPath !== undefined) {
+            try {
+                await verifyWorkLogSource(input.agentDir, input.workLogPath, input.expectedWorkLogSha256);
+            }
+            catch (error) {
+                return workLogFailure(error);
+            }
+        }
         await applyLocalMemoryResult({
             agentDir: input.agentDir,
             result,
@@ -109,20 +123,12 @@ export async function commitLocalMemoryResultAfterExit(input) {
     }
     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 before = await verifyWorkLogSource(input.agentDir, input.workLogPath, input.expectedWorkLogSha256);
             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) {
+                if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino
+                    || opened.size !== before.size || opened.mtimeMs !== before.mtimeMs || opened.ctimeMs !== before.ctimeMs) {
                     throw new Error("local_memory_work_log_path_changed");
                 }
                 await handle.truncate(0);
@@ -131,8 +137,8 @@ export async function commitLocalMemoryResultAfterExit(input) {
                 await handle.close();
             }
         }
-        catch {
-            return { status: "failed", error: "local_memory_work_log_cleanup_failed" };
+        catch (error) {
+            return workLogFailure(error);
         }
     }
     try {

package/dist/local-memory/work-log-execution.js

@@ -0,0 +1,31 @@
+import { resolve } from "node:path";
+import { withKeyedLease } from "../local-execution-lease.js";
+// 只记录尚未结束的本机执行，最后一个执行结束即移除，不落盘。
+const activeExecutions = new Map();
+export function workLogExecutionKey(agentsRoot, handle, taskKey) {
+    return `work-log:${JSON.stringify([resolve(agentsRoot, handle), taskKey ?? "default"])}`;
+}
+export async function withWorkLogExecution(key, operation, cancellation) {
+    // 只在登记期间持锁；普通任务与收尾的模型调用仍可并行。
+    await withKeyedLease(key, async () => {
+        activeExecutions.set(key, (activeExecutions.get(key) ?? 0) + 1);
+    }, cancellation);
+    try {
+        return await operation();
+    }
+    finally {
+        const remaining = (activeExecutions.get(key) ?? 1) - 1;
+        if (remaining === 0)
+            activeExecutions.delete(key);
+        else
+            activeExecutions.set(key, remaining);
+    }
+}
+export async function withWorkLogCommit(key, operation, cancellation) {
+    return withKeyedLease(key, async () => {
+        // 已有同任务执行可能继续写日志，不能提交旧提案；新执行等短提交结束后再登记。
+        if (activeExecutions.get(key) !== 1)
+            throw new Error("local_memory_work_log_execution_conflict");
+        return operation();
+    }, cancellation);
+}

package/dist/local-memory/work-log.js

@@ -0,0 +1,58 @@
+import { lstat, readFile, realpath } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { safeKey } from "../workspace.js";
+/** 收尾会话可以换目录，但仍应消费同一任务已写好的日志；不迁移文件或复用会话。 */
+export async function resolveMemoryPruneWorkLog(workspace, input) {
+    // 旧映射有损时无法证明是同一任务，不能用它查找或清理来源。
+    if (input.keyMode !== "opaque" || !input.taskKey || safeKey(input.taskKey) !== input.taskKey) {
+        return workspace;
+    }
+    const legacyPath = join(workspace.dir, "tasks", input.taskKey, "work-log.md");
+    if (legacyPath === workspace.workLogPath)
+        return workspace;
+    let legacyStat;
+    try {
+        legacyStat = await lstat(legacyPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return workspace;
+        throw error;
+    }
+    if (!legacyStat.isFile() || legacyStat.isSymbolicLink()
+        || await realpath(legacyPath) !== join(await realpath(workspace.dir), "tasks", input.taskKey, "work-log.md")) {
+        throw new Error("local_memory_work_log_path_invalid");
+    }
+    const workLog = await readFile(legacyPath, "utf8");
+    if (workLog.length === 0)
+        return workspace;
+    if ((await readFile(workspace.workLogPath, "utf8")).length > 0) {
+        throw new Error("local_memory_work_log_source_conflict");
+    }
+    return { ...workspace, workLogPath: legacyPath, workLog };
+}
+export function workLogSha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+/** 调用方须在同任务的提交互斥边界内校验；指纹对应实际注入模型的那一版内容。 */
+export async function verifyWorkLogSource(agentDir, path, expectedSha256) {
+    if (expectedSha256 === undefined)
+        throw new Error("local_memory_work_log_version_missing");
+    const relativePath = relative(resolve(agentDir), resolve(path));
+    if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+        throw new Error("local_memory_work_log_path_invalid");
+    }
+    const before = await lstat(path);
+    if (!before.isFile() || before.isSymbolicLink()
+        || await realpath(path) !== join(await realpath(agentDir), relativePath)) {
+        throw new Error("local_memory_work_log_path_invalid");
+    }
+    const content = await readFile(path);
+    const after = await lstat(path);
+    if (workLogSha256(content) !== expectedSha256 || before.dev !== after.dev || before.ino !== after.ino
+        || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) {
+        throw new Error("local_memory_work_log_source_changed");
+    }
+    return after;
+}

package/dist/local-memory/write.js

@@ -2,29 +2,12 @@ import { createHash, randomUUID } from "node:crypto";
 import { lstat, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
-import { containsLikelySecret } from "../agent-memory/policy.js";
-import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderLocalMemoryIndexCard, selectLocalMemoryIndexEntries, } from "./index-budget.js";
+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";
-const CategorySchema = z.enum([
-    "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
-]);
-const SingleLineText = z.string().trim().min(1).max(500).regex(/^[^\r\n]+$/u);
-const ChangeSchema = z.object({
-    operation: z.enum(["create", "update", "supersede"]),
-    memoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
-    baseRevision: z.number().int().nonnegative().nullable(),
-    supersedesMemoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
-    title: SingleLineText.max(120),
-    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
-    summary: SingleLineText,
-    triggers: z.array(SingleLineText.max(80)).min(1).max(16),
-    priority: z.enum(["high", "medium", "low"]),
-    detailCategory: CategorySchema,
-    detailBody: z.string().trim().min(1).max(12_000),
-    reviewAfter: SingleLineText.nullable(),
-}).strict();
 const StatusChangeSchema = z.object({
-    memoryId: SingleLineText,
+    memoryId: LocalMemorySingleLineText,
     expectedRevision: z.number().int().positive(),
     expectedStatus: z.enum(["candidate", "active", "pinned", "stale", "superseded", "archived"]),
     targetStatus: z.enum(["candidate", "active", "pinned", "stale", "archived"]),
@@ -35,7 +18,7 @@ const ResultSchema = z.object({
     purpose: z.literal("memory_prune"),
     baseCatalogRevision: z.number().int().nonnegative(),
     outcome: z.enum(["no_change", "proposed", "conflict", "failed"]),
-    changes: z.array(ChangeSchema).max(50),
+    changes: z.array(LocalMemoryChangeSchema).max(50),
     statusChanges: z.array(StatusChangeSchema).max(50),
 }).strict();
 const GENERATED_INDEX_PATTERN = /<!--\s*NOWWORK:MEMORY_INDEX:BEGIN\s+schema=1\s*-->[\s\S]*?<!--\s*NOWWORK:MEMORY_INDEX:END\s*-->/u;
@@ -43,8 +26,6 @@ const INDEX_HEADING = /^##\s+Knowledge Index\s*$/mu;
 const NEXT_SECTION = /^##\s+(?!#)/mu;
 const CARD_HEADING = /^###\s+(.+?)\s*$/gmu;
 const FIELD_LINE = /^-\s+([a-z][a-z_]*)\s*:\s*(.*?)\s*$/iu;
-const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
-const RESERVED_MEMORY_MARKER = /NOWWORK:(?:MEMORY_ENTRY|MEMORY_INDEX):/iu;
 function codePointLength(value) {
     return Array.from(value).length;
 }
@@ -117,13 +98,6 @@ function parseUnmarkedMemoryIndex(memory) {
     const section = indexSection(memory).replace(GENERATED_INDEX_PATTERN, "");
     return parseCards(section);
 }
-function renderGeneratedIndex(entries) {
-    const cards = entries
-        .filter((entry) => entry.status === "pinned" || entry.status === "active")
-        .map(renderLocalMemoryIndexCard)
-        .join("\n");
-    return `<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=1 -->\n${cards}<!-- NOWWORK:MEMORY_INDEX:END -->`;
-}
 function replaceGeneratedIndex(memory, entries) {
     const generated = renderGeneratedIndex(entries);
     if (GENERATED_INDEX_PATTERN.test(memory))
@@ -135,9 +109,15 @@ function replaceGeneratedIndex(memory, entries) {
     }
     return `${memory.trimEnd()}\n\n## Knowledge Index\n${generated}\n`;
 }
+function unwrappedNoteBody(title, body) {
+    const detail = body.trim();
+    const heading = /^([^\r\n]+)\r?\n\r?\n/u.exec(detail);
+    // Agent 可能回传包含包装标题的全文；只解开一层，保留内部及历史标题。
+    return heading?.[1] === `## ${title}` ? detail.slice(heading[0].length) : detail;
+}
 function noteSection(id, revision, title, body) {
     return `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id} revision=${revision} -->\n`
-        + `## ${title}\n\n${body.trim()}\n`
+        + `## ${title}\n\n${unwrappedNoteBody(title, body)}\n`
         + `<!-- NOWWORK:MEMORY_ENTRY:END id=${id} -->\n`;
 }
 function notePattern(id) {
@@ -148,34 +128,12 @@ function replaceNote(content, id, replacement) {
     const pattern = notePattern(id);
     return pattern.test(content) ? content.replace(pattern, replacement) : null;
 }
-function containsReservedText(change) {
-    return RESERVED_MEMORY_MARKER.test([change.title, change.summary, ...change.triggers, change.detailBody].join("\n"));
-}
 function validateCandidate(result) {
     if (result.outcome === "no_change" && (result.changes.length > 0 || result.statusChanges.length > 0)) {
         throw new Error("local_memory_no_change_has_operations");
     }
-    for (const change of result.changes) {
-        const text = [change.title, change.summary, ...change.triggers, change.detailBody].join("\n");
-        if (containsLikelySecret(text))
-            throw new Error("local_memory_secret_candidate");
-        if (CONTROL_CHARACTER_PATTERN.test(text))
-            throw new Error("local_memory_control_character");
-        if (containsReservedText(change))
-            throw new Error("local_memory_reserved_marker");
-        if (change.operation === "create"
-            && (change.memoryId !== null || change.baseRevision !== null || change.supersedesMemoryId !== null)) {
-            throw new Error("local_memory_create_revision_invalid");
-        }
-        if (change.operation === "update"
-            && (change.memoryId === null || change.baseRevision === null || change.supersedesMemoryId !== null)) {
-            throw new Error("local_memory_update_revision_missing");
-        }
-        if (change.operation === "supersede"
-            && (change.memoryId !== null || change.baseRevision === null || change.supersedesMemoryId === null)) {
-            throw new Error("local_memory_supersede_revision_missing");
-        }
-    }
+    for (const change of result.changes)
+        validateLocalMemoryChange(change);
 }
 export function parseLocalMemoryResult(raw) {
     let value;
@@ -477,7 +435,16 @@ export async function applyLocalMemoryResult(input) {
         // Pending create candidates are durable overflow, not dead ends. Promote only
         // when the current catalog has room; supersede/update candidates stay pending
         // until a fresh revision-aware decision can safely replay them.
-        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir });
+        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir }).catch((error) => {
+            if (!(error instanceof Error) || error.message !== "memory_pending_directory_over_budget")
+                throw error;
+            // 自动提升是可选工作，目录查询预算不应阻断本轮已验证的更新或腾位操作。
+            dslog("local_memory.pending_promotion_skipped", "pending目录超出扫描预算，本轮跳过自动提升", {
+                level: "WARN", execution_id: input.executionId, prune_trace_id: input.pruneTraceId,
+                reason: "memory_pending_directory_over_budget",
+            });
+            return [];
+        });
         for (const pending of pendingCandidatesOnDisk) {
             const change = pending.candidate;
             if (change.operation !== "create")
@@ -494,8 +461,10 @@ export async function applyLocalMemoryResult(input) {
             if (duplicate !== undefined) {
                 const duplicatePath = resolve(input.agentDir, duplicate.file);
                 const duplicateBody = readNoteBody(noteUpdates.get(duplicatePath) ?? await readNote(duplicatePath), duplicate.id);
-                if (duplicateBody === change.detailBody)
+                if (duplicateBody === change.detailBody
+                    || duplicateBody === unwrappedNoteBody(change.title, change.detailBody).trim()) {
                     resolvedPendingIds.add(pending.pendingId);
+                }
                 continue;
             }
             const entry = entryFromChange(change, id, 1, "active");