@nowcrew/daemon 0.6.87 → 0.6.88-beta.1

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/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 };
+}

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

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

package/dist/local-memory-diagnostics.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
 import { isAbsolute, join, normalize, relative, resolve } from "node:path";
+import { parseArgs } from "node:util";
 import { capMemoryForInject, MEMORY_INJECT_CAP } from "./prompt.js";
 const INJECTION_MARKERS = [
     "## Injected MEMORY.md (bounded local context)\n",
@@ -172,10 +173,58 @@ function commandOperation(command) {
         ? "read"
         : null;
 }
+function crewMemoryReadAccess(command, paths) {
+    if (!/^\s*crew-memory(?:\s|$)/u.test(command))
+        return null;
+    const args = [];
+    let remaining = command.trim();
+    // Only complete literal arguments are supported; shell expansion and concatenated quoting are not inferred.
+    while (remaining !== "") {
+        const match = /^(?:"([^"\\$`]*)"|'([^']*)'|([^\s"'\\$`<>;|&()\[\]{}*?!#]+))(?=\s|$)\s*/u.exec(remaining);
+        if (match === null)
+            return null;
+        args.push(match[1] ?? match[2] ?? match[3]);
+        remaining = remaining.slice(match[0].length);
+    }
+    try {
+        const { values, positionals } = parseArgs({
+            args: args.slice(1),
+            allowPositionals: true,
+            options: {
+                file: { type: "string" }, query: { type: "string", short: "q" },
+                limit: { type: "string" }, offset: { type: "string" },
+                "after-line": { type: "string" }, "if-hash": { type: "string" },
+                json: { type: "boolean" }, help: { type: "boolean", short: "h" },
+            },
+        });
+        if (values.help || positionals.length !== 1)
+            return null;
+        const operation = positionals[0];
+        if (operation === "search") {
+            if (!values.query?.trim() || values.offset !== undefined)
+                return null;
+        }
+        else if (operation !== "read" || values.query !== undefined || values["after-line"] !== undefined) {
+            return null;
+        }
+        const file = values.file ?? "MEMORY.md";
+        if (file !== "MEMORY.md" && !/^notes\/[^/\\\u0000-\u001f\u007f]+\.md$/u.test(file))
+            return null;
+        const classified = classifyExplicitPath(resolve(paths.homeDir, file), paths);
+        return classified === null ? null : { ...classified, operation: "read" };
+    }
+    catch {
+        return null;
+    }
+}
 function commandAccesses(command, paths) {
     if (/[;|&\n]/.test(command))
         return [];
     const accesses = new Map();
+    const memoryRead = crewMemoryReadAccess(command, paths);
+    if (memoryRead !== null) {
+        accesses.set(`${memoryRead.target}:${memoryRead.relative_path ?? ""}:read`, memoryRead);
+    }
     const expanded = command
         .replaceAll("${CREW_HOME}", paths.homeDir)
         .replaceAll("$CREW_HOME", paths.homeDir)
@@ -243,26 +292,41 @@ export function createLocalMemoryAccessObserver(options) {
                 for (const block of blocks) {
                     if (block.type !== "tool_use" || typeof block.id !== "string" || typeof block.name !== "string")
                         continue;
+                    if (block.name === "Bash") {
+                        const input = block.input && typeof block.input === "object" && !Array.isArray(block.input)
+                            ? block.input
+                            : null;
+                        const accesses = typeof input?.command === "string" ? commandAccesses(input.command, paths) : [];
+                        if (accesses.length > 0)
+                            pending.set(block.id, { accesses, evidence: "shell_command" });
+                        continue;
+                    }
                     const operation = toolOperation(block.name);
                     const path = toolPath(block.input);
                     const classified = operation === null || path === null ? null : classifyExplicitPath(path, paths);
-                    if (operation !== null && classified !== null)
-                        pending.set(block.id, { operation, ...classified });
+                    if (operation !== null && classified !== null) {
+                        pending.set(block.id, {
+                            accesses: [{ operation, ...classified }],
+                            evidence: "structured_tool",
+                        });
+                    }
                 }
             }
             if (record.type === "user") {
                 for (const block of blocks) {
                     if (block.type !== "tool_result" || typeof block.tool_use_id !== "string")
                         continue;
-                    const access = pending.get(block.tool_use_id);
+                    const toolAccess = pending.get(block.tool_use_id);
                     pending.delete(block.tool_use_id);
-                    if (access === undefined)
+                    if (toolAccess === undefined)
                         continue;
-                    recordObservation(observations, counts, {
-                        ...access,
-                        outcome: block.is_error === true ? "failed" : "succeeded",
-                        evidence: "structured_tool",
-                    });
+                    for (const access of toolAccess.accesses) {
+                        recordObservation(observations, counts, {
+                            ...access,
+                            outcome: block.is_error === true ? "failed" : "succeeded",
+                            evidence: toolAccess.evidence,
+                        });
+                    }
                 }
             }
             if (record.type === "kimi.acp.tool_call" && typeof record.id === "string") {
@@ -277,15 +341,18 @@ export function createLocalMemoryAccessObserver(options) {
                     ? null
                     : classifyExplicitPath(path, paths);
                 if (fallbackOperation !== null && classified !== null) {
-                    pending.set(record.id, { operation: fallbackOperation, ...classified });
+                    pending.set(record.id, {
+                        accesses: [{ operation: fallbackOperation, ...classified }],
+                        evidence: "structured_tool",
+                    });
                 }
             }
             if (record.type === "kimi.acp.tool_result" && typeof record.id === "string") {
                 if (record.status !== "completed" && record.status !== "failed")
                     return observations;
-                const access = pending.get(record.id);
+                const toolAccess = pending.get(record.id);
                 pending.delete(record.id);
-                if (access !== undefined) {
+                for (const access of toolAccess?.accesses ?? []) {
                     recordObservation(observations, counts, {
                         ...access,
                         outcome: record.status === "failed" ? "failed" : "succeeded",

package/dist/prompt.js

@@ -67,10 +67,23 @@ export function capWorkLogForInject(workLog, cap = WORKLOG_INJECT_CAP) {
     const tail = workLog.slice(-WORKLOG_TAIL);
     return `${head}\n…(work-log 过长已截去中段,全文用 Read 读 $CREW_TASK_LOG)\n${tail}`;
 }
-export function capMemoryForInject(memory, cap = MEMORY_INJECT_CAP) {
-    return memory.length > cap
-        ? `${memory.slice(0, cap)}\n…(MEMORY.md 过长已截断,详情用 Read 读 $CREW_HOME/MEMORY.md;功能明细仅按索引中的 file 读取)`
-        : memory;
+export function capMemoryForInject(memory, cap = MEMORY_INJECT_CAP, maxBytes = Number.POSITIVE_INFINITY) {
+    if (memory.length <= cap && Buffer.byteLength(memory, "utf8") <= maxBytes)
+        return memory;
+    const notice = "[MEMORY.md preview truncated; use crew-memory search/read for more.]\n";
+    const noticeBytes = Buffer.byteLength(notice, "utf8");
+    if (notice.length > cap || noticeBytes > maxBytes)
+        return "";
+    let end = 0;
+    let bytes = noticeBytes;
+    for (const character of memory) {
+        const size = Buffer.byteLength(character, "utf8");
+        if (notice.length + end + character.length > cap || bytes + size > maxBytes)
+            break;
+        end += character.length;
+        bytes += size;
+    }
+    return notice + memory.slice(0, end);
 }
 export function buildSystemPrompt(ctx) {
     const product = ctx.productName ?? "nowwork";
@@ -99,7 +112,7 @@ export function buildSystemPrompt(ctx) {
     // scheduled 换成静默版,不出现任何"先确认/先回复"的措辞。
     const startupSequence = alwaysReport
         ? `## 启动序列(每轮汇报定时任务)
-1. 使用本提示词末尾已注入的 MEMORY.md 索引;命中相关条目时,再按索引中的 file 从 $CREW_HOME 读取明细。
+1. 参考本提示词中的 MEMORY.md 预览;需要历史约束或经验时检索完整索引,再按索引中的 file 从 $CREW_HOME 读取明细。
 2. 执行唤醒提示词里给出的定时指令。
 3. Return exactly one self-contained final report as your runtime final response.
 4. Do not call crew message send; the daemon delivers the final response.
@@ -107,14 +120,14 @@ export function buildSystemPrompt(ctx) {
 6. 只有存在需要后续跟进的具体事项时,才用 \`crew task create\` 创建任务。`
         : scheduled
             ? `## 启动序列(静默定时任务)
-1. 使用本提示词末尾已注入的 MEMORY.md 索引;命中相关条目时,再按索引中的 file 从 $CREW_HOME 读取明细。
+1. 参考本提示词中的 MEMORY.md 预览;需要历史约束或经验时检索完整索引,再按索引中的 file 从 $CREW_HOME 读取明细。
 2. 执行唤醒提示词里给出的定时指令。**默认零输出**:不判断"是否需要先确认/声明接手",本轮没有人在等你回复。
 3. 只有发现异常、需要人处理、或指令明确要求汇报时,才用 \`crew message send --send-draft\` 输出到频道(用法见上面"通信"一节)。
 4. 只有存在需要后续跟进的具体事项时,才用 \`crew task create\` 创建任务。
 5. 无异常时直接结束,不需要任何输出,不必读频道历史(除非指令要求)。`
             : `## 启动序列
 1. 若本轮来信可以直接回答,不要先发确认消息;处理完后只发一条完整回复。只有需要澄清、调用工具、协调他人或较长时间处理时,才先发有信息量的确认/进度消息。
-2. 使用本提示词末尾已注入的 MEMORY.md 索引;命中相关条目时,再按索引中的 file 从 $CREW_HOME 读取明细。
+2. 参考本提示词中的 MEMORY.md 预览;需要历史约束或经验时检索完整索引,再按索引中的 file 从 $CREW_HOME 读取明细。
 3. 若本轮只有"有未读"的 inbox notice、没有正文:notice 表示存在你尚未看到的消息(正文被暂时省略以免刷屏,不是没有内容)。是否读、何时读由你判断,可用 \`crew message check\` / \`crew message read\` 拉取。**绝不能仅凭一条 content-free notice 就断定"没有工作"**;若选择暂不读,要诚实当作 defer。
 4. 收到消息就处理,并用 \`crew message send\` 回复。
 5. **做完你负责的所有事再停。** 多步任务(调研/改码/测试)要全部完成、汇报结果后再停。新消息会在你存活期间自动送达,无需轮询等待。`;
@@ -329,13 +342,15 @@ ${interactiveTaskRules}${freshnessRule}${externalReplyRule}${collaborationEtique
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),按“常驻索引 + 功能明细 + 当前工作”分层:
-1. **MEMORY.md = 常驻索引 + 角色**:系统每次已把它(截断索引版)注入本提示词末尾。索引条目包含 \`file/type/scope/summary/triggers/priority/updated\`,其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`),先用这些字段判断当前问题是否相关;通常不必再读整份 MEMORY.md。
+1. **MEMORY.md = 常驻索引 + 角色**:提示词末尾可能只有它的有界预览,预算不足时也可能省略。预览未命中不等于没有记忆。索引条目包含 \`file/type/scope/summary/triggers/priority/updated\`,其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`);需要历史约束、经验或偏好时先检索完整索引,再按需分段读取。
 2. **notes/<topic>.md = 功能明细**:按用户偏好、项目规则、测试、调试、Git、事故复盘等主题拆分。优先读取与当前任务匹配的文件;\`notes/lessons.md\` 只保留未分类经验和历史兼容内容,不是所有新经验的默认目的地。普通任务默认只读不写,但当前用户明确要求时可以按最小范围更新;任务结束后的专门收尾执行仍按收尾指令复核。
    - 对旧版 MEMORY.md,如果条目没有完整结构化字段但明确指向 \`notes/<file>.md\`,把它视为 legacy 索引;仍需结合条目标题/链接和当前请求判断相关性,不要因为缺少 summary/triggers 就假定正文已注入。
 3. **本任务 work-log = \`$CREW_TASK_LOG\`**:每任务一份(别的运行不会碰),记当前阶段/下一步/卡点/关键结论。系统已把它的当前内容注入末尾让你续上;有进展就更新它——这是你**唯一**该在任务中持续写的记忆文件。**work-log 是现状快照,不是流水账**:保持 ≤100 行,更新时重写全文替换过时内容,不要无限追加(过长会被注入截断)。
 
 **按需读取规则(提示词引导,不是 Daemon 自动召回保证)**:
-- 当前请求命中 MEMORY.md 某条目的 \`summary\` 或 \`triggers\`,或用户明确询问历史经验/偏好时,在最终回答或执行动作前用 \`Read $CREW_HOME/<file>\` 读取对应明细;不要再次拼接 \`notes/\`。
+- 需要历史约束、经验或偏好时,在最终回答或执行动作前先用只读命令 \`crew-memory search --query '关键词' [--after-line N]\` 搜索完整 \`$CREW_HOME/MEMORY.md\`;默认返回 JSON,有后续结果时按返回游标继续,不要把预览中未命中当成全文无结果。
+- 用 \`crew-memory read [--file MEMORY.md|notes/xxx.md] [--offset N] [--limit N]\` 读取命中范围,再按索引中的 file 从 $CREW_HOME 读取明细;默认返回 JSON。以当前有效索引及其指向的正文为依据,不自动读取 pending,也不把未决或已替代片段当成有效记忆。
+- 旧 daemon 没有 \`crew-memory\` 时,回退到 runtime 原生文件搜索和分段 Read:先搜索完整 \`$CREW_HOME/MEMORY.md\`,再用 \`Read $CREW_HOME/<file>\` 读取命中范围;不要再次拼接 \`notes/\`。工具提示截断或返回下一页时继续分页,不要一次读取整份大文件。
 - 未命中时不要为了“保险”读取全部 notes;只读取能直接影响当前任务的文件。MEMORY.md 注入的是索引,不会自动让 note 正文可用。
 
 **沉淀与瘦身由系统触发,不要平时自行扩展范围**:任务被改为 done/closed 时,系统会单独唤醒你收尾——那时按功能分类把可复用经验提炼进合适的 \`notes/<topic>.md\`,更新 MEMORY.md 索引。普通执行已经按用户明确要求写入时,收尾先检查、后修改,只在明确缺漏时做最小必要修正,不得重复追加或只为优化措辞而改写。最终结论必须且只能归类为:无变化、已修正、冲突、失败;无变化或已修正时必须满足对应后置条件并清空 work-log,冲突或失败时保留 work-log,任一记忆写入失败则保留 work-log。不要默认全部写入 \`notes/lessons.md\`。默认不要改 MEMORY.md/notes,但不能覆盖当前用户明确授权的最小范围更新。

package/dist/workspace.js

@@ -11,6 +11,8 @@
 import { mkdir, writeFile, readFile, chmod, access, lstat } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
 import { dslog } from "./slog.js";
 /** 文件系统安全的 taskKey:仅留 [\w.-],其余转 _,截断,避免路径穿越/超长。 */
 export function safeKey(key) {
@@ -96,6 +98,19 @@ export async function prepareWorkspace(input) {
     await chmod(wrapper, 0o755);
     // win32 侧 wrapper:cmd/PowerShell 不认 shebang 脚本,并存 crew.cmd(unix 下无害不会被命中)
     await writeFile(join(crewDir, "crew.cmd"), `@echo off\r\nnode ${JSON.stringify(input.cliPath)} %*\r\n`, "utf8");
+    if (!input.skipLocalMemory) {
+        const sourceMode = import.meta.url.endsWith(".ts");
+        const reader = fileURLToPath(new URL(`./local-memory/read-cli.${sourceMode ? "ts" : "js"}`, import.meta.url));
+        const readerArgs = sourceMode
+            ? ["--import", pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm")).href, reader]
+            : [reader];
+        const readerWrapper = join(crewDir, "crew-memory");
+        const posixArgs = readerArgs.map((arg) => `'${arg.replace(/'/gu, "'\\''")}'`).join(" ");
+        const windowsArgs = readerArgs.map((arg) => `"${arg.replace(/%/gu, "%%")}"`).join(" ");
+        await writeFile(readerWrapper, `#!/bin/sh\nexec node ${posixArgs} "$@"\n`, "utf8");
+        await chmod(readerWrapper, 0o755);
+        await writeFile(join(crewDir, "crew-memory.cmd"), `@echo off\r\nnode ${windowsArgs} %*\r\n`, "utf8");
+    }
     // 每个 agent 独立的 XDG 配置根:隔离第三方 CLI 凭证,避免 agent 之间互相串号
     const homeDir = join(dir, ".home");
     await mkdir(join(homeDir, ".config"), { recursive: true });

package/package.json

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