@zenera/neo 1.1.12 → 1.1.15

package/dist/inspect/report.js

@@ -1,3 +1,4 @@
+import { buildMemorySlice } from "../memory/report.js";
 import { collectPayloads } from "../payload.js";
 // ---------------------------------------------------------------------------
 // Run inspector — a single HTML file that explains a run
@@ -12,6 +13,9 @@ import { collectPayloads } from "../payload.js";
  *  a report into a file no editor will open. */
 export const MAX_BLOB_BYTES = 512 * 1024;
 export const MERMAID_URL = 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';
+/** Deliberately meaner than the memory page's own cap: this file already holds
+ *  a whole run, and one remembered artifact should not decide whether it opens. */
+export const MAX_MEMORY_FILE_BYTES = 64 * 1024;
 /** Base64 data uris only: the charset ends at the closing JSON quote. */
 const DATA_URL = /data:[\w.+-]+\/[\w.+-]+;base64,[A-Za-z0-9+/=]+/g;
 /** Below this a uri is cheaper to leave in place than to indirect through. */
@@ -57,6 +61,47 @@ export async function buildRunReport(state, payloads, opts = {}) {
         truncated,
         media,
         architecture: opts.architecture,
+        memory: opts.memory ? await remembered(opts.memory, state, media, opts) : undefined,
+    };
+}
+/** Every memory node the run touched, branches included. */
+function memoryIds(nodes, into) {
+    for (const node of nodes) {
+        if (node.type === 'memory_recall' || node.type === 'memory_op') {
+            for (const n of node.nodes) {
+                into.add(n.id);
+            }
+        }
+        else if (node.type === 'join') {
+            for (const branch of node.branches) {
+                memoryIds(branch.nodes, into);
+            }
+        }
+    }
+    return into;
+}
+async function remembered(store, state, media, opts) {
+    const ids = memoryIds(state.trajectory, new Set());
+    if (!ids.size) {
+        return undefined;
+    }
+    let slice;
+    try {
+        slice = await buildMemorySlice(store, [...ids], {
+            maxContentBytes: opts.maxMemoryFileBytes ?? MAX_MEMORY_FILE_BYTES,
+        });
+    }
+    catch {
+        // A memory that cannot be read is a view the page does without; it is
+        // not a reason to lose the record of the run.
+        return undefined;
+    }
+    return {
+        dir: store.dir,
+        // Remembered images go through the same table as the run's own, so a
+        // picture the agent both saw and filed is carried once.
+        nodes: slice.nodes.map((n) => (n.image ? { ...n, image: hoistMedia(n.image, media) } : n)),
+        edges: slice.edges,
     };
 }
 //# sourceMappingURL=report.js.map

package/dist/memory/report.d.ts

@@ -53,5 +53,17 @@ export interface MemoryReportOptions {
     /** override the clock, for tests */
     now?: () => string;
 }
+/** Part of a memory, for a caller that already knows which part it wants. */
+export interface MemorySlice {
+    nodes: ReportNode[];
+    /** only the edges with both ends inside the slice */
+    edges: MemoryEdge[];
+}
+/**
+ * The nodes named, built exactly as the whole graph is — same inlining, same
+ * excuses, same degree, which is counted over every edge rather than over the
+ * slice: a node's degree is a fact about the memory, not about the cut.
+ */
+export declare function buildMemorySlice(store: MemoryStore, ids: readonly string[], opts?: Pick<MemoryReportOptions, 'maxContentBytes'>): Promise<MemorySlice>;
 export declare function buildMemoryReport(store: MemoryStore, opts?: MemoryReportOptions): Promise<MemoryReport>;
 //# sourceMappingURL=report.d.ts.map

package/dist/memory/report.js

@@ -25,25 +25,26 @@ const MIME = {
     webp: 'image/webp',
     svg: 'image/svg+xml',
 };
