@nowcrew/daemon 0.6.87-beta.2 → 0.6.87-beta.4

package/dist/cloud-report-uploader.js

@@ -13,22 +13,17 @@ const fileFingerprint = async (path) => {
     const stat = await lstat(path);
     return `${stat.size}:${stat.mtimeMs}`;
 };
-function isReportFile(root, path) {
+function isReportFile(root, path, kind) {
     const parts = relative(root, path).split(sep).filter(Boolean);
     const filename = parts.at(-1) ?? "";
-    if (parts[0] === "tasks" && parts.length >= 3) {
-        return REPORT_FILENAMES.has(filename) || extname(filename).toLowerCase() === ".html";
-    }
-    if (parts[0] !== "qa-report-server-v2")
-        return false;
-    if (parts[1] === "static" && parts.length === 3)
-        return extname(filename).toLowerCase() === ".html";
-    if (parts[1] === "qa-results" && parts.length >= 4) {
+    if (kind === "static")
+        return parts.length === 1 && extname(filename).toLowerCase() === ".html";
+    if (parts.length >= 2) {
         return REPORT_FILENAMES.has(filename) || extname(filename).toLowerCase() === ".html";
     }
     return false;
 }
-async function walkReports(root, directory, depth, output) {
+async function walkReports(root, directory, depth, output, kind) {
     if (depth > MAX_DEPTH || output.length >= MAX_FILES)
         return;
     const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
@@ -39,28 +34,26 @@ async function walkReports(root, directory, depth, output) {
             continue;
         const path = join(directory, entry.name);
         if (entry.isDirectory()) {
-            await walkReports(root, path, depth + 1, output);
+            await walkReports(root, path, depth + 1, output, kind);
         }
-        else if (entry.isFile() && isReportFile(root, path)) {
+        else if (entry.isFile() && isReportFile(root, path, kind)) {
             output.push(resolve(path));
         }
     }
 }
-export async function snapshotReportFiles(root) {
+export async function snapshotReportFiles(root, qaReportRoot) {
     const files = [];
     const workspaceRoot = resolve(root);
-    for (const directory of [
-        join(workspaceRoot, "tasks"),
-        join(workspaceRoot, "qa-report-server-v2", "qa-results"),
-        join(workspaceRoot, "qa-report-server-v2", "static"),
-    ]) {
-        await walkReports(workspaceRoot, directory, 0, files);
+    const hub = resolve(qaReportRoot ?? join(workspaceRoot, "qa-report-server-v2"));
+    for (const kind of ["tasks", "qa-results", "static"]) {
+        const directory = join(kind === "tasks" ? workspaceRoot : hub, kind);
+        await walkReports(directory, directory, 0, files, kind);
     }
     const entries = await Promise.all(files.map(async (path) => [path, await fileFingerprint(path)]));
     return new Map(entries);
 }
-export async function discoverReportFiles(root, before) {
-    const after = await snapshotReportFiles(root);
+export async function discoverReportFiles(root, before, qaReportRoot) {
+    const after = await snapshotReportFiles(root, qaReportRoot);
     return [...after.entries()]
         .filter(([path, fingerprint]) => before.get(path) !== fingerprint)
         .map(([path]) => path)
@@ -97,7 +90,7 @@ async function verifyOssUrl(url) {
     }
 }
 export async function uploadCloudReports(input) {
-    const files = await discoverReportFiles(input.root, input.before);
+    const files = await discoverReportFiles(input.root, input.before, input.qaReportRoot);
     if (files.length === 0)
         return { urls: [], failures: [] };
     const run = input.execFile ?? (async (file, args) => {
@@ -131,10 +124,10 @@ export async function uploadCloudReports(input) {
     }
     return { urls, failures };
 }
-export async function prepareCloudReportSnapshot(facts, root) {
+export async function prepareCloudReportSnapshot(facts, root, qaReportRoot) {
     if (!facts.enabled)
         return null;
-    return snapshotReportFiles(root);
+    return snapshotReportFiles(root, qaReportRoot);
 }
 export async function prepareCloudReportExecution(input) {
     const facts = cloudReportUploadFacts(input.env);
@@ -147,7 +140,7 @@ export async function prepareCloudReportExecution(input) {
         return { facts, snapshot: null };
     }
     try {
-        return { facts, snapshot: await prepareCloudReportSnapshot(facts, input.root) };
+        return { facts, snapshot: await prepareCloudReportSnapshot(facts, input.root, input.qaReportRoot) };
     }
     catch (error) {
         dslog("cloud_report_upload.snapshot_failed", "报告文件快照失败", {
@@ -177,6 +170,7 @@ export async function deliverCloudReports(input) {
         const result = await (input.upload ?? uploadCloudReports)({
             script: input.facts.ossUploadScript,
             root: input.root,
+            ...(input.qaReportRoot === undefined ? {} : { qaReportRoot: input.qaReportRoot }),
             before: input.before,
         });
         if (result.failures.length > 0) {
@@ -185,6 +179,14 @@ export async function deliverCloudReports(input) {
                 uploaded_count: result.urls.length, failed_count: result.failures.length,
             });
         }
+        else {
+            dslog(result.urls.length === 0 ? "cloud_report_upload.no_files" : "cloud_report_upload.completed", result.urls.length === 0 ? "未发现新增或变化的报告文件" : "报告上传完成", {
+                execution_id: input.executionId, agent_handle: input.agentHandle,
+                uploaded_count: result.urls.length,
+                report_root: input.root,
+                qa_report_root: input.qaReportRoot ?? join(input.root, "qa-report-server-v2"),
+            });
+        }
         return {
             finalText: input.captureFinal && result.urls.length > 0
                 ? appendReportLinks(input.finalText ?? "", result.urls)

package/dist/execution-runner.js

@@ -25,6 +25,7 @@ import { PROJECT_WORKSPACES_CAPABILITY } from "./machine-info.js";
 import { PROJECT_SKILL_PROJECTION_V2_CAPABILITY } from "./project-skills/types.js";
 import { dslog } from "./slog.js";
 import { identityRosterPromptFacts } from "./identity-roster-telemetry.js";
+import { renderLocalMemoryV2WriteGuard } from "./local-memory/runtime.js";
 export { supervisorLaunch } from "./supervised-runtime.js";
 const MAX_LOCAL_EXECUTION_ATTEMPTS = 3;
 const ACTIVITY_KIND = {
@@ -828,7 +829,8 @@ export async function runExecution(config, input, dependencies) {
         const baseSystemPromptBudget = spec.agent.abilityRelease === undefined
             ? systemPromptBudget
             : Math.max(0, Math.min(systemPromptBudget, Math.max(32 * 1024, systemPromptBudget - 168 * 1024)));
-        const systemPromptWithLocalFacts = withLocalExecutionFacts(spec.instructions.systemPrompt, baseSystemPromptBudget, {
+        const localMemoryV2Enabled = config.localMemoryV2Handles?.has(spec.agent.handle) === true;
+        const systemPromptWithLocalFacts = withLocalExecutionFacts(`${spec.instructions.systemPrompt}${localMemoryV2Enabled ? renderLocalMemoryV2WriteGuard() : ""}`, baseSystemPromptBudget, {
             ...(selfTraining ? { isolateLocalMemory: true } : {}),
             collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex",
         });
@@ -887,7 +889,7 @@ export async function runExecution(config, input, dependencies) {
                 maxTurns: config.sessionMaxTurns,
             },
             ...(selfTraining ? { maintenancePurpose: "self_training" } : {}),
-            localMemoryV2Enabled: config.localMemoryV2Handles?.has(spec.agent.handle) === true,
+            localMemoryV2Enabled,
         };
         const result = await Promise.race([
             execute(localInput, callbacks, localDependencies),

package/dist/external-output.js

@@ -1,15 +1,104 @@
 export const EXTERNAL_ANSWER_OPEN = "<nowwork_external_answer>";
 export const EXTERNAL_ANSWER_CLOSE = "</nowwork_external_answer>";
-function retainedMarkerPrefix(value, marker) {
-    const maximum = Math.min(value.length, marker.length - 1);
-    for (let length = maximum; length > 0; length -= 1) {
-        if (marker.startsWith(value.slice(-length)))
-            return length;
+const MAX_MARKER_TAG_LENGTH = 96;
+const KNOWN_EXTERNAL_ANSWER_TAG = /^now+orkexternalanswer$/u;
+const CANONICAL_EXTERNAL_ANSWER_TAG = "noworkexternalanswer";
+function editDistanceWithin(value, target, maximum) {
+    if (Math.abs(value.length - target.length) > maximum)
+        return false;
+    let previous = Array.from({ length: target.length + 1 }, (_, index) => index);
+    for (let row = 1; row <= value.length; row += 1) {
+        const current = [row];
+        let rowMinimum = row;
+        for (let column = 1; column <= target.length; column += 1) {
+            const cost = value[row - 1] === target[column - 1] ? 0 : 1;
+            const distance = Math.min(previous[column] + 1, current[column - 1] + 1, previous[column - 1] + cost);
+            current.push(distance);
+            rowMinimum = Math.min(rowMinimum, distance);
+        }
+        if (rowMinimum > maximum)
+            return false;
+        previous = current;
+    }
+    return previous[target.length] <= maximum;
+}
+function resemblesExternalAnswerTag(name) {
+    if (name.includes("externalanswer"))
+        return true;
+    const canonicalized = name.replace(/^now+ork/u, "nowork");
+    return editDistanceWithin(canonicalized, CANONICAL_EXTERNAL_ANSWER_TAG, 2);
+}
+function classifyMarkerTag(body) {
+    const trimmed = body.trim();
+    const closing = trimmed.startsWith("/");
+    const name = (closing ? trimmed.slice(1) : trimmed)
+        .trim()
+        .toLowerCase()
+        .replace(/[_\-\s]/gu, "");
+    if (KNOWN_EXTERNAL_ANSWER_TAG.test(name))
+        return { closing, kind: "known" };
+    return {
+        closing,
+        kind: resemblesExternalAnswerTag(name) ? "suspicious" : "other",
+    };
+}
+function nextMarkerTag(value, from) {
+    let cursor = from;
+    while (cursor < value.length) {
+        const start = value.indexOf("<", cursor);
+        if (start < 0)
+            return null;
+        const end = value.indexOf(">", start + 1);
+        if (end < 0)
+            return null;
+        const body = value.slice(start + 1, end);
+        const classified = classifyMarkerTag(body);
+        if (classified.kind === "suspicious"
+            || (classified.kind === "known" && body.length > MAX_MARKER_TAG_LENGTH)) {
+            return { start, end: end + 1, closing: classified.closing, kind: "suspicious" };
+        }
+        if (classified.kind === "known") {
+            return { start, end: end + 1, closing: classified.closing, kind: "known" };
+        }
+        cursor = end + 1;
+    }
+    return null;
+}
+function parseExternalAnswerText(value) {
+    const sections = [];
+    let cursor = 0;
+    let contentStart = 0;
+    let inside = false;
+    let found = false;
+    for (;;) {
+        const tag = nextMarkerTag(value, cursor);
+        if (!tag)
+            break;
+        if (tag.kind === "suspicious")
+            return { kind: "rejected", text: "" };
+        if (tag.closing) {
+            if (!inside)
+                return { kind: "rejected", text: "" };
+            sections.push(value.slice(contentStart, tag.start));
+            inside = false;
+        }
+        else {
+            if (inside)
+                return { kind: "rejected", text: "" };
+            found = true;
+            inside = true;
+            contentStart = tag.end;
+        }
+        cursor = tag.end;
     }
-    return 0;
+    if (inside)
+        sections.push(value.slice(contentStart));
+    if (!found)
+        return { kind: "plain", text: value.trim() };
+    return { kind: "marked", text: sections.join("").trim() };
 }
 /**
- * 跨 chunk 的契约标签流式解码器:push() 逐段返回标签内文本(供 answerStream 实时转发);
+ * 跨 chunk 的契约标签解码器:push() 在合法闭合后返回完整标签块(供 answerStream 转发);
  * 同时记住整轮里**最后一个完整闭合**的标签块(`lastClosedBlock`),供完结时作为契约答案——
  * 只有闭合了的块才算数:半截块(被工具调用拆开的前半段)与叙述里提到的开标签
  * ("我会把结论包在 <marker> 里,先去跑测试")都不会被当成答案(review of a027bf15, C1)。
@@ -40,34 +129,63 @@ export class ExternalAnswerDecoder {
     }
     consume(value, output) {
         this.pending = "";
-        const marker = this.state === "outside" ? EXTERNAL_ANSWER_OPEN : EXTERNAL_ANSWER_CLOSE;
-        const markerAt = value.indexOf(marker);
-        if (markerAt >= 0) {
-            if (this.state === "inside") {
-                const head = value.slice(0, markerAt);
-                if (head)
-                    output.push(head);
-                const completed = `${this.block}${head}`.trim();
-                if (completed)
-                    this.closed = completed;
-                this.block = "";
-                this.state = "outside";
+        const appendInside = (text) => {
+            if (!text)
+                return;
+            this.block += text;
+        };
+        for (const character of value) {
+            if (this.pending) {
+                this.pending += character;
+                if (character === ">") {
+                    const body = this.pending.slice(1, -1);
+                    const tag = classifyMarkerTag(body);
+                    if (tag.kind === "known" && body.length <= MAX_MARKER_TAG_LENGTH) {
+                        if (tag.closing && this.state === "inside") {
+                            const completed = this.block.trim();
+                            if (completed) {
+                                this.closed = completed;
+                                output.push(completed);
+                            }
+                            this.block = "";
+                            this.state = "outside";
+                        }
+                        else if (!tag.closing && this.state === "outside") {
+                            this.block = "";
+                            this.state = "inside";
+                        }
+                        else {
+                            this.block = "";
+                            this.state = tag.closing ? "outside" : "inside";
+                        }
+                    }
+                    else if (tag.kind === "suspicious" || tag.kind === "known") {
+                        this.block = "";
+                        this.state = "outside";
+                    }
+                    else if (this.state === "inside") {
+                        appendInside(this.pending);
+                    }
+                    this.pending = "";
+                }
+                else if (this.pending.length > MAX_MARKER_TAG_LENGTH + 2) {
+                    const tag = classifyMarkerTag(this.pending.slice(1));
+                    if (tag.kind === "suspicious" || tag.kind === "known") {
+                        this.block = "";
+                        this.state = "outside";
+                    }
+                    else if (this.state === "inside") {
+                        appendInside(this.pending);
+                    }
+                    this.pending = "";
+                }
             }
-            else {
-                this.block = "";
-                this.state = "inside";
+            else if (character === "<") {
+                this.pending = character;
+            }
+            else if (this.state === "inside") {
+                appendInside(character);
             }
-            const remaining = value.slice(markerAt + marker.length);
-            if (remaining)
-                this.consume(remaining, output);
-            return;
-        }
-        const retained = retainedMarkerPrefix(value, marker);
-        const safe = retained > 0 ? value.slice(0, -retained) : value;
-        this.pending = retained > 0 ? value.slice(-retained) : "";
-        if (this.state === "inside" && safe) {
-            output.push(safe);
-            this.block += safe;
         }
     }
 }
@@ -104,20 +222,7 @@ export function decodeExternalOutputEvent(runtime, event, decoder) {
         : [];
 }
 export function stripExternalAnswerMarkers(value) {
-    const sections = [];
-    let cursor = 0;
-    while (cursor < value.length) {
-        const openAt = value.indexOf(EXTERNAL_ANSWER_OPEN, cursor);
-        if (openAt < 0)
-            break;
-        const contentAt = openAt + EXTERNAL_ANSWER_OPEN.length;
-        const closeAt = value.indexOf(EXTERNAL_ANSWER_CLOSE, contentAt);
-        if (closeAt < 0)
-            return value.slice(contentAt).trim();
-        sections.push(value.slice(contentAt, closeAt));
-        cursor = closeAt + EXTERNAL_ANSWER_CLOSE.length;
-    }
-    return (sections.length > 0 ? sections.join("") : value).trim();
+    return parseExternalAnswerText(value).text;
 }
 /**
  * 提取 marker 内容:有 marker 返回拼接内容(trim,空→null),无 marker 返回 null。
@@ -125,25 +230,6 @@ export function stripExternalAnswerMarkers(value) {
  * 本函数用于判定"agent 是否给出了频道直接回复"——必须能区分有无 marker。
  */
 export function extractExternalAnswer(value) {
-    const parts = [];
-    let found = false;
-    let rest = value;
-    for (;;) {
-        const open = rest.indexOf(EXTERNAL_ANSWER_OPEN);
-        if (open < 0)
-            break;
-        found = true;
-        const afterOpen = rest.slice(open + EXTERNAL_ANSWER_OPEN.length);
-        const close = afterOpen.indexOf(EXTERNAL_ANSWER_CLOSE);
-        if (close < 0) {
-            parts.push(afterOpen);
-            break;
-        }
-        parts.push(afterOpen.slice(0, close));
-        rest = afterOpen.slice(close + EXTERNAL_ANSWER_CLOSE.length);
-    }
-    if (!found)
-        return null;
-    const answer = parts.join("").trim();
-    return answer.length > 0 ? answer : null;
+    const parsed = parseExternalAnswerText(value);
+    return parsed.kind === "marked" && parsed.text ? parsed.text : null;
 }

package/dist/local-executor.js

@@ -37,6 +37,7 @@ import { formatRuntimeStartupError } from "./runtime-startup-error.js";
 import { machinePackageManagerEnv, packageManagerEnvFacts } from "./package-manager-env.js";
 import { sanitizeEnvVars } from "./runtime-env.js";
 import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, renderLocalMemoryResultInstructions, } from "./local-memory/runtime.js";
+import { renderPendingMemoryContext, searchPendingMemoryCandidates, } from "./local-memory/pending.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -253,7 +254,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let executionWorkspace = workspace;
     let localMemoryTelemetry = null;
     const inheritedEnv = { ...process.env };
-    const cloudReportPreparation = await prepareCloudReportExecution({ env: inheritedEnv, root: workspace.dir, executionId: input.executionId, agentHandle: input.handle });
+    const reportRoots = {
+        root: workspace.dir,
+        ...(input.launch.qaReportRoot === undefined ? {} : { qaReportRoot: input.launch.qaReportRoot }),
+    };
+    const cloudReportPreparation = await prepareCloudReportExecution({ env: inheritedEnv, ...reportRoots, executionId: input.executionId, agentHandle: input.handle });
     const { facts: cloudReportUpload, snapshot: reportSnapshot } = cloudReportPreparation;
     for (const key of Object.keys(inheritedEnv)) {
         if (key.startsWith("CREW_AGENT_MEMORY_") || ["CREW_CLOUD_PROVIDER", "CREW_OSS_UPLOAD_SCRIPT", "CREW_OSS_REPORT_UPLOAD"].includes(key))
@@ -381,6 +386,26 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
         const wakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
+        let pendingMemoryContext = "";
+        if (input.localMemoryV2Enabled === true) {
+            try {
+                const pendingCandidates = await searchPendingMemoryCandidates({
+                    agentDir: executionWorkspace.dir,
+                    query: wakePrompt,
+                    limit: 5,
+                });
+                pendingMemoryContext = renderPendingMemoryContext(pendingCandidates);
+            }
+            catch (error) {
+                dslog("local_memory.pending_recall_failed", "本地归档记忆召回失败", {
+                    level: "WARN",
+                    execution_id: input.executionId,
+                    agent_handle: input.handle,
+                    error_name: error instanceof Error ? error.name : "unknown",
+                    error_code: error?.code,
+                });
+            }
+        }
         memoryPruneTraceId = parseMemoryPruneTraceId(wakePrompt);
         if (input.localMemoryV2Enabled === true && memoryPruneTraceId !== null
             && isLocalMemoryV2Eligible({
@@ -392,14 +417,21 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             })) {
             localMemoryResultPath = makeLocalMemoryResultPath(executionWorkspace.runDir, input.executionId);
         }
-        const baseSystemPrompt = resolvePrompt(input.systemPrompt, promptContext);
+        const promptWithoutPending = resolvePrompt(input.systemPrompt, promptContext);
+        let baseSystemPrompt = `${promptWithoutPending}${pendingMemoryContext}`;
         const structuredMemoryInstructions = localMemoryResultPath === null
             ? null
             : renderLocalMemoryResultInstructions(localMemoryResultPath);
-        const structuredPromptFits = structuredMemoryInstructions === null
+        const fitsPromptBudget = (prompt) => structuredMemoryInstructions === null
             || input.maxSystemPromptBytes === undefined
-            || Buffer.byteLength(baseSystemPrompt, "utf8") + Buffer.byteLength(structuredMemoryInstructions, "utf8")
+            || Buffer.byteLength(prompt, "utf8") + Buffer.byteLength(structuredMemoryInstructions, "utf8")
                 <= input.maxSystemPromptBytes;
+        // The structured prune contract is mandatory for V2. Drop optional archived
+        // recall before dropping the daemon result file when the prompt budget is tight.
+        if (!fitsPromptBudget(baseSystemPrompt) && pendingMemoryContext !== "") {
+            baseSystemPrompt = promptWithoutPending;
+        }
+        const structuredPromptFits = fitsPromptBudget(baseSystemPrompt);
         if (!structuredPromptFits)
             localMemoryResultPath = null;
         const systemPrompt = localMemoryResultPath === null
@@ -990,7 +1022,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }
         const cloudReportResult = exitCode === 0
             ? await deliverCloudReports({
-                facts: cloudReportUpload, root: workspace.dir, before: reportSnapshot, finalText,
+                facts: cloudReportUpload, ...reportRoots, before: reportSnapshot, finalText,
                 externalAnswer: externalOutput.lastClosedBlock
                     ?? (finalText === null ? null : extractExternalAnswer(finalText)),
                 captureFinal: input.captureFinal, executionId: input.executionId, agentHandle: input.handle,

package/dist/local-memory/pending.js

@@ -2,6 +2,8 @@ import { randomUUID } from "node:crypto";
 import { lstat, mkdir, readdir, realpath, rename, rm, writeFile, readFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
+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(),
@@ -59,6 +61,44 @@ async function pendingDirectory(agentDir) {
     }
     return directory;
 }
+async function existingPendingDirectory(agentDir) {
+    const agentRoot = await realpath(agentDir);
+    const memoryRoot = resolve(agentRoot, ".crew", "memory");
+    let memoryStat;
+    try {
+        memoryStat = await lstat(memoryRoot);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    if (!memoryStat.isDirectory() || memoryStat.isSymbolicLink()) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    const resolvedMemoryRoot = await realpath(memoryRoot);
+    if (resolvedMemoryRoot !== memoryRoot || !within(agentRoot, resolvedMemoryRoot)) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    const directory = join(memoryRoot, "pending");
+    let stat;
+    try {
+        stat = await lstat(directory);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    const resolvedDirectory = await realpath(directory);
+    if (resolvedDirectory !== directory || !within(agentRoot, resolvedDirectory)) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    return directory;
+}
 async function assertRegularFile(path) {
     try {
         const stat = await lstat(path);
@@ -91,15 +131,40 @@ export async function persistPendingMemoryCandidate(input) {
     await atomicWrite(target, `${JSON.stringify(parsed.data, null, 2)}\n`);
     return target;
 }
+export async function removePendingMemoryCandidate(input) {
+    const directory = await existingPendingDirectory(input.agentDir);
+    if (directory === null)
+        return;
+    const target = join(directory, `${input.pendingId}.json`);
+    await assertRegularFile(target);
+    await rm(target, { force: true });
+}
 export async function readPendingMemoryCandidates(input) {
-    const directory = await pendingDirectory(input.agentDir);
+    const directory = await existingPendingDirectory(input.agentDir);
+    if (directory === null)
+        return [];
     const names = (await readdir(directory)).filter((name) => name.endsWith(".json")).sort();
+    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)
+            break;
         const path = join(directory, name);
         try {
             await assertRegularFile(path);
-            const parsed = PendingSchema.safeParse(JSON.parse(await readFile(path, "utf8")));
+            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);
         }
@@ -109,3 +174,72 @@ export async function readPendingMemoryCandidates(input) {
     }
     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)
+        .sort((left, right) => right.score - left.score
+        || priorityRank(left.candidate.candidate.priority) - priorityRank(right.candidate.candidate.priority)
+        || right.candidate.createdAt.localeCompare(left.candidate.createdAt)
+        || left.candidate.pendingId.localeCompare(right.candidate.pendingId))
+        .slice(0, limit)
+        .map((item) => item.candidate);
+}
+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)
+        return "";
+    const header = `\n\n## Archived memory candidates (daemon-managed)\n这些记忆已持久化，但尚未进入常驻热索引；只在当前请求相关时参考，必要时再由 memory-prune 提升。\n`;
+    let remaining = maxCodePoints - Array.from(header).length;
+    if (remaining <= 0)
+        return truncateCodePoints(header, maxCodePoints);
+    const sections = [];
+    for (const item of candidates) {
+        const change = item.candidate;
+        const prefix = `\n### ${change.title}\n`
+            + `- pending_file: .crew/memory/pending/${item.pendingId}.json\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 length = Array.from(section).length;
+        sections.push(section);
+        remaining -= length;
+    }
+    return `${header}${sections.join("")}`;
+}

package/dist/local-memory/runtime.js

@@ -57,9 +57,16 @@ ${resultPath}
 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 中等待后续治理。
+只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中；后续相关任务会按需召回，索引腾出空间后可自动提升。
 `;
 }
+/** Prevent ordinary V2 turns from racing the daemon-managed memory writer. */
+export function renderLocalMemoryV2WriteGuard() {
+    return `
+
+## V2 shared memory write safety
+本节覆盖前文关于普通任务直接更新共享记忆的例外规则。本 Agent 已启用结构化本地记忆 V2。普通任务不得直接编辑共享的 $CREW_HOME/MEMORY.md 或 $CREW_HOME/notes/ 文件；即使用户明确要求记住内容，也只把候选、用户授权和分类理由记录到本任务的 $CREW_TASK_LOG，留给任务结束后的 memory-prune 结构化收尾应用。只有 memory-prune 收尾提示明确要求写入 daemon 提供的 result 文件时，才按该协议提交候选。`;
+}
 export async function commitLocalMemoryResultAfterExit(input) {
     if (input.exitCode !== 0)
         return { status: "skipped" };