@nowcrew/daemon 0.6.87-beta.3 → 0.6.87-beta.5

package/README.md

@@ -418,6 +418,28 @@ Local policy can reduce server-requested access and limits; it cannot grant more
 Provider credentials and configured environment are prepared locally and never carried in execution
 control frames.
 
+## 完整本地记忆读取
+
+运行时注入的 `MEMORY.md` 是有界预览，未命中不代表完整文件没有相关记忆。
+普通 Agent 工作区会在现有 PATH 目录中提供只读 `crew-memory` 工具，无需 Server 凭证：
+
+```bash
+crew-memory search --query '提交前检查'
+crew-memory search --query '提交前检查' --after-line 120
+crew-memory read --offset 2400 --limit 2000
+crew-memory read --file notes/testing.md --offset 0 --limit 2000
+```
+
+命令默认返回 JSON。搜索遍历完整指定文件，返回 `line`、`offset`、命中摘要和
+`nextAfterLine`；读取按 Unicode 字符偏移分页，使用 `nextOffset` 继续直到 `eof=true`。
+后续页可传 `--if-hash <上一页的sha256>`，文件变化时明确停止，不混读不同版本。
+每页 JSON 有 12 KiB 上限，输入文件超过 32 MiB 时明确报错，不将未完成搜索伪装为零命中。
+
+工具仅支持 `MEMORY.md` 和 `notes/` 下明确指定的 Markdown 文件，不遍历 pending，
+不写入或迁移记忆。搜索结果是原始资料定位，读取明细前仍需确认当前有效索引和正文片段。
+这些修改不改变现有 V2 写入上限、候选状态或归档策略，也不提供自动语义召回保证。
+工具随 daemon 包发布；旧 daemon 没有该入口时，Agent 使用原生文件搜索与分段读取回退。
+
 ## Optional TencentDB Agent Memory Bridge
 
 Execution protocol v1 can opt NowWork Agents into the private TencentDB Agent Memory Panel.

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

@@ -834,9 +834,12 @@ export async function runExecution(config, input, dependencies) {
             ...(selfTraining ? { isolateLocalMemory: true } : {}),
             collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex",
         });
-        const boundedSystemPrompt = (context) => appendAgentMemoryContext(typeof systemPromptWithLocalFacts === "string"
-            ? systemPromptWithLocalFacts
-            : systemPromptWithLocalFacts(context), recalledMemory, baseSystemPromptBudget);
+        const boundedSystemPrompt = (context) => {
+            const base = typeof systemPromptWithLocalFacts === "string"
+                ? systemPromptWithLocalFacts
+                : systemPromptWithLocalFacts(context);
+            return appendAgentMemoryContext(base, recalledMemory, Math.max(Buffer.byteLength(base, "utf8"), baseSystemPromptBudget - (context.reservedPromptBytes ?? 0)));
+        };
         const localInput = {
             executionId: spec.executionId,
             handle: spec.agent.handle,

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-execution-prompt.js

@@ -34,45 +34,39 @@ export function truncateUtf8(value, maxBytes) {
     }
     return value.slice(0, end);
 }
