@nowcrew/daemon 0.6.88-beta.10 → 0.6.88-beta.11

package/dist/local-execution-lease.js

@@ -0,0 +1,22 @@
+import { awaitWithCancellation } from "./runtime-cancellation.js";
+const leaseTails = new Map();
+/** 同一进程内的短操作或原生会话排队；等待取消也不会越过前一位持有者。 */
+export async function withKeyedLease(key, operation, cancellation) {
+    const predecessor = leaseTails.get(key) ?? Promise.resolve();
+    // 解锁函数在等待 predecessor 前可用，保留取消等待时的队列顺序。
+    let unlock;
+    const current = new Promise(resolve => { unlock = resolve; });
+    const queued = predecessor.then(() => current);
+    leaseTails.set(key, queued);
+    try {
+        await awaitWithCancellation(predecessor, cancellation);
+        return await operation();
+    }
+    finally {
+        unlock();
+        void queued.then(() => {
+            if (leaseTails.get(key) === queued)
+                leaseTails.delete(key);
+        });
+    }
+}

package/dist/local-executor.js

@@ -17,6 +17,9 @@ import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
 import { NativeThreadContext, isolateMaintenanceSession } from "./native-thread-context.js";
 import { prepareThreadDelivery } from "./thread-input-delivery.js";
+import { resolveMemoryPruneWorkLog, workLogSha256 } from "./local-memory/work-log.js";
+import { withKeyedLease } from "./local-execution-lease.js";
+import { withWorkLogExecution, withWorkLogCommit, workLogExecutionKey } from "./local-memory/work-log-execution.js";
 import { providerErrorFromExit } from "./provider-error.js";
 import { createConsoleFormatter } from "./console-formatter.js";
 import { withLocalExecutionFacts, } from "./local-execution-prompt.js";
@@ -159,28 +162,12 @@ async function launchLegacyRuntime(request) {
 function resolvePrompt(prompt, context) {
     return typeof prompt === "string" ? prompt : prompt(context);
 }
-const nativeSessionLeaseTails = new Map();
 const activeMemoryPrunes = new Map();
-async function withKeyedLease(key, operation, cancellation) {
-    const predecessor = nativeSessionLeaseTails.get(key) ?? Promise.resolve();
-    let release;
-    const current = new Promise((resolve) => { release = resolve; });
-    const tail = predecessor.then(() => current);
-    nativeSessionLeaseTails.set(key, tail);
-    try {
-        await awaitWithCancellation(predecessor, cancellation);
-        return await operation();
-    }
-    finally {
-        release();
-        void tail.then(() => {
-            if (nativeSessionLeaseTails.get(key) === tail)
-                nativeSessionLeaseTails.delete(key);
-        });
-    }
-}
 export async function executeLocal(input, callbacks = {}, dependencies = {}) {
     input = isolateMaintenanceSession(input);
+    return withWorkLogExecution(workLogExecutionKey(input.launch.agentsRoot, input.handle, input.taskKey), () => executeLocalWithSession(input, callbacks, dependencies), dependencies.cancellation);
+}
+async function executeLocalWithSession(input, callbacks, dependencies) {
     const versionedProjectSkills = input.projectSkills !== undefined
         && !Array.isArray(input.projectSkills);
     if (versionedProjectSkills && (input.runtime.name !== "codex" && input.runtime.name !== "claude")) {
@@ -357,7 +344,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             ? await rotateAgentSession(workspace.sessionDir)
             : workspace.agentSessionId);
         await materializePrivateCodexHome({ runtime: runtime.name, homeDir: workspace.homeDir, ...(input.launch.codexHomeMode === undefined ? {} : { mode: input.launch.codexHomeMode }), ...(sourceCodexHome === undefined ? {} : { sourceHome: sourceCodexHome }), ...(launchSessionId === undefined ? {} : { sessionId: launchSessionId }), ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }), ...(dependencies.materializeDefaultCodexHome === undefined ? {} : { materialize: dependencies.materializeDefaultCodexHome }) });
-        const promptContext = {
+        let promptContext = {
             workspace: executionWorkspace,
             resuming,
             rotatedForBudget,
@@ -396,8 +383,13 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             }
         }
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
-        const baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
+        let baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
         memoryPruneTraceId = parseMemoryPruneTraceId(baseWakePrompt);
