@nowcrew/daemon 0.5.44 → 0.5.46

package/dist/list-models.js

@@ -1,6 +1,7 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { isWin } from "./platform.js";
+import { listHermesModels } from "./runtimes/hermes-models.js";
 const execFileRaw = promisify(execFile);
 const MODEL_PROBE_TIMEOUT_MS = 8_000;
 const MODEL_PROBE_MAX_BUFFER_BYTES = 1024 * 1024;
@@ -11,14 +12,16 @@ const execFileP = (bin, args) => execFileRaw(bin, args, {
     killSignal: "SIGKILL",
     maxBuffer: MODEL_PROBE_MAX_BUFFER_BYTES,
 });
-export async function listRuntimeModels(runtime) {
+export async function listRuntimeModels(runtime, options = {}) {
     switch (runtime) {
         case "codex":
             return parseCodexModels((await execFileP("codex", ["debug", "models"])).stdout);
         case "cursor":
             return parseCursorModels((await execFileP("cursor-agent", ["--list-models"])).stdout);
+        case "hermes":
+            return listHermesModels(options);
         case "opencode":
-            return parseOpencodeModels((await execFileP("opencode", ["models"])).stdout);
+            return listOpencodeModels();
         case "pi":
             return parsePiModels((await execFileP("pi", ["--list-models"])).stdout);
         default:
@@ -76,12 +79,103 @@ function parseCursorModels(stdout) {
         return { id: id.trim(), label: (label || id).trim(), ...(index === 0 ? { default: true } : {}) };
     });
 }
-function parseOpencodeModels(stdout) {
-    return stdout
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0 && !line.startsWith("warning:"))
-        .map((line, index) => ({ id: line, label: line, ...(index === 0 ? { default: true } : {}) }));
+async function outputEvenOnFailure(bin, args) {
+    try {
+        return (await execFileP(bin, args)).stdout;
+    }
+    catch (error) {
+        const stdout = error.stdout;
+        if (typeof stdout === "string")
+            return stdout;
+        if (Buffer.isBuffer(stdout))
+            return stdout.toString("utf8");
+        return "";
+    }
+}
+async function listOpencodeModels() {
+    const verbose = parseOpencodeModels(await outputEvenOnFailure("opencode", ["models", "--verbose"]));
+    if (verbose.length > 0)
+        return verbose;
+    return parseOpencodeModels(await outputEvenOnFailure("opencode", ["models"]));
+}
+const VARIANT_ORDER = new Map([
+    ["none", 0], ["minimal", 1], ["low", 2], ["medium", 3],
+    ["high", 4], ["xhigh", 5], ["max", 6],
+]);
+function modelIdLine(line) {
+    const id = line.trim().split(/\s+/, 1)[0] ?? "";
+    if (!id.includes("/") || /^["{[]/.test(id) || id === id.toUpperCase())
+        return null;
+    return id;
+}
+function collectJson(lines, start) {
+    let raw = "";
+    for (let index = start; index < lines.length; index += 1) {
+        if (index > start && modelIdLine(lines[index]) !== null)
+            return { raw, next: index };
+        raw += `${raw ? "\n" : ""}${lines[index]}`;
+        try {
+            JSON.parse(raw);
+            return { raw, next: index + 1 };
+        }
+        catch {
+            // A pretty-printed block is complete only when JSON.parse succeeds.
+        }
+    }
+    return { raw, next: lines.length };
+}
+function parseVariants(raw) {
+    try {
+        const meta = JSON.parse(raw);
+        const variants = meta.variants ?? {};
+        const looksReasoning = meta.reasoning === true || Object.entries(variants).some(([name, value]) => VARIANT_ORDER.has(name) || typeof value.reasoningEffort === "string" || value.thinking != null);
+        if (!looksReasoning)
+            return [];
+        return Object.entries(variants)
+            .filter(([name, value]) => name.length > 0 && value.disabled !== true)
+            .map(([name]) => name)
+            .sort((left, right) => {
+            const leftOrder = VARIANT_ORDER.get(left);
+            const rightOrder = VARIANT_ORDER.get(right);
+            if (leftOrder !== undefined && rightOrder !== undefined)
+                return leftOrder - rightOrder;
+            if (leftOrder !== undefined)
+                return -1;
+            if (rightOrder !== undefined)
+                return 1;
+            return left.localeCompare(right);
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export function parseOpencodeModels(stdout) {
+    const lines = stdout.split(/\r?\n/);
+    const models = [];
+    const byId = new Map();
+    for (let index = 0; index < lines.length; index += 1) {
+        const id = modelIdLine(lines[index]);
+        if (id === null)
+            continue;
+        let modelIndex = byId.get(id);
+        if (modelIndex === undefined) {
+            modelIndex = models.length;
+            byId.set(id, modelIndex);
+            models.push({ id, label: id, ...(modelIndex === 0 ? { default: true } : {}) });
+        }
+        let next = index + 1;
+        while (next < lines.length && lines[next].trim() === "")
+            next += 1;
+        if (next >= lines.length || !lines[next].trim().startsWith("{"))
+            continue;
+        const block = collectJson(lines, next);
+        const reasoning = parseVariants(block.raw);
+        if (reasoning.length > 0)
+            models[modelIndex] = { ...models[modelIndex], reasoning };
+        index = block.next - 1;
+    }
+    return models;
 }
 function parsePiModels(stdout) {
     return stdout

package/dist/local-executor.js

@@ -19,6 +19,7 @@ import { awaitWithCancellation, RuntimeCancelledError, } from "./runtime-cancell
 import { isRuntimeReadyEvent, } from "./runtime-startup-gate.js";
 import { dslog } from "./slog.js";
 import { evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
+import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 function memoryPruneSnapshotFields(snapshot) {
     const fields = {};
     for (const [label, fact] of Object.entries(snapshot)) {
@@ -79,6 +80,7 @@ export function withLocalExecutionFacts(serverPrompt, maxBytes) {
 }
 const STDERR_TAIL_CAP = 2_000;
 const MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS = 2_000;
+const LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS = 250;
 const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const RESERVED_ENV = new Set([
     "PATH",
@@ -112,15 +114,17 @@ export function awaitExit(child) {
     });
 }
 export function exitActivity(runtime, exitCode, stderrTail) {
-    if ((runtime === "codex" || runtime === "kimi" || exitCode === -1) && exitCode !== 0) {
+    if ((runtime === "codex" || runtime === "kimi" || runtime === "hermes"
+        || runtime === "opencode" || exitCode === -1) && exitCode !== 0) {
         return {
             kind: "error",
             label: "运行出错",
             detail: `${runtime} exited with code ${exitCode}${stderrTail ? `: ${stderrTail}` : ""}`,
         };
     }
-    if (runtime === "kimi" && exitCode === 0)
+    if ((runtime === "kimi" || runtime === "hermes" || runtime === "opencode") && exitCode === 0) {
         return { kind: "done", label: "本轮结束" };
+    }
     return null;
 }
 function wrapChild(child) {
@@ -222,16 +226,27 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             : "high"
         : runtime.reasoning;
     const providerFp = providerFingerprint(runtime.name, providerConfig);
-    const workspace = await awaitWithCancellation(prepareWorkspace({
-        agentsRoot: input.launch.agentsRoot,
-        handle: input.handle,
-        cliPath: input.launch.cliPath,
-        executionId: input.executionId,
-        ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
-        ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-        ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
-        ...(input.launch.description ? { description: input.launch.description } : {}),
-    }), dependencies.cancellation);
+    let workspace;
+    try {
+        workspace = await awaitWithCancellation(prepareWorkspace({
+            agentsRoot: input.launch.agentsRoot,
+            handle: input.handle,
+            cliPath: input.launch.cliPath,
+            executionId: input.executionId,
+            ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
+            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+            ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
+            ...(input.launch.description ? { description: input.launch.description } : {}),
+        }), dependencies.cancellation);
+    }
+    catch (error) {
+        logLocalMemoryContextPrepareFailure({
+            executionId: input.executionId,
+            agentHandle: input.handle,
+            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+        }, "workspace_prepare", error);
+        throw error;
+    }
     let materialized = null;
     let knownAttachmentDirectory = null;
     let startupReservation = null;
@@ -242,6 +257,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let memoryPruneBeforeSnapshot = null;
     let memoryPruneSharedWriteKey = null;
     let executionWorkspace = workspace;
+    let localMemoryTelemetry = null;
     try {
         if (isDeepSeekCodex && !providerConfig.providerApiKey) {
             throw new Error("DeepSeek API key is not configured for this Agent");
@@ -345,6 +361,29 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
         const wakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
         memoryPruneTraceId = parseMemoryPruneTraceId(wakePrompt);
+        try {
+            localMemoryTelemetry = createLocalMemoryTelemetry({
+                executionId: input.executionId,
+                agentHandle: input.handle,
+                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+                runtime: runtime.name,
+                stableProtocolRuntime: dependencies.launchRuntime !== undefined,
+                agentDir: executionWorkspace.dir,
+                runDir: executionWorkspace.runDir,
+                isMemoryPrune: memoryPruneTraceId !== null,
+                diagnosticsTimeoutMs: dependencies.localMemoryDiagnosticsTimeoutMs
+                    ?? LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS,
+            });
+            await localMemoryTelemetry.captureBefore();
+        }
+        catch (error) {
+            localMemoryTelemetry = null;
+            logLocalMemoryDiagnosticsFailure({
+                executionId: input.executionId,
+                agentHandle: input.handle,
+                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+            }, "initialize", error);
+        }
         if (memoryPruneTraceId !== null) {
             memoryPruneSharedWriteKey = JSON.stringify([input.launch.agentsRoot, input.handle]);
             const activePruneCount = (activeMemoryPrunes.get(memoryPruneSharedWriteKey) ?? 0) + 1;
@@ -378,7 +417,25 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             }
         }
         memoryPruneFailurePhase = "prompt_write";
-        await awaitWithCancellation(writeFile(workspace.systemPromptPath, systemPrompt, "utf8"), dependencies.cancellation);
+        try {
+            await awaitWithCancellation(writeFile(workspace.systemPromptPath, systemPrompt, "utf8"), dependencies.cancellation);
+        }
+        catch (error) {
+            logLocalMemoryContextPrepareFailure({
+                executionId: input.executionId,
+                agentHandle: input.handle,
+                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+            }, "system_prompt_write", error);
+            throw error;
+        }
+        localMemoryTelemetry?.contextPrepared({
+            systemPrompt,
+            memory: executionWorkspace.memory,
+            resumed: resuming,
+            ...(executionWorkspace.memorySeedCreated === undefined
+                ? {}
+                : { memorySeedCreated: executionWorkspace.memorySeedCreated }),
+        });
         memoryPruneFailurePhase = "runtime_prepare";
         const inheritedEnv = { ...process.env };
         for (const key of Object.keys(inheritedEnv)) {
@@ -454,6 +511,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const child = input.projectSkills !== undefined && dependencies.projectSkills !== undefined
             ? await dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.projectSkills, () => launchRuntime(launchRequest))
             : await launchRuntime(launchRequest);
+        localMemoryTelemetry?.markRuntimeStarted();
         memoryPruneFailurePhase = "runtime_execution";
         if (child.cancel !== undefined) {
             dependencies.cancellation?.register(child.cancel);
@@ -479,6 +537,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             if (runtimeReady)
                 return;
             runtimeReady = true;
+            localMemoryTelemetry?.markRuntimeReady();
             startupReservation?.release();
             dslog("runtime.start_ready", "runtime 已完成初始化", {
                 execution_id: input.executionId,
@@ -493,6 +552,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             const event = parseLine(line);
             if (!event)
                 return;
+            localMemoryTelemetry?.observe(event);
             if (isRuntimeReadyEvent(runtime.name, event))
                 markRuntimeReady();
             const meta = extractRunMeta(event);
@@ -511,7 +571,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             const extracted = extractFinalText(event);
             if (extracted) {
                 const incremental = typeof event === "object" && event !== null
-                    && "type" in event && event.type === "kimi.acp.text_delta";
+                    && "type" in event && (event.type === "kimi.acp.text_delta"
+                    || event.type === "hermes.acp.text_delta" || event.type === "opencode.text_delta");
                 finalText = incremental ? `${finalText ?? ""}${extracted}` : extracted;
             }
             for (const text of decodeExternalOutputEvent(runtime.name, event, externalOutput)) {
@@ -569,6 +630,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             throw error;
         }
         const { exitCode, spawnError, terminationSignal } = runtimeExit;
+        localMemoryTelemetry?.markRuntimeExited(exitCode);
         memoryPruneRuntimeExitCode = exitCode;
         const errorTail = [
             stderrTail.trim(),
@@ -602,6 +664,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             }
         }
         memoryPruneExecutorCompleted = true;
+        localMemoryTelemetry?.markExecutorCompleted();
         return {
             workspaceRunDir: executionWorkspace.runDir,
             exitCode,
@@ -624,6 +687,16 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     }
     finally {
         startupReservation?.release();
+        try {
+            await localMemoryTelemetry?.finish();
+        }
+        catch (error) {
+            logLocalMemoryDiagnosticsFailure({
+                executionId: input.executionId,
+                agentHandle: input.handle,
+                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+            }, "finish", error);
+        }
         if (memoryPruneTraceId !== null) {
             try {
                 const snapshot = await inspectMemoryPruneFilesWithinDeadline(executionWorkspace.dir, executionWorkspace.runDir, executionWorkspace.workLogPath, dependencies.memoryPruneDiagnosticsTimeoutMs

package/dist/local-memory-diagnostics.js

@@ -0,0 +1,336 @@
+import { createHash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import { isAbsolute, join, normalize, resolve } from "node:path";
+import { capMemoryForInject, MEMORY_INJECT_CAP } from "./prompt.js";
+const INJECTION_MARKERS = [
+    "## Injected MEMORY.md (bounded local context)\n",
+    "## [注入] 你的 MEMORY.md(索引,只读参考)\n",
+];
+const LOCAL_MEMORY_HASH_CAP_BYTES = 10 * 1024 * 1024;
+function errorCode(error) {
+    const code = error?.code;
+    return typeof code === "string" ? code : error instanceof Error ? error.name : "unknown";
+}
+async function inspectFile(path, signal) {
+    let metadata;
+    try {
+        metadata = await stat(path);
+    }
+    catch (error) {
+        const code = errorCode(error);
+        return code === "ENOENT" ? { exists: false } : { exists: false, error_code: code };
+    }
+    const base = { exists: true, size_bytes: metadata.size, mtime_ms: metadata.mtimeMs };
+    if (!metadata.isFile())
+        return { ...base, hash_skipped_reason: "not_regular_file" };
+    if (metadata.size > LOCAL_MEMORY_HASH_CAP_BYTES) {
+        return { ...base, hash_skipped_reason: "too_large" };
+    }
+    try {
+        const content = await readFile(path, { encoding: "utf8", signal });
+        const facts = localMemoryContentFacts(content);
+        if (facts.scan_skipped_reason !== undefined) {
+            return { ...base, hash_skipped_reason: facts.scan_skipped_reason };
+        }
+        return { ...base, ...facts };
+    }
+    catch (error) {
+        return { ...base, error_code: errorCode(error) };
+    }
+}
+export async function inspectLocalMemoryFilesWithinDeadline(homeDir, timeoutMs) {
+    const controller = new AbortController();
+    let timer;
+    const inspection = Promise.all([
+        inspectFile(join(homeDir, "MEMORY.md"), controller.signal),
+        inspectFile(join(homeDir, "notes", "lessons.md"), controller.signal),
+    ]).then(([memory, lessons]) => ({ memory, lessons }));
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            controller.abort();
+            reject(Object.assign(new Error("local memory diagnostics timed out"), {
+                code: "diagnostics_timeout",
+            }));
+        }, Math.max(1, timeoutMs));
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([inspection, timeout]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+export function localMemoryContentFacts(content, maxScanBytes = LOCAL_MEMORY_HASH_CAP_BYTES) {
+    const sizeBytes = Buffer.byteLength(content, "utf8");
+    if (sizeBytes > Math.max(0, maxScanBytes)) {
+        return { size_bytes: sizeBytes, scan_skipped_reason: "too_large" };
+    }
+    return {
+        size_bytes: sizeBytes,
+        sha256: createHash("sha256").update(content).digest("hex"),
+        nonblank: content.trim().length > 0,
+        markdown_heading_count: content.split(/\r?\n/).filter((line) => /^#{1,6}\s+\S/.test(line)).length,
+        lessons_reference_count: content.match(/\bnotes[\\/]lessons\.md\b/gi)?.length ?? 0,
+    };
+}
+export function analyzeLocalMemoryInjection(systemPrompt, sourceMemory) {
+    const sourceBytes = Buffer.byteLength(sourceMemory, "utf8");
+    if (sourceMemory.length === 0) {
+        return { state: "empty_source", source_bytes: 0, bounded_bytes: 0, injected_bytes: 0 };
+    }
+    const bounded = capMemoryForInject(sourceMemory);
+    const marker = INJECTION_MARKERS.find((candidate) => systemPrompt.includes(candidate));
+    if (marker === undefined) {
+        return {
+            state: "omitted",
+            source_bytes: sourceBytes,
+            bounded_bytes: Buffer.byteLength(bounded, "utf8"),
+            injected_bytes: 0,
+        };
+    }
+    const markerStart = systemPrompt.indexOf(marker) + marker.length;
+    const sectionTail = systemPrompt.slice(markerStart);
+    const nextSection = sectionTail.search(/\n\n## (?:Injected work-log|\[注入\] 本任务 work-log)/);
+    const injected = nextSection < 0 ? sectionTail : sectionTail.slice(0, nextSection);
+    const fullyInjected = injected.startsWith(bounded);
+    return {
+        state: fullyInjected
+            ? sourceMemory.length > MEMORY_INJECT_CAP ? "cap_truncated" : "full"
+            : "prompt_budget_truncated",
+        source_bytes: sourceBytes,
+        bounded_bytes: Buffer.byteLength(bounded, "utf8"),
+        injected_bytes: Buffer.byteLength(injected, "utf8"),
+    };
+}
+export function localMemoryFileChanged(before, after) {
+    if (before.exists !== after.exists)
+        return true;
+    if (!before.exists && !after.exists)
+        return false;
+    if (before.sha256 !== undefined && after.sha256 !== undefined) {
+        return before.sha256 !== after.sha256;
+    }
+    return before.size_bytes !== after.size_bytes || before.mtime_ms !== after.mtime_ms;
+}
+function normalized(path) {
+    return normalize(path).replaceAll("\\", "/");
+}
+function targetPaths(options) {
+    return {
+        homeDir: normalized(resolve(options.homeDir)),
+        runDir: normalized(resolve(options.runDir)),
+        sharedMemory: normalized(resolve(options.homeDir, "MEMORY.md")),
+        sharedLessons: normalized(resolve(options.homeDir, "notes", "lessons.md")),
+        sharedNotes: normalized(resolve(options.homeDir, "notes")),
+        cwdMemory: normalized(resolve(options.runDir, "MEMORY.md")),
+        cwdLessons: normalized(resolve(options.runDir, "notes", "lessons.md")),
+    };
+}
+function classifyExplicitPath(path, paths) {
+    const replaced = path
+        .replace(/^\$\{CREW_HOME\}/, paths.homeDir)
+        .replace(/^\$CREW_HOME/, paths.homeDir);
+    const absolute = normalized(isAbsolute(replaced) ? replaced : resolve(paths.runDir, replaced));
+    if (absolute === paths.sharedMemory)
+        return "shared_memory";
+    if (absolute === paths.sharedLessons)
+        return "shared_lessons";
+    if (absolute === paths.cwdMemory && paths.cwdMemory !== paths.sharedMemory)
+        return "cwd_shadow_memory";
+    if (absolute === paths.cwdLessons && paths.cwdLessons !== paths.sharedLessons)
+        return "cwd_shadow_lessons";
+    if (absolute.startsWith(`${paths.sharedNotes}/`))
+        return "other_shared_note";
+    return null;
+}
+function commandTargets(command, paths) {
+    const targets = new Set();
+    const expandedCommand = command
+        .replaceAll("${CREW_HOME}", paths.homeDir)
+        .replaceAll("$CREW_HOME", paths.homeDir)
+        .replace(/["']/g, "");
+    const references = [
+        { values: [paths.sharedMemory], target: "shared_memory" },
+        { values: [paths.sharedLessons], target: "shared_lessons" },
+        { values: [paths.cwdMemory], target: "cwd_shadow_memory" },
+        { values: [paths.cwdLessons], target: "cwd_shadow_lessons" },
+    ];
+    for (const reference of references) {
+        if (reference.values.some((value) => expandedCommand.includes(value)))
+            targets.add(reference.target);
+    }
+    const withoutKnownPaths = references.flatMap((reference) => reference.values)
+        .reduce((value, reference) => value.replaceAll(reference, ""), expandedCommand);
+    if (/(?:^|[\s'"`])notes[\\/]lessons\.md(?:$|[\s'"`;|&])/i.test(withoutKnownPaths)) {
+        targets.add("cwd_shadow_lessons");
+    }
+    else if (/(?:^|[\s'"`])MEMORY\.md(?:$|[\s'"`;|&])/i.test(withoutKnownPaths)) {
+        targets.add("cwd_shadow_memory");
+    }
+    return [...targets];
+}
+function commandOperation(command) {
+    if (/(?:^|[;&|]\s*|\s)(?:rm|unlink)\s/i.test(command))
+        return "delete";
+    if (/(?:>>?|\btee\b|\btouch\b|\btruncate\b|\bsed\s+-i\b|\bperl\b[^\n]*\s-i\b|\bapply_patch\b)/i.test(command)) {
+        return "write";
+    }
+    return "read";
+}
+function toolOperation(name) {
+    const lowered = name.toLowerCase();
+    if (["read", "readfile", "view"].includes(lowered))
+        return "read";
+    if (["write", "writefile", "edit", "multiedit", "apply_patch", "patch"].includes(lowered))
+        return "write";
+    if (["delete", "remove", "unlink"].includes(lowered))
+        return "delete";
+    return null;
+}
+function toolPath(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return null;
+    const record = input;
+    for (const key of ["file_path", "path", "filePath"]) {
+        if (typeof record[key] === "string")
+            return record[key];
+    }
+    return null;
+}
+function recordObservation(observations, counts, observation) {
+    observations.push(observation);
+    const key = `${observation.target}:${observation.operation}:${observation.outcome}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+}
+export function createLocalMemoryAccessObserver(options) {
+    const paths = targetPaths(options);
+    const pending = new Map();
+    const counts = new Map();
+    return {
+        observe(event) {
+            const observations = [];
+            if (!event || typeof event !== "object")
+                return observations;
+            const record = event;
+            const message = record.message && typeof record.message === "object"
+                ? record.message
+                : undefined;
+            const blocks = Array.isArray(message?.content) ? message.content : [];
+            if (record.type === "assistant") {
+                for (const block of blocks) {
+                    if (block.type !== "tool_use" || typeof block.id !== "string" || typeof block.name !== "string")
+                        continue;
+                    const operation = toolOperation(block.name);
+                    const path = toolPath(block.input);
+                    const target = operation === null || path === null ? null : classifyExplicitPath(path, paths);
+                    if (operation !== null && target !== null)
+                        pending.set(block.id, { operation, target });
+                }
+            }
+            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);
+                    pending.delete(block.tool_use_id);
+                    if (access === undefined)
+                        continue;
+                    recordObservation(observations, counts, {
+                        ...access,
+                        outcome: block.is_error === true ? "failed" : "succeeded",
+                        evidence: "structured_tool",
+                    });
+                }
+            }
+            if (record.type === "kimi.acp.tool_call" && typeof record.id === "string") {
+                const operation = typeof record.kind === "string"
+                    ? toolOperation(record.kind)
+                    : null;
+                const fallbackOperation = operation ?? (typeof record.title === "string"
+                    ? toolOperation(record.title)
+                    : null);
+                const path = toolPath(record.input);
+                const target = fallbackOperation === null || path === null
+                    ? null
+                    : classifyExplicitPath(path, paths);
+                if (fallbackOperation !== null && target !== null) {
+                    pending.set(record.id, { operation: fallbackOperation, target });
+                }
+            }
+            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);
+                pending.delete(record.id);
+                if (access !== undefined) {
+                    recordObservation(observations, counts, {
+                        ...access,
+                        outcome: record.status === "failed" ? "failed" : "succeeded",
+                        evidence: "structured_tool",
+                    });
+                }
+            }
+            const item = record.type === "item.completed" && record.item && typeof record.item === "object"
+                ? record.item
+                : null;
+            if (item?.type === "command_execution" && typeof item.command === "string") {
+                const operation = commandOperation(item.command);
+                const outcome = typeof item.exit_code === "number"
+                    ? item.exit_code === 0 ? "succeeded" : "failed"
+                    : item.status === "completed"
+                        ? "succeeded"
+                        : item.status === "failed" || item.status === "declined"
+                            ? "failed"
+                            : "unknown";
+                for (const target of commandTargets(item.command, paths)) {
+                    recordObservation(observations, counts, { target, operation, outcome, evidence: "shell_command" });
+                }
+            }
+            const fileChange = record.type === "diagnostic.file_change" && Array.isArray(record.changes)
+                ? record
+                : item?.type === "file_change" && Array.isArray(item.changes)
+                    ? item
+                    : null;
+            if (fileChange !== null && Array.isArray(fileChange.changes)) {
+                const outcome = fileChange.status === "completed"
+                    ? "succeeded"
+                    : fileChange.status === "failed" || fileChange.status === "declined"
+                        ? "failed"
+                        : fileChange === item ? "succeeded" : "unknown";
+                for (const change of fileChange.changes) {
+                    if (!change || typeof change !== "object")
+                        continue;
+                    const detail = change;
+                    if (typeof detail.path !== "string")
+                        continue;
+                    const target = classifyExplicitPath(detail.path, paths);
+                    if (target === null)
+                        continue;
+                    recordObservation(observations, counts, {
+                        target,
+                        operation: detail.kind === "delete" ? "delete" : "write",
+                        outcome,
+                        evidence: "file_change",
+                    });
+                }
+            }
+            return observations;
+        },
+        summary() {
+            const count = (target, operation, outcome) => counts.get(`${target}:${operation}:${outcome}`) ?? 0;
+            return {
+                memory_read_succeeded: count("shared_memory", "read", "succeeded"),
+                memory_read_failed: count("shared_memory", "read", "failed"),
+                lessons_read_succeeded: count("shared_lessons", "read", "succeeded"),
+                lessons_read_failed: count("shared_lessons", "read", "failed"),
+                shared_memory_write_succeeded: count("shared_memory", "write", "succeeded"),
+                shared_lessons_write_succeeded: count("shared_lessons", "write", "succeeded"),
+                cwd_shadow_write_succeeded: count("cwd_shadow_memory", "write", "succeeded")
+                    + count("cwd_shadow_lessons", "write", "succeeded"),
+                pending_access_count: pending.size,
+            };
+        },
+    };
+}