-function takeCompletePromptSections(sections, maxBytes) {
-    return sections.reduce((state, section) => {
-        if (!state.full)
-            return state;
-        const sectionBytes = Buffer.byteLength(section, "utf8");
-        if (state.bytes + sectionBytes > maxBytes)
-            return { ...state, full: false };
-        return { value: `${state.value}${section}`, bytes: state.bytes + sectionBytes, full: true };
-    }, { value: "", bytes: 0, full: true }).value;
-}
 /** v1 server instructions opt in to daemon-owned paths and bounded local workspace context. */
 export function withLocalExecutionFacts(serverPrompt, maxBytes, options = {}) {
-    return ({ workspace, resuming, projectContext, trainingProjectContext }) => {
-        const memory = options.isolateLocalMemory ? "" : capMemoryForInject(workspace.memory);
+    return ({ workspace, resuming, projectContext, trainingProjectContext, reservedPromptBytes = 0 }) => {
         const workLog = resuming ? "" : capWorkLogForInject(workspace.workLog);
         const collaborationPrompt = options.collaborationTools === true ? buildCollaborationToolsPrompt() : "";
         const mandatoryWorkspacePrompt = `${buildRuntimeWorkspacePrompt(projectContext)}${buildTrainingGitProjectPrompt(trainingProjectContext)}`;
         const crewHome = options.isolateLocalMemory ? workspace.runDir : workspace.dir;
-        const localFactSections = [`\n\n## Local execution facts
+        const localFacts = `\n\n## Local execution facts
 - $CREW_HOME: ${crewHome}
-- $CREW_TASK_LOG: ${workspace.workLogPath}`,
-            ...(memory ? [`\n\n## Injected MEMORY.md (bounded local context)\n${memory}`] : []),
-            ...(workLog ? [`\n\n## Injected work-log (bounded local context)\n${workLog}`] : []),
-        ];
+- $CREW_TASK_LOG: ${workspace.workLogPath}`;
         const serverPromptBytes = Buffer.byteLength(serverPrompt, "utf8");
         const collaborationBytes = Buffer.byteLength(collaborationPrompt, "utf8");
         const mandatoryBytes = Buffer.byteLength(mandatoryWorkspacePrompt, "utf8");
         const requiredBytes = serverPromptBytes + collaborationBytes + mandatoryBytes;
-        // 必需预算与 projectContext 无关:协作段落永远参与;无协作时与旧实现逐字节等价。
+        // 先保留全部必需内容,再按实际剩余字节一次性构造预览。
         if (collaborationPrompt !== "" && requiredBytes > maxBytes) {
             throw new Error("collaboration_tools_prompt_budget_exceeded");
         }
-        if (mandatoryWorkspacePrompt !== "") {
-            if (requiredBytes > maxBytes)
-                throw new Error("project_workspace_prompt_budget_exceeded");
-            const optionalFacts = takeCompletePromptSections(localFactSections, maxBytes - requiredBytes);
-            return `${serverPrompt}${collaborationPrompt}${optionalFacts}${mandatoryWorkspacePrompt}`;
+        if (mandatoryWorkspacePrompt !== "" && requiredBytes > maxBytes) {
+            throw new Error("project_workspace_prompt_budget_exceeded");
         }
-        const remaining = maxBytes - requiredBytes;
-        return `${serverPrompt}${collaborationPrompt}${truncateUtf8(localFactSections.join(""), remaining)}`;
+        const remaining = maxBytes - requiredBytes - Math.max(0, reservedPromptBytes);
+        const factsBytes = Buffer.byteLength(localFacts, "utf8");
+        if (factsBytes > remaining)
+            return `${serverPrompt}${collaborationPrompt}${mandatoryWorkspacePrompt}`;
+        const memoryHeading = "\n\n## Injected MEMORY.md (bounded local context)\n";
+        const memory = options.isolateLocalMemory ? "" : capMemoryForInject(workspace.memory, undefined, remaining - factsBytes - Buffer.byteLength(memoryHeading, "utf8"));
+        const memorySection = memory === "" ? "" : memoryHeading + memory;
+        const workLogSection = workLog === "" ? "" : `\n\n## Injected work-log (bounded local context)\n${workLog}`;
+        const workLogBudget = remaining - factsBytes - Buffer.byteLength(memorySection, "utf8");
+        const boundedWorkLog = mandatoryWorkspacePrompt === ""
+            ? truncateUtf8(workLogSection, workLogBudget)
+            : Buffer.byteLength(workLogSection, "utf8") <= workLogBudget ? workLogSection : "";
+        return `${serverPrompt}${collaborationPrompt}${localFacts}${memorySection}${boundedWorkLog}${mandatoryWorkspacePrompt}`;
     };
 }

package/dist/local-executor.js

@@ -36,8 +36,8 @@ import { CodexStartupStageParser } from "./codex-startup-stage.js";
 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";
+import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
+import { prepareLocalMemoryPrompt } from "./local-memory/prompt.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -254,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))
@@ -382,26 +386,6 @@ 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({
@@ -413,26 +397,14 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             })) {
             localMemoryResultPath = makeLocalMemoryResultPath(executionWorkspace.runDir, input.executionId);
         }