+        if (memoryPruneTraceId !== null) {
+            executionWorkspace = await resolveMemoryPruneWorkLog(executionWorkspace, input);
+            promptContext = { ...promptContext, workspace: executionWorkspace };
+            baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
+        }
         if (input.localMemoryV2Enabled === true && memoryPruneTraceId !== null
             && isLocalMemoryV2Eligible({
                 enabledForHandle: true,
@@ -937,14 +929,17 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         memoryPruneRuntimeExitCode = exitCode;
         if (localMemoryResultPath !== null) {
             memoryPruneFailurePhase = "memory_commit";
-            const committed = await commitLocalMemoryResultAfterExit({
-                resultPath: localMemoryResultPath,
+            const resultPath = localMemoryResultPath;
+            const commit = () => commitLocalMemoryResultAfterExit({
+                resultPath,
                 agentDir: executionWorkspace.dir,
                 executionId: input.executionId,
                 pruneTraceId: memoryPruneTraceId,
                 exitCode,
                 workLogPath: executionWorkspace.workLogPath,
+                expectedWorkLogSha256: workLogSha256(executionWorkspace.workLog),
             });
+            const committed = exitCode !== 0 ? await commit() : await withWorkLogCommit(workLogExecutionKey(input.launch.agentsRoot, input.handle, input.taskKey), commit, dependencies.cancellation);
             if (committed.status === "failed" || committed.status === "missing") {
                 const reason = committed.error ?? "local_memory_result_missing";
                 dslog("local_memory.commit_failed", "结构化本地记忆提交或清理未完成，保留可用恢复材料", {

package/dist/local-memory/index-budget.js

@@ -19,6 +19,14 @@ export function renderLocalMemoryIndexCard(entry) {
         + `- updated: ${entry.updated}\n`
         + (entry.reviewAfter === null ? "" : `- review_after: ${entry.reviewAfter}\n`);
 }
+/** 写入和预演共用完整索引，预算包含起止标记与分隔换行。 */
+export function renderGeneratedIndex(entries) {
+    const cards = entries
+        .filter(entry => PROJECTABLE_STATUSES.has(entry.status))
+        .map(renderLocalMemoryIndexCard)
+        .join("\n");
+    return `<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=1 -->\n${cards}<!-- NOWWORK:MEMORY_INDEX:END -->`;
+}
 function compareEntries(left, right) {
     const statusRank = (status) => status === "pinned" ? 0 : 1;
     const priorityRank = (priority) => (priority === "high" ? 0 : priority === "medium" ? 1 : 2);

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

@@ -0,0 +1,61 @@
+const CommandSchema = z.object({
+    "agent-dir": z.string().min(1).refine(isAbsolute),
+    "dry-run": z.literal(true),
+}).strict();
+const USAGE = "只读记忆盘点与转换预演，不写文件，不支持 --apply。\n"
+    + "pnpm --filter @nowcrew/daemon exec tsx src/local-memory/inventory-cli.ts --agent-dir <单个Agent绝对路径> --dry-run\n"
+    + "报告包含原始记忆，需作为敏感本地资料保存；退出码0仅代表盘点及格式预演无阻塞，不代表批准迁移。\n";
+export async function runMemoryInventoryCommand(args, io) {
+    if (args.length === 1 && args[0] === "--help") {
+        io.out(USAGE);
+        return 0;
+    }
+    let command;
+    try {
+        const parsed = parseArgs({ args, allowPositionals: false, options: {
+                "agent-dir": { type: "string" }, "dry-run": { type: "boolean" },
+            } });
+        command = CommandSchema.parse(parsed.values);
+    }
+    catch {
+        io.err(USAGE);
+        return 2;
+    }
+    try {
+        const scan = await scanMemorySources(command["agent-dir"]);
+        const scanComplete = scan.issues.length === 0;
+        const analysis = previewMemoryInventory(scan.sources, scanComplete);
+        const complete = scanComplete && !analysis.issues.some((issue) => issue.code === "missing_detail");
+        const issues = [...scan.issues, ...analysis.issues];
+        const referenced = new Set(analysis.entries.map((entry) => entry.sourceFields.file));
+        const files = scan.sources.map(({ path, bytes, sha256 }) => ({ path, bytes, sha256 }));
+        const report = {
+            schemaVersion: 1, mode: "dry-run", agentDir: scan.root, applySupported: false,
+            complete, scanComplete, requiresHumanReview: true,
+            coverage: ["MEMORY.md", "notes/**", ".crew/memory/pending/**", "根目录的 .memory-result.v1-*.json"],
+            limitations: ["不扫描历史执行目录；result清单仅覆盖Agent根目录。", "两遍摘要比对不等同跨文件原子快照，正式迁移仍需停止写入并重新核对。"],
+            limits: inventoryLimits, totalBytes: scan.totalBytes, files, ...analysis, issues,
+            pending: files.filter((file) => file.path.startsWith(".crew/memory/pending/")).map((file) => file.path),
+            orphanNotes: files.filter((file) => file.path.startsWith("notes/") && !referenced.has(file.path)).map((file) => file.path),
+            resultFiles: files.filter((file) => file.path.startsWith(".memory-result.v1-")).map((file) => file.path),
+        };
+        io.out(JSON.stringify(report, null, 2) + "\n");
+        return issues.length ? 1 : 0;
+    }
+    catch (error) {
+        const code = error instanceof Error ? error.code ?? error.message : "inventory_failed";
+        io.err(`记忆盘点失败：${code}\n`);
+        return 1;
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+    process.exitCode = await runMemoryInventoryCommand(process.argv.slice(2), {
+        out: (text) => process.stdout.write(text), err: (text) => process.stderr.write(text),
+    });
+}
+import { isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+import { z } from "zod";
+import { inventoryLimits, scanMemorySources } from "./inventory-source.js";
+import { previewMemoryInventory } from "./inventory-preview.js";

package/dist/local-memory/inventory-preview.js

@@ -0,0 +1,154 @@
+import { createHash } from "node:crypto";
+import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderGeneratedIndex, } from "./index-budget.js";
+import { parseLocalMemoryIndex } from "./write.js";
+const GENERATED = /<!--\s*NOWWORK:MEMORY_INDEX:BEGIN\s+schema=1\s*-->[\s\S]*?<!--\s*NOWWORK:MEMORY_INDEX:END\s*-->/gu;
+const REFERENCE = /^notes\/(?!.*(?:^|\/)\.\.?\/)(?:[^/\\\u0000-\u001f]+\/)*[^/\\\u0000-\u001f]+\.md$/u;
+const FIELD = /^-\s+([a-z][a-z_]*)\s*:\s*(.*?)\s*$/iu;
+const WRITABLE_FILES = new Set(["preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons"]
+    .map((category) => `notes/${category}.md`));
+const length = (text) => Array.from(text).length;
+const digest = (text) => createHash("sha256").update(text).digest("hex");
+export function previewMemoryInventory(sources, readComplete) {
+    const issues = [];
+    const entries = [];
+    const sourceMap = new Map(sources.map((source) => [source.path, source]));
+    const memory = sourceMap.get("MEMORY.md")?.content ?? "";
+    const add = (code, path = "MEMORY.md") => issues.push({ code, path });
+    // 掩盖注释但保留UTF-16位置，避免把模板示例当成条目，也保留原文供人工复核。
+    const comments = [...memory.matchAll(/<!--[\s\S]*?-->/gu)];
+    if ((memory.match(/<!--/gu) ?? []).length !== comments.length
+        || (memory.match(/-->/gu) ?? []).length !== comments.length)
+        add("comment_boundary_invalid");
+    const masked = memory.replace(/<!--[\s\S]*?-->/gu, (comment) => comment.replace(/[^\r\n]/gu, (character) => " ".repeat(character.length)));
+    const sections = [...masked.matchAll(/^##[\t ]+Knowledge Index[\t ]*\r?$/gmu)];
+    const heading = sections[0];
+    if (sections.length !== 1 || heading?.index === undefined)
+        add("index_heading_invalid");
+    const start = heading === undefined ? 0 : heading.index + heading[0].length;
+    const next = /^##[\t ]+(?!#)/mu.exec(masked.slice(start));
+    const end = next?.index === undefined ? memory.length : start + next.index;
+    const generated = [...memory.matchAll(GENERATED)];
+    const markerCount = (memory.match(/NOWWORK:MEMORY_INDEX:/gu) ?? []).length;
+    if (markerCount !== generated.length * 2 || generated.length > 1
+        || generated.some((block) => block.index < start || block.index + block[0].length > end))
+        add("index_marker_invalid");
+    const heads = [...masked.slice(start, end).matchAll(/^###[\t ]+(.+?)[\t ]*\r?$/gmu)];
+    if (heads.length > 1000)
+        add("card_limit_exceeded");
+    const ranges = [];
+    for (const [i, head] of heads.slice(0, 1000).entries()) {
+        const cardStart = start + head.index;
+        const cardEnd = heads[i + 1]?.index === undefined ? end : start + heads[i + 1].index;
+        const tailStart = cardStart + head[0].length;
+        const tail = masked.slice(tailStart, cardEnd);
+        const fields = {};
+        const issueStart = issues.length;
+        let lastFieldEnd = tailStart;
+        let proseSeen = false;
+        for (const line of tail.matchAll(/[^\n]*(?:\n|$)/gu)) {
+            const field = FIELD.exec(line[0].replace(/\r?\n$/u, ""));
+            if (field) {
+                const key = field[1].toLowerCase();
+                if (fields[key] !== undefined)
+                    add("duplicate_field");
+                if (proseSeen)
+                    add("ambiguous_card_body");
+                fields[key] = field[2];
+                lastFieldEnd = tailStart + line.index + line[0].length;
+            }
+            else if (line[0].trim())
+                proseSeen = true;
+        }
+        const rawCard = memory.slice(cardStart, lastFieldEnd);
+        const format = generated.some((block) => cardStart >= block.index && cardStart < block.index + block[0].length)
+            ? "managed" : "legacy";
+        const parsed = parseLocalMemoryIndex(`## Knowledge Index\n${rawCard}`)[0];
+        if (!parsed || !fields.type || !fields.summary || !fields.triggers || !fields.priority || !fields.updated
+            || (format === "legacy" && !fields.scope)
+            || !["procedural", "semantic", "episodic", "preference"].includes(fields.type)
+            || !["high", "medium", "low"].includes(fields.priority))
+            add("invalid_card");
+        const file = fields.file ?? "";
+        if (!REFERENCE.test(file) || file.split("/").some((part) => part === "." || part === ".."))
+            add("invalid_reference", file);
+        const detail = sourceMap.get(file)?.content ?? null;
+        if (detail === null)
+            add("missing_detail", file);
+        let proposed = null;
+        if (parsed) {
+            const id = format === "legacy" ? `mem_${digest(rawCard).slice(0, 32)}` : parsed.id;
+            proposed = { ...parsed, id, anchor: id, revision: format === "legacy" ? 1 : parsed.revision };
+            if (format === "managed") {
+                if (!fields.id || !/^[a-zA-Z0-9_-]+$/u.test(fields.id) || fields.anchor !== fields.id
+                    || !/^[1-9][0-9]*$/u.test(fields.revision ?? "") || !Number.isSafeInteger(parsed.revision)
+                    || !["active", "pinned"].includes(fields.status ?? ""))
+                    add("managed_metadata_invalid");
+                const begin = `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${parsed.id} revision=${parsed.revision} -->`;
+                const finish = `<!-- NOWWORK:MEMORY_ENTRY:END id=${parsed.id} -->`;
+                if (!detail?.includes(begin) || !detail.includes(finish)
+                    || detail.indexOf(finish) < detail.indexOf(begin)
+                    || detail.split(begin).length !== 2 || detail.split(finish).length !== 2)
+                    add("managed_anchor_invalid", file);
+            }
+            else if (fields.status && fields.status !== "active") {
+                add("legacy_status_requires_review", file);
+            }
+            if (format === "legacy" && /NOWWORK:MEMORY_(?:ENTRY|INDEX):/u.test(detail ?? ""))
+                add("legacy_detail_contains_markers", file);
+        }
+        entries.push({
+            title: head[1], format, disposition: issues.length === issueStart ? "review_required" : "blocked",
+            sourceFields: fields, rawCard, detail, proposed,
+        });
+        ranges.push({ start: cardStart, end: lastFieldEnd });
+    }
+    for (const entry of entries) {
+        if (entries.filter((other) => other.sourceFields.file === entry.sourceFields.file).length > 1
+            && entry.format === "legacy")
+            add("shared_legacy_detail", entry.sourceFields.file);
+        if (entries.filter((other) => other.proposed?.id === entry.proposed?.id).length > 1)
+            add("duplicate_id");
+        if (entries.filter((other) => other.title.trim().toLowerCase() === entry.title.trim().toLowerCase()).length > 1)
+            add("duplicate_title");
+    }
+    const compatibilityIssues = entries.filter((entry) => !WRITABLE_FILES.has(entry.sourceFields.file ?? ""))
+        .map((entry) => ({ code: "detail_category_mapping_required", path: entry.sourceFields.file ?? "" }));
+    let preview = null;
+    if (readComplete && issues.length === 0) {
+        const index = renderGeneratedIndex(entries.map(entry => entry.proposed));
+        let retained = memory;
+        for (const range of [...ranges].reverse())
+            retained = retained.slice(0, range.start) + retained.slice(range.end);
+        retained = retained.replace(GENERATED, "");
+        // 新生成块仅替换索引卡片，角色、目标、维护说明和其它段落保留。
+        const insertAt = start;
+        const projected = retained.slice(0, insertAt) + `\n${index}\n` + retained.slice(insertAt);
+        const budget = {
+            entries: entries.length, indexCodePoints: length(index), totalCodePoints: length(projected),
+            entryCap: LOCAL_MEMORY_INDEX_ENTRY_CAP, indexCodePointCap: LOCAL_MEMORY_INDEX_CODE_POINT_CAP,
+            totalCodePointCap: LOCAL_MEMORY_TOTAL_CODE_POINT_CAP,
+            fits: entries.length <= LOCAL_MEMORY_INDEX_ENTRY_CAP && length(index) <= LOCAL_MEMORY_INDEX_CODE_POINT_CAP
+                && length(projected) <= LOCAL_MEMORY_TOTAL_CODE_POINT_CAP,
+        };
+        preview = {
+            memory: projected, budget, writerCompatible: compatibilityIssues.length === 0,
+            notes: entries.filter((entry) => entry.format === "legacy").map((entry) => ({
+                path: entry.sourceFields.file,
+                content: `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${entry.proposed.id} revision=1 -->\n`
+                    + `## ${entry.title}\n\n旧索引范围（仍需结合正文人工确认）：${entry.sourceFields.scope}\n\n`
+                    + `${entry.detail}${entry.detail.endsWith("\n") ? "" : "\n"}`
+                    + `<!-- NOWWORK:MEMORY_ENTRY:END id=${entry.proposed.id} -->\n`,
+            })),
+        };
+        if (!budget.fits)
+            add("projection_over_budget");
+    }
+    const shownDetails = new Set();
+    const compactEntries = entries.map((entry) => {
+        const file = entry.sourceFields.file ?? "";
+        const detail = shownDetails.has(file) ? null : entry.detail;
+        shownDetails.add(file);
+        return { ...entry, detail };
+    });
+    return { entries: compactEntries, issues: [...issues, ...compatibilityIssues], preview, rawMemory: memory };
+}

package/dist/local-memory/inventory-source.js

@@ -0,0 +1,159 @@
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, open, readdir, realpath } from "node:fs/promises";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { TextDecoder } from "node:util";
+const MAX_FILE_BYTES = 32 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+const MAX_ITEMS = 10_000;
+const MAX_DEPTH = 32;
+export const inventoryLimits = {
+    fileBytes: MAX_FILE_BYTES, totalBytes: MAX_TOTAL_BYTES, items: MAX_ITEMS, depth: MAX_DEPTH,
+};
+function errorCode(error) {
+    if (error instanceof TypeError)
+        return "invalid_utf8";
+    if (error instanceof Error)
+        return error.code ?? error.message;
+    return "read_failed";
+}
+async function safePath(root, file) {
+    const parts = file.split("/");
+    if (parts.some((part) => !part || part === "." || part === ".." || part.includes("\\"))) {
+        throw new Error("unsafe_path");
+    }
+    let path = root;
+    for (const part of parts) {
+        path = join(path, part);
+        if ((await lstat(path)).isSymbolicLink())
+            throw new Error("unsafe_path");
+    }
+    const actual = await realpath(path);
+    const rel = relative(root, actual);
+    if (actual !== path || isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`)) {
+        throw new Error("unsafe_path");
+    }
+    return path;
+}
+async function readSource(root, file, budget) {
+    const path = await safePath(root, file);
+    const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+    try {
+        const before = await handle.stat();
+        if (!before.isFile())
+            throw new Error("not_regular_file");
+        const limit = Math.min(MAX_FILE_BYTES, budget);
+        if (before.size > limit)
+            throw new Error("read_limit_exceeded");
+        const chunks = [];
+        let bytes = 0;
+        for (;;) {
+            const chunk = Buffer.alloc(Math.min(64 * 1024, limit + 1 - bytes));
+            const { bytesRead } = await handle.read(chunk, 0, chunk.length, null);
+            if (bytesRead === 0)
+                break;
+            bytes += bytesRead;
+            if (bytes > limit)
+                throw new Error("read_limit_exceeded");
+            chunks.push(chunk.subarray(0, bytesRead));
+        }
+        const after = await handle.stat();
+        const current = await lstat(await safePath(root, file));
+        if (before.ino !== current.ino || before.dev !== current.dev || before.size !== after.size
+            || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs)
+            throw new Error("source_changed");
+        const data = Buffer.concat(chunks);
+        return {
+            path: file, bytes,
+            sha256: createHash("sha256").update(data).digest("hex"),
+            content: new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(data),
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function scanMemorySources(agentDir) {
+    const root = await realpath(agentDir);
+    if ((await lstat(agentDir)).isSymbolicLink())
+        throw new Error("agent_root_symlink");
+    if (!(await lstat(root)).isDirectory())
+        throw new Error("agent_root_not_directory");
+    const sources = [];
+    const issues = [];
+    const directories = new Map();
+    let totalBytes = 0;
+    let items = 0;
+    const addIssue = (code, path) => issues.push({ code, path });
+    async function visit(file, optional = false, depth = 0) {
+        if (++items > MAX_ITEMS || depth > MAX_DEPTH) {
+            addIssue("scan_limit_exceeded", file);
+            return;
+        }
+        try {
+            const path = await safePath(root, file);
+            const stat = await lstat(path);
+            if (file === "MEMORY.md" && !stat.isFile())
+                throw new Error("not_regular_file");
+            if ((file === "notes" || file === ".crew/memory/pending") && !stat.isDirectory())
+                throw new Error("not_directory");
+            if (stat.isDirectory()) {
+                const names = (await readdir(path)).sort();
+                directories.set(file, names);
+                for (const name of names) {
+                    if (items >= MAX_ITEMS) {
+                        addIssue("scan_limit_exceeded", file);
+                        break;
+                    }
+                    await visit(`${file}/${name}`, false, depth + 1);
+                }
+            }
+            else {
+                const source = await readSource(root, file, MAX_TOTAL_BYTES - totalBytes);
+                totalBytes += source.bytes;
+                sources.push(source);
+            }
+        }
+        catch (error) {
+            const code = errorCode(error);
+            if (optional && code === "ENOENT")
+                directories.set(file, []);
+            else
+                addIssue(code, file);
+        }
+    }
+    await visit("MEMORY.md");
+    await visit("notes", true);
+    await visit(".crew/memory/pending", true);
+    const resultNames = (await readdir(root)).filter((name) => /^\.memory-result\.v1-.*\.json$/u.test(name)).sort();
+    for (const name of resultNames)
+        await visit(name);
+    // 第二遍比对摘要和目录清单，发现扫描期间的变化就拒绝完整性结论；这不是跨文件事务锁。
+    for (const source of sources) {
+        try {
+            if ((await readSource(root, source.path, MAX_FILE_BYTES)).sha256 !== source.sha256) {
+                addIssue("source_changed", source.path);
+            }
+        }
+        catch (error) {
+            addIssue(errorCode(error), source.path);
+        }
+    }
+    for (const [file, names] of directories) {
+        try {
+            const current = (await readdir(await safePath(root, file))).sort();
+            if (JSON.stringify(current) !== JSON.stringify(names))
+                addIssue("source_changed", file);
+        }
+        catch (error) {
+            if (errorCode(error) !== "ENOENT" || names.length > 0)
+                addIssue("source_changed", file);
+        }
+    }
+    const currentResults = (await readdir(root)).filter((name) => /^\.memory-result\.v1-.*\.json$/u.test(name)).sort();
+    if (JSON.stringify(currentResults) !== JSON.stringify(resultNames))
+        addIssue("source_changed", ".memory-result.v1-*.json");
+    if (await realpath(agentDir) !== root)
+        addIssue("source_changed", "agent_root");
+    return { root, sources: sources.sort((a, b) => a.path.localeCompare(b.path)), issues, totalBytes };
+}

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
@@ -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

@@ -4,7 +4,7 @@ import { dirname, join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
 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, renderLocalMemoryIndexCard, selectLocalMemoryIndexEntries, } from "./index-budget.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 StatusChangeSchema = z.object({
     memoryId: LocalMemorySingleLineText,
@@ -98,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))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.88-beta.10",
+  "version": "0.6.88-beta.11",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",