@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/core/dist/plugins/graph-memory.js

@@ -1,9 +1,11 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { basename, dirname, join, resolve } from "node:path";
+import { lstat, mkdir, opendir, rmdir, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { Type } from "@earendil-works/pi-ai";
 import { defineTool } from "@earendil-works/pi-coding-agent";
+import { atomicWriteFile } from "../atomic-write.js";
+import { readBoundedFile, readBoundedTextFile } from "../bounded-file.js";
 const defaultFileName = "graph-memory.json";
 const absoluteNodeLimit = 2_000;
 const absoluteRelationLimit = 5_000;
@@ -12,26 +14,166 @@ const maxSummaryBytes = 16 * 1024;
 const maxSourceLength = 512;
 const maxQueryLength = 160;
 const maxFileBytes = 4 * 1024 * 1024;
+const maxSearchResults = 50;
 const lockRetryMs = 25;
 const lockTimeoutMs = 10_000;
+const staleLockMs = 30_000;
+const maxLockOwnerBytes = 1024;
+const nodeFields = new Set(["id", "kind", "label", "summary", "source", "createdAt", "updatedAt"]);
+const relationFields = new Set(["id", "from", "to", "relation", "createdAt"]);
+function cloneNode(node) {
+    return { ...node };
+}
+function cloneRelation(relation) {
+    return { ...relation };
+}
+function cloneSearchReport(report) {
+    return { ...report, nodes: report.nodes.map(cloneNode), relations: report.relations.map(cloneRelation) };
+}
+function throwIfAborted(signal) {
+    if (!signal.aborted)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("Graph memory operation was cancelled", { cause: signal.reason });
+}
+function rejectionError(error, message) {
+    return error instanceof Error ? error : new Error(message, { cause: error });
+}
+function withCancellation(operation, signal) {
+    try {
+        throwIfAborted(signal);
+    }
+    catch (error) {
+        return Promise.reject(rejectionError(error, "Graph memory operation was cancelled"));
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            signal.removeEventListener("abort", onAbort);
+            try {
+                throwIfAborted(signal);
+            }
+            catch (error) {
+                reject(rejectionError(error, "Graph memory operation was cancelled"));
+            }
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        void operation.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(rejectionError(error, "Graph memory operation failed"));
+        });
+    });
+}
+async function waitForLockRetry(signal) {
+    throwIfAborted(signal);
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, lockRetryMs);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
+            try {
+                throwIfAborted(signal);
+            }
+            catch (error) {
+                reject(error instanceof Error ? error : new Error("Graph memory operation was cancelled", { cause: error }));
+            }
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
 export const Config = z.object({
     fileName: z.string().default(defaultFileName),
     maxNodes: z.number().default(absoluteNodeLimit),
     maxRelations: z.number().default(absoluteRelationLimit),
 });