-        const promptWithoutPending = resolvePrompt(input.systemPrompt, promptContext);
-        let baseSystemPrompt = `${promptWithoutPending}${pendingMemoryContext}`;
-        const structuredMemoryInstructions = localMemoryResultPath === null
-            ? null
-            : renderLocalMemoryResultInstructions(localMemoryResultPath);
-        const fitsPromptBudget = (prompt) => structuredMemoryInstructions === null
-            || input.maxSystemPromptBytes === undefined
-            || 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
-            ? baseSystemPrompt
-            : `${baseSystemPrompt}${structuredMemoryInstructions ?? ""}`;
+        const memoryPrompt = await prepareLocalMemoryPrompt({
+            agentDir: executionWorkspace.dir, executionId: input.executionId, agentHandle: input.handle,
+            enabled: input.localMemoryV2Enabled === true, query: wakePrompt,
+            resultPath: localMemoryResultPath, maxBytes: input.maxSystemPromptBytes,
+            renderBase: (reservedPromptBytes) => resolvePrompt(input.systemPrompt, { ...promptContext, reservedPromptBytes }),
+        });
+        localMemoryResultPath = memoryPrompt.resultPath;
+        const systemPrompt = memoryPrompt.systemPrompt;
         if (!isolatedMaintenance)
             try {
                 localMemoryTelemetry = createLocalMemoryTelemetry({
@@ -1018,7 +990,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/prompt.js

@@ -0,0 +1,37 @@
+import { dslog } from "../slog.js";
+import { renderPendingMemoryContext, searchPendingMemoryCandidates } from "./pending.js";
+import { renderLocalMemoryResultInstructions } from "./runtime.js";
+export async function prepareLocalMemoryPrompt(input) {
+    let pending = "";
+    if (input.enabled) {
+        try {
+            pending = renderPendingMemoryContext(await searchPendingMemoryCandidates({
+                agentDir: input.agentDir, query: input.query, limit: 5,
+            }));
+        }
+        catch (error) {
+            dslog("local_memory.pending_recall_failed", "本地归档记忆召回失败", {
+                level: "WARN",
+                execution_id: input.executionId,
+                agent_handle: input.agentHandle,
+                error_name: error instanceof Error ? error.name : "unknown",
+                error_code: error?.code,
+            });
+        }
+    }
+    const original = input.renderBase(0);
+    const structured = input.resultPath === null ? "" : renderLocalMemoryResultInstructions(input.resultPath);
+    const fits = (prompt) => input.maxBytes === undefined || Buffer.byteLength(prompt, "utf8") <= input.maxBytes;
+    const render = (suffix) => (suffix === "" ? original : input.renderBase(Buffer.byteLength(suffix, "utf8"))) + suffix;
+    // 后缀先占预算，可选预览重建；结构化契约优先于 pending，不能被预览挤掉。
+    const complete = render(pending + structured);
+    if (fits(complete))
+        return { systemPrompt: complete, resultPath: input.resultPath };
+    if (pending !== "") {
+        const withoutPending = render(structured);
+        if (fits(withoutPending))
+            return { systemPrompt: withoutPending, resultPath: input.resultPath };
+    }
+    // 强制基础指令与契约本身仍无法共存时，保留既有非结构化兼容回退，不裁基础指令。
+    return { systemPrompt: original, resultPath: null };
+}