+/**
+ * The nodes named, built exactly as the whole graph is — same inlining, same
+ * excuses, same degree, which is counted over every edge rather than over the
+ * slice: a node's degree is a fact about the memory, not about the cut.
+ */
+export async function buildMemorySlice(store, ids, opts = {}) {
+    const graph = store.graph;
+    const all = graph.edges();
+    const wanted = new Set(ids);
+    return {
+        nodes: await inline(store, graph.nodes().filter((n) => wanted.has(n.id)), degrees(all), graph.superseded(), opts.maxContentBytes ?? MAX_CONTENT_BYTES),
+        edges: all.filter((e) => wanted.has(e.source) && wanted.has(e.target)),
+    };
+}
 export async function buildMemoryReport(store, opts = {}) {
     const graph = store.graph;
     const nodes = graph.nodes();
     const edges = graph.edges();
-    const stale = graph.superseded();
     const limit = opts.maxContentBytes ?? MAX_CONTENT_BYTES;
-    const degree = new Map();
-    for (const e of edges) {
-        degree.set(e.source, (degree.get(e.source) ?? 0) + 1);
-        degree.set(e.target, (degree.get(e.target) ?? 0) + 1);
-    }
-    // Files are read in parallel: one memory can hold hundreds, and they are
-    // independent.
-    const built = await Promise.all(nodes.map(async (n) => ({
-        ...plain(n),
-        stale: stale.has(n.id),
-        degree: degree.get(n.id) ?? 0,
-        ...(n.file ? await body(store.dir, n.file, limit) : {}),
-    })));
+    const built = await inline(store, nodes, degrees(edges), graph.superseded(), limit);
     const vectors = store.vectors;
     return {
         title: opts.title ?? 'Memory',
@@ -59,6 +60,23 @@ export async function buildMemoryReport(store, opts = {}) {
         audiences: [...new Set(nodes.flatMap((n) => n.audience))].sort(),
     };
 }
+function degrees(edges) {
+    const degree = new Map();
+    for (const e of edges) {
+        degree.set(e.source, (degree.get(e.source) ?? 0) + 1);
+        degree.set(e.target, (degree.get(e.target) ?? 0) + 1);
+    }
+    return degree;
+}
+/** Files are read in parallel: one memory can hold hundreds, independently. */
+async function inline(store, nodes, degree, stale, limit) {
+    return Promise.all(nodes.map(async (n) => ({
+        ...plain(n),
+        stale: stale.has(n.id),
+        degree: degree.get(n.id) ?? 0,
+        ...(n.file ? await body(store.dir, n.file, limit) : {}),
+    })));
+}
 /** The node's own fields, without the graph attributes graphology adds. */
 function plain(n) {
     return {

package/dist/memory/tools.js

@@ -101,8 +101,23 @@ export function memoryTools(opts) {
                 additionalProperties: false,
             },
             execute: async (args, tc) => {
+                const opId = memoryOpId(tc.state.runId, tc.callId);
                 const loaded = await index.load(args.ids, binding.sees, tc.services.clock);
-                return loaded.map((l) => ({
+                // Recorded because this is the only path that puts a whole body
+                // in the context: a recall block carries a clipped line.
+                const spec = {
+                    kind: 'op',
+                    op: 'load',
+                    opId,
+                    nodes: loaded.map((l) => ({
+                        id: l.node.id,
+                        kind: l.node.kind,
+                        revision: l.node.revision,
+                    })),
+                    edges: [],
+                    files: loaded.filter((l) => l.content !== undefined).length,
+                };
+                return withEffects(loaded.map((l) => ({
                     id: l.node.id,
                     kind: l.node.kind,
                     text: l.node.text,
@@ -113,7 +128,7 @@ export function memoryTools(opts) {
                         ? { path: l.node.file.path, bytes: l.node.file.bytes }
                         : undefined,
                     content: l.content,
-                }));
+                })), { kind: 'memory_op', spec });
             },
         }),
     ];
@@ -271,6 +286,11 @@ export function memoryTools(opts) {
                 const node = index.graph.get(id);
                 return node ? [{ id, kind: node.kind, revision: node.revision }] : [];
             });
+            // Taken before the delete: afterwards nothing can say what this
+            // node hung from, and a report would draw it floating.
+            const links = new Map(args.ids
+                .flatMap((id) => index.graph.neighbors(id, binding.sees))
+                .map((e) => [`${e.source}|${e.relation}|${e.target}`, e]));
             try {
                 await index.forget(args.ids, binding.sees);
             }
@@ -279,7 +299,14 @@ export function memoryTools(opts) {
             }
             return withEffects(`${MEMORY_FORGET_TOOL} ${before.length} nodes`, {
                 kind: 'memory_op',
-                spec: { kind: 'op', op: 'forget', opId, nodes: before, edges: [], files: 0 },
+                spec: {
+                    kind: 'op',
+                    op: 'forget',
+                    opId,
+                    nodes: before,
+                    edges: [...links.values()],
+                    files: 0,
+                },
             });
         },
     }));

package/dist/memory/types.d.ts

@@ -169,10 +169,11 @@ export interface MemoryRecallSpec {
 }
 export interface MemoryOpSpec {
     kind: 'op';
-    op: 'commit' | 'forget';
+    /** `load` is here rather than under recall: it hands the model whole bodies, and it writes. */
+    op: 'commit' | 'forget' | 'load';
     /** sha256(runId, callId) — deterministic, so a replay is deduplicated */
     opId: string;
-    /** nodes this op created, changed or removed */
+    /** nodes this op created, changed, removed or read in full */
     nodes: {
         id: string;
         kind: string;

package/dist/trajectory.d.ts

@@ -67,7 +67,7 @@ export interface MemoryRecallNode extends NodeBase {
 }
 export interface MemoryOpNode extends NodeBase {
     type: 'memory_op';
-    op: 'commit' | 'forget';
+    op: 'commit' | 'forget' | 'load';
     /** sha256(runId, callId) — deterministic, so a replay is deduplicated */
     opId: string;
     nodes: {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenera/neo",
-    "version": "1.1.12",
+    "version": "1.1.15",
     "description": "A multi-agent runtime for Node.js: agents, models, tools, skills, memory and an append-only trajectory.",
     "keywords": [
         "agents",