+function boundedInteger(value, fallback, maximum) {
+    return typeof value === "number" && Number.isFinite(value) ? Math.max(1, Math.min(maximum, Math.trunc(value))) : fallback;
+}
+function dataDescriptors(value, field, allowed) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${field} must be an object`);
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (Reflect.ownKeys(descriptors).some((key) => typeof key !== "string" || !allowed.has(key)))
+        throw new Error(`${field} contains an unknown property`);
+    if (Object.values(descriptors).some((descriptor) => !("value" in descriptor)))
+        throw new Error(`${field} must use data properties`);
+    return descriptors;
+}
+function recordParameters(value) {
+    const descriptors = dataDescriptors(value, "Graph memory record parameters", new Set(["kind", "label", "summary", "source"]));
+    const kind = descriptors.kind?.value;
+    const label = descriptors.label?.value;
+    const summary = descriptors.summary?.value;
+    const source = descriptors.source?.value;
+    if (!isNodeKind(kind))
+        throw new Error("Graph memory kind must be task, skill, or event");
+    if (typeof label !== "string")
+        throw new Error("Graph memory label must be a string");
+    if (typeof summary !== "string")
+        throw new Error("Graph memory summary must be a string");
+    if (source !== undefined && typeof source !== "string")
+        throw new Error("Graph memory source must be a string");
+    return { kind, label, summary, ...(source === undefined ? {} : { source }) };
+}
+function linkParameters(value) {
+    const descriptors = dataDescriptors(value, "Graph memory link parameters", new Set(["from", "to", "relation"]));
+    const from = descriptors.from?.value;
+    const to = descriptors.to?.value;
+    const relation = descriptors.relation?.value;
+    if (typeof from !== "string")
+        throw new Error("Graph memory link from must be a string");
+    if (typeof to !== "string")
+        throw new Error("Graph memory link to must be a string");
+    if (!isRelationKind(relation))
+        throw new Error("Graph memory relation kind is invalid");
+    return { from, to, relation };
+}
+function searchParameters(value) {
+    const descriptors = dataDescriptors(value, "Graph memory search parameters", new Set(["query", "kind", "limit"]));
+    const query = descriptors.query?.value;
+    const kind = descriptors.kind?.value;
+    const limit = descriptors.limit?.value;
+    if (typeof query !== "string")
+        throw new Error("Graph memory query must be a string");
+    if (kind !== undefined && !isNodeKind(kind))
+        throw new Error("Graph memory search kind must be task, skill, or event");
+    if (limit !== undefined && typeof limit !== "number")
+        throw new Error("Graph memory search limit must be a number");
+    return { query, ...(kind === undefined ? {} : { kind }), ...(limit === undefined ? {} : { limit }) };
+}
+function forgetParameters(value) {
+    const descriptors = dataDescriptors(value, "Graph memory forget parameters", new Set(["id", "confirm"]));
+    const id = descriptors.id?.value;
+    const confirm = descriptors.confirm?.value;
+    if (typeof id !== "string")
+        throw new Error("Graph memory forget id must be a string");
+    if (typeof confirm !== "boolean")
+        throw new Error("Graph memory forget confirm must be a boolean");
+    return { id, confirm };
+}
 function normalizeFilePath(agentDir, fileName) {
     const name = (fileName ?? defaultFileName).trim();
-    if (name === "" || basename(name) !== name || !name.toLowerCase().endsWith(".json"))
+    if (name.includes("\0"))
+        throw new Error("Graph memory fileName must not contain NUL characters");
+    if (name === "" || name.includes("/") || name.includes("\\") || basename(name) !== name || !name.toLowerCase().endsWith(".json"))
         throw new Error("Graph memory fileName must be a single .json filename");
     return resolve(agentDir, name);
 }
 function normalizeText(value, field, maxLength) {
+    if (value.includes("\0"))
+        throw new Error(`${field} must not contain NUL characters`);
     const normalized = value.trim();
     if (normalized.length === 0 || normalized.length > maxLength)
         throw new Error(`${field} must contain 1-${maxLength} characters`);
     return normalized;
 }
 function normalizeSummary(value) {
+    if (value.includes("\0"))
+        throw new Error("Graph memory summary must not contain NUL characters");
     const normalized = value.trim();
     if (normalized === "" || Buffer.byteLength(normalized, "utf8") > maxSummaryBytes)
         throw new Error(`Graph memory summary must be non-empty and at most ${maxSummaryBytes} bytes`);
@@ -47,7 +189,8 @@ function isGraphNode(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         return false;
     const node = value;
-    return (typeof node.id === "string" &&
+    return (Object.keys(node).every((key) => nodeFields.has(key)) &&
+        typeof node.id === "string" &&
         node.id.length > 0 &&
         node.id.length <= maxLabelLength &&
         isNodeKind(node.kind) &&
@@ -68,7 +211,8 @@ function isGraphRelation(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         return false;
     const relation = value;
-    return (typeof relation.id === "string" &&
+    return (Object.keys(relation).every((key) => relationFields.has(key)) &&
+        typeof relation.id === "string" &&
         relation.id.length > 0 &&
         relation.id.length <= maxLabelLength &&
         typeof relation.from === "string" &&
@@ -80,15 +224,13 @@ function isGraphRelation(value) {
 async function readGraphFile(filePath, nodeLimit, relationLimit) {
     let raw;
     try {
-        raw = await readFile(filePath);
+        raw = await readBoundedFile(filePath, maxFileBytes, "Graph memory file");
     }
     catch (error) {
         if (error.code === "ENOENT")
             return { nodes: [], relations: [] };
         throw error;
     }
-    if (raw.byteLength > maxFileBytes)
-        throw new Error(`Graph memory file exceeds its ${maxFileBytes}-byte limit`);
     const parsed = JSON.parse(raw.toString("utf8"));
     if (parsed.version !== 1 || !Array.isArray(parsed.nodes) || !Array.isArray(parsed.relations))
         throw new Error("Graph memory file has an unsupported format");
@@ -116,24 +258,135 @@ async function readGraphFile(filePath, nodeLimit, relationLimit) {
 }
 async function writeGraphFile(filePath, state) {
     const payload = JSON.stringify({ version: 1, ...state }, null, 2);
+    const bytes = Buffer.byteLength(payload, "utf8");
+    if (bytes > maxFileBytes)
+        throw new Error(`Graph memory file exceeds its ${maxFileBytes}-byte limit`);
     await mkdir(dirname(filePath), { recursive: true });
-    const temporary = join(dirname(filePath), `.${basename(filePath)}.${randomUUID()}.tmp`);
-    await writeFile(temporary, payload, { encoding: "utf8", mode: 0o600 });
-    await rename(temporary, filePath);
+    await atomicWriteFile(filePath, payload, { encoding: "utf8", mode: 0o600 });
+}
+function graphLockOwnerIsAlive(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const pid = value.pid;
+    if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
+        return undefined;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "ESRCH" ? false : true;
+    }
 }
-async function acquireGraphLock(lockPath) {
+function sameFile(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+async function reclaimStaleGraphLock(lockPath, lockMetadata) {
+    if (Date.now() - Number(lockMetadata.mtimeMs) <= staleLockMs)
+        return false;
+    let directory;
+    try {
+        directory = await opendir(lockPath, { bufferSize: 1 });
+    }
+    catch {
+        return false;
+    }
+    let ownerName;
+    try {
+        const owner = await directory.read();
+        const extra = await directory.read();
+        if (owner === null || extra !== null || !/^[a-z0-9-]{1,64}\.owner$/iu.test(owner.name))
+            return false;
+        ownerName = owner.name;
+    }
+    finally {
+        await directory.close().catch(() => undefined);
+    }
+    const ownerPath = resolve(lockPath, ownerName);
+    let ownerMetadata;
+    try {
+        ownerMetadata = await lstat(ownerPath);
+        if (!ownerMetadata.isFile() || ownerMetadata.isSymbolicLink() || Date.now() - Number(ownerMetadata.mtimeMs) <= staleLockMs)
+            return false;
+        const owner = JSON.parse(await readBoundedTextFile(ownerPath, maxLockOwnerBytes, "Graph memory lock owner"));
+        if (graphLockOwnerIsAlive(owner) === true)
+            return false;
+        const [currentLockMetadata, currentOwnerMetadata] = await Promise.all([lstat(lockPath), lstat(ownerPath)]);
+        if (!sameFile(lockMetadata, currentLockMetadata) || !sameFile(ownerMetadata, currentOwnerMetadata))
+            return false;
+        await unlink(ownerPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        if (!(error instanceof SyntaxError))
+            return false;
+        const [currentLockMetadata, currentOwnerMetadata] = await Promise.all([lstat(lockPath), lstat(ownerPath)]).catch(() => []);
+        if (currentLockMetadata === undefined || currentOwnerMetadata === undefined)
+            return false;
+        if (!sameFile(lockMetadata, currentLockMetadata) || ownerMetadata === undefined || !sameFile(ownerMetadata, currentOwnerMetadata))
+            return false;
+        await unlink(ownerPath).catch(() => undefined);
+    }
+    try {
+        await rmdir(lockPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function acquireGraphLock(lockPath, signal) {
     const deadline = Date.now() + lockTimeoutMs;
     while (true) {
+        throwIfAborted(signal);
         try {
-            await mkdir(lockPath);
+            await mkdir(lockPath, { mode: 0o700 });
+            const token = randomUUID();
+            const ownerPath = resolve(lockPath, `${token}.owner`);
+            try {
+                await writeFile(ownerPath, JSON.stringify({ pid: process.pid, token }), { encoding: "utf8", mode: 0o600, flag: "wx" });
+            }
+            catch (error) {
+                await rmdir(lockPath).catch(() => undefined);
+                throw new Error("Could not establish graph memory lock ownership", { cause: error });
+            }
             return async () => {
-                await rm(lockPath, { recursive: true, force: true });
+                try {
+                    await unlink(ownerPath);
+                }
+                catch (error) {
+                    throw new Error("Graph memory lock ownership was lost before release", { cause: error });
+                }
+                try {
+                    await rmdir(lockPath);
+                }
+                catch (error) {
+                    throw new Error("Could not safely release graph memory file lock", { cause: error });
+                }
             };
         }
         catch (error) {
-            if (error.code !== "EEXIST" || Date.now() >= deadline)
+            if (error.code !== "EEXIST")
+                throw new Error("Could not acquire graph memory file lock", { cause: error });
+            let metadata;
+            try {
+                metadata = await lstat(lockPath);
+            }
+            catch (inspectionError) {
+                if (inspectionError.code === "ENOENT")
+                    continue;
+                throw new Error("Could not inspect graph memory file lock", { cause: inspectionError });
+            }
+            if (metadata.isSymbolicLink())
+                throw new Error("Graph memory file lock must not be a symbolic link", { cause: error });
+            if (!metadata.isDirectory())
+                throw new Error("Graph memory file lock must be a directory", { cause: error });
+            if (await reclaimStaleGraphLock(lockPath, metadata))
+                continue;
+            if (Date.now() >= deadline)
                 throw new Error("Timed out waiting for graph memory file lock", { cause: error });
-            await new Promise((resolve) => setTimeout(resolve, lockRetryMs));
+            await waitForLockRetry(signal);
         }
     }
 }
@@ -143,45 +396,59 @@ export default {
     Config,
     apply(context, config) {
         const filePath = normalizeFilePath(context.piHarnessLaunch.agentDir, config.fileName);
-        const nodeLimit = Math.max(1, Math.min(absoluteNodeLimit, Math.trunc(config.maxNodes ?? absoluteNodeLimit)));
-        const relationLimit = Math.max(1, Math.min(absoluteRelationLimit, Math.trunc(config.maxRelations ?? absoluteRelationLimit)));
+        const nodeLimit = boundedInteger(config.maxNodes, absoluteNodeLimit, absoluteNodeLimit);
+        const relationLimit = boundedInteger(config.maxRelations, absoluteRelationLimit, absoluteRelationLimit);
         let nodes = [];
         let relations = [];
         let loaded = false;
         let loading;
         let mutationQueue = Promise.resolve();
         let lastSearch;
+        const lifecycle = new AbortController();
         const load = async () => {
             if (loaded)
                 return;
             if (loading !== undefined)
                 return loading;
-            loading = (async () => {
+            const pending = (async () => {
                 const state = await readGraphFile(filePath, nodeLimit, relationLimit);
                 nodes = state.nodes;
                 relations = state.relations;
                 loaded = true;
             })();
-            return loading;
+            loading = pending;
+            try {
+                await pending;
+            }
+            finally {
+                if (loading === pending)
+                    loading = undefined;
+            }
         };
-        const mutate = async (operation) => {
+        const mutate = async (operation, signal) => {
+            throwIfAborted(signal);
             let result;
             const run = async () => {
-                const release = await acquireGraphLock(`${filePath}.lock`);
+                throwIfAborted(signal);
+                const release = await acquireGraphLock(`${filePath}.lock`, signal);
                 try {
                     const state = await readGraphFile(filePath, nodeLimit, relationLimit);
+                    throwIfAborted(signal);
                     result = operation(state);
+                    throwIfAborted(signal);
                     await writeGraphFile(filePath, state);
                     nodes = state.nodes;
                     relations = state.relations;
                     loaded = true;
+                    lastSearch = undefined;
                 }
                 finally {
                     await release();
                 }
             };
-            mutationQueue = mutationQueue.catch(() => undefined).then(run);
-            await mutationQueue;
+            const scheduled = mutationQueue.catch(() => undefined).then(run);
+            mutationQueue = scheduled.then(() => undefined, () => undefined);
+            await withCancellation(scheduled, signal);
             return result;
         };
         const recordTool = defineTool({
@@ -194,8 +461,12 @@ export default {
                 label: Type.String(),
                 summary: Type.String(),
                 source: Type.Optional(Type.String()),
-            }),
-            async execute(_toolCallId, params) {
+            }, { additionalProperties: false }),
+            executionMode: "sequential",
+            async execute(_toolCallId, rawParams, signal) {
+                const params = recordParameters(rawParams);
+                const operationSignal = signal === undefined ? lifecycle.signal : AbortSignal.any([signal, lifecycle.signal]);
+                throwIfAborted(operationSignal);
                 const label = normalizeText(params.label, "Graph memory label", maxLabelLength);
                 const summary = normalizeSummary(params.summary);
                 const source = params.source === undefined ? undefined : normalizeText(params.source, "Graph memory source", maxSourceLength);
@@ -209,8 +480,8 @@ export default {
                         : { ...existing, label, summary, ...(source === undefined ? {} : { source }), updatedAt: now };
                     state.nodes = [next, ...state.nodes.filter((candidate) => candidate.id !== next.id)];
                     return next;
-                });
-                return { content: [{ type: "text", text: `Graph memory recorded: ${node.id} [${node.kind}] ${node.label}` }], details: node };
+                }, operationSignal);
+                return { content: [{ type: "text", text: `Graph memory recorded: ${node.id} [${node.kind}] ${node.label}` }], details: cloneNode(node) };
             },
         });
         const linkTool = defineTool({
@@ -229,8 +500,12 @@ export default {
                     Type.Literal("CONFLICTS_WITH"),
                     Type.Literal("RELATED_TO"),
                 ]),
-            }),
-            async execute(_toolCallId, params) {
+            }, { additionalProperties: false }),
+            executionMode: "sequential",
+            async execute(_toolCallId, rawParams, signal) {
+                const params = linkParameters(rawParams);
+                const operationSignal = signal === undefined ? lifecycle.signal : AbortSignal.any([signal, lifecycle.signal]);
+                throwIfAborted(operationSignal);
                 const from = normalizeText(params.from, "Graph relation source id", maxLabelLength);
                 const to = normalizeText(params.to, "Graph relation target id", maxLabelLength);
                 if (from === to)
@@ -248,10 +523,10 @@ export default {
                     const next = { id: randomUUID(), from, to, relation: params.relation, createdAt: new Date().toISOString() };
                     state.relations = [next, ...state.relations];
                     return next;
-                });
+                }, operationSignal);
                 return {
                     content: [{ type: "text", text: `Graph relation ${relation.id} ${relation.relation}: ${relation.from} → ${relation.to}` }],
-                    details: relation,
+                    details: cloneRelation(relation),
                 };
             },
         });
@@ -264,14 +539,19 @@ export default {
                 query: Type.String(),
                 kind: Type.Optional(Type.Union([Type.Literal("task"), Type.Literal("skill"), Type.Literal("event")])),
                 limit: Type.Optional(Type.Number()),
-            }),
-            async execute(_toolCallId, params) {
+            }, { additionalProperties: false }),
+            executionMode: "sequential",
+            async execute(_toolCallId, rawParams, signal) {
+                const params = searchParameters(rawParams);
+                const operationSignal = signal === undefined ? lifecycle.signal : AbortSignal.any([signal, lifecycle.signal]);
+                throwIfAborted(operationSignal);
                 await load();
+                throwIfAborted(operationSignal);
                 const query = normalizeText(params.query, "Graph memory query", maxQueryLength);
                 if (query.length < 2)
                     throw new Error(`Graph memory query must contain 2-${maxQueryLength} characters`);
                 const needle = query.toLocaleLowerCase();
-                const limit = Math.max(1, Math.min(50, Math.trunc(params.limit ?? 12)));
+                const limit = boundedInteger(params.limit, 12, maxSearchResults);
                 const ranked = nodes
                     .filter((node) => params.kind === undefined || node.kind === params.kind)
                     .map((node) => {
@@ -297,7 +577,8 @@ export default {
                 const matches = ranked.slice(0, limit).map((match) => match.node);
                 const matchedIds = new Set(matches.map((node) => node.id));
                 const matchedRelations = relations.filter((relation) => matchedIds.has(relation.from) || matchedIds.has(relation.to)).slice(0, limit * 4);
-                lastSearch = { query, total: ranked.length, nodes: matches, relations: matchedRelations };
+                const report = { query, total: ranked.length, nodes: matches.map(cloneNode), relations: matchedRelations.map(cloneRelation) };
+                lastSearch = cloneSearchReport(report);
                 return {
                     content: [
                         {
@@ -307,7 +588,7 @@ export default {
                                 : matches.map((node) => `${node.id} [${node.kind}] ${node.label}: ${node.summary}`).join("\n"),
                         },
                     ],
-                    details: lastSearch,
+                    details: cloneSearchReport(report),
                 };
             },
         });
@@ -316,8 +597,12 @@ export default {
             label: "Forget graph memory",
             description: "Delete one graph-memory node and all incident relations after explicit confirmation.",
             promptSnippet: "forget a graph memory after confirmation",
-            parameters: Type.Object({ id: Type.String(), confirm: Type.Boolean() }),
-            async execute(_toolCallId, params) {
+            parameters: Type.Object({ id: Type.String(), confirm: Type.Boolean() }, { additionalProperties: false }),
+            executionMode: "sequential",
+            async execute(_toolCallId, rawParams, signal) {
+                const params = forgetParameters(rawParams);
+                const operationSignal = signal === undefined ? lifecycle.signal : AbortSignal.any([signal, lifecycle.signal]);
+                throwIfAborted(operationSignal);
                 const id = normalizeText(params.id, "Graph memory node id", maxLabelLength);
                 if (params.confirm !== true)
                     throw new Error("Deleting a graph memory requires confirm=true");
@@ -327,7 +612,7 @@ export default {
                     state.nodes = state.nodes.filter((node) => node.id !== id);
                     state.relations = state.relations.filter((relation) => relation.from !== id && relation.to !== id);
                     return { id, removed: state.nodes.length !== beforeNodes, removedRelations: beforeRelations - state.relations.length };
-                });
+                }, operationSignal);
                 return {
                     content: [{ type: "text", text: result.removed ? `Graph memory deleted: ${id}` : `Graph memory not found: ${id}` }],
                     details: result,
@@ -357,13 +642,14 @@ export default {
                             skill: nodes.filter((node) => node.kind === "skill").length,
                             event: nodes.filter((node) => node.kind === "event").length,
                         },
-                        recent: nodes.slice(0, 8),
+                        recent: nodes.slice(0, 8).map(cloneNode),
                         recentRelations: relations.slice(0, 8).map((relation) => ({
                             ...relation,
                             fromLabel: nodes.find((node) => node.id === relation.from)?.label ?? relation.from,
                             toLabel: nodes.find((node) => node.id === relation.to)?.label ?? relation.to,
                         })),
-                        lastSearch: lastSearch ?? null,
+                        lastSearch: lastSearch === undefined ? null : cloneSearchReport(lastSearch),
+                        limits: { nodes: nodeLimit, relations: relationLimit, fileBytes: maxFileBytes, searchResults: maxSearchResults },
                     };
                 },
             }));
@@ -374,6 +660,7 @@ export default {
             throw error;
         }
         context.effect(() => () => {
+            lifecycle.abort(new Error("Graph memory plugin disposed"));
             for (const dispose of disposers.reverse())
                 dispose();
         });