@nowcrew/daemon 0.6.87-beta.4 → 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/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`);
@@ -386,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({
@@ -417,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({

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",