@remnic/core 10.0.76 → 10.0.78

package/dist/transfer/capsule-export.js

@@ -1,10 +1,10 @@
 import {
   exportCapsule,
   isValidCapsuleSince
-} from "../chunk-KQAFEZQX.js";
-import "../chunk-WEHSQBFR.js";
-import "../chunk-X7Y7WX73.js";
+} from "../chunk-R45L4TV6.js";
 import "../chunk-J4EB7DNW.js";
+import "../chunk-WEHSQBFR.js";
+import "../chunk-DQEMWVMT.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";
 import "../chunk-FP2373TW.js";

package/dist/transfer/capsule-import.js

@@ -1,6 +1,6 @@
 import {
   importCapsule
-} from "../chunk-2R7OCBRR.js";
+} from "../chunk-YK7GOPIE.js";
 import "../chunk-ER7XANP3.js";
 import "../chunk-M5GVCJSJ.js";
 import "../chunk-RBOJCG4T.js";
@@ -11,7 +11,7 @@ import "../chunk-7CT3AI52.js";
 import "../chunk-C64XATK7.js";
 import "../chunk-42JKGUFJ.js";
 import "../chunk-WEHSQBFR.js";
-import "../chunk-X7Y7WX73.js";
+import "../chunk-DQEMWVMT.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";
 import "../chunk-FP2373TW.js";

package/dist/transfer/export-okf.js

@@ -4,28 +4,28 @@ import {
   exportOkfBundle,
   firstHeading,
   parseIncludeStatus
-} from "../chunk-I4LJJ44E.js";
+} from "../chunk-LNHBYT3F.js";
 import {
   OKF_EXPORT_VERSION
 } from "../chunk-I7TR2OCU.js";
 import "../chunk-D24OXEPB.js";
 import "../chunk-3UXOZBHV.js";
-import "../chunk-5IQL4N37.js";
+import "../chunk-D4WBMLPD.js";
 import "../chunk-UHVXE24Y.js";
 import "../chunk-QGVCFVX6.js";
 import "../chunk-IGOW4TJE.js";
 import "../chunk-G6OFEGUR.js";
 import "../chunk-7PMOCQOL.js";
-import "../chunk-SHVLNI4L.js";
-import "../chunk-OBQ2NZAR.js";
+import "../chunk-LU66I56Q.js";
+import "../chunk-VKDAJJQP.js";
 import "../chunk-OVZIYLBZ.js";
 import "../chunk-EXYT52NR.js";
-import "../chunk-YK6SFDP2.js";
-import "../chunk-P3AQ2YSX.js";
+import "../chunk-DOJBV6WR.js";
+import "../chunk-PFUXPTBT.js";
 import "../chunk-CYEPCZN5.js";
-import "../chunk-FYQUUIPI.js";
-import "../chunk-Y5NLBXPV.js";
+import "../chunk-DLZGSZVC.js";
 import "../chunk-WNEVEMJ3.js";
+import "../chunk-Y5NLBXPV.js";
 import "../chunk-TFA6HPOA.js";
 import "../chunk-F4TWWUMP.js";
 import "../chunk-72A4L5JJ.js";

package/dist/verified-recall.js

@@ -1,24 +1,24 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-GCJA5KKT.js";
+} from "./chunk-XBNO56HC.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-5IQL4N37.js";
+import "./chunk-D4WBMLPD.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-QGVCFVX6.js";
 import "./chunk-IGOW4TJE.js";
 import "./chunk-G6OFEGUR.js";
 import "./chunk-7PMOCQOL.js";
-import "./chunk-SHVLNI4L.js";
-import "./chunk-OBQ2NZAR.js";
+import "./chunk-LU66I56Q.js";
+import "./chunk-VKDAJJQP.js";
 import "./chunk-OVZIYLBZ.js";
 import "./chunk-EXYT52NR.js";
-import "./chunk-YK6SFDP2.js";
-import "./chunk-P3AQ2YSX.js";
+import "./chunk-DOJBV6WR.js";
+import "./chunk-PFUXPTBT.js";
 import "./chunk-CYEPCZN5.js";
-import "./chunk-FYQUUIPI.js";
-import "./chunk-Y5NLBXPV.js";
+import "./chunk-DLZGSZVC.js";
 import "./chunk-WNEVEMJ3.js";
+import "./chunk-Y5NLBXPV.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";

package/dist/who-knows-cli.js

@@ -4,24 +4,24 @@ import {
   renderWhoKnows,
   renderWhoKnowsJson,
   renderWhoKnowsText
-} from "./chunk-6RPPZL7W.js";
-import "./chunk-ELUG6NKQ.js";
-import "./chunk-5IQL4N37.js";
+} from "./chunk-SMSJOWVE.js";
+import "./chunk-YSA4CYTK.js";
+import "./chunk-D4WBMLPD.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-QGVCFVX6.js";
 import "./chunk-IGOW4TJE.js";
 import "./chunk-G6OFEGUR.js";
 import "./chunk-7PMOCQOL.js";
-import "./chunk-SHVLNI4L.js";
-import "./chunk-OBQ2NZAR.js";
+import "./chunk-LU66I56Q.js";
+import "./chunk-VKDAJJQP.js";
 import "./chunk-OVZIYLBZ.js";
 import "./chunk-EXYT52NR.js";
-import "./chunk-YK6SFDP2.js";
-import "./chunk-P3AQ2YSX.js";
+import "./chunk-DOJBV6WR.js";
+import "./chunk-PFUXPTBT.js";
 import "./chunk-CYEPCZN5.js";
-import "./chunk-FYQUUIPI.js";
-import "./chunk-Y5NLBXPV.js";
+import "./chunk-DLZGSZVC.js";
 import "./chunk-WNEVEMJ3.js";
+import "./chunk-Y5NLBXPV.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";

package/dist/who-knows.js

@@ -9,23 +9,23 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-ELUG6NKQ.js";
-import "./chunk-5IQL4N37.js";
+} from "./chunk-YSA4CYTK.js";
+import "./chunk-D4WBMLPD.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-QGVCFVX6.js";
 import "./chunk-IGOW4TJE.js";
 import "./chunk-G6OFEGUR.js";
 import "./chunk-7PMOCQOL.js";
-import "./chunk-SHVLNI4L.js";
-import "./chunk-OBQ2NZAR.js";
+import "./chunk-LU66I56Q.js";
+import "./chunk-VKDAJJQP.js";
 import "./chunk-OVZIYLBZ.js";
 import "./chunk-EXYT52NR.js";
-import "./chunk-YK6SFDP2.js";
-import "./chunk-P3AQ2YSX.js";
+import "./chunk-DOJBV6WR.js";
+import "./chunk-PFUXPTBT.js";
 import "./chunk-CYEPCZN5.js";
-import "./chunk-FYQUUIPI.js";
-import "./chunk-Y5NLBXPV.js";
+import "./chunk-DLZGSZVC.js";
 import "./chunk-WNEVEMJ3.js";
+import "./chunk-Y5NLBXPV.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "10.0.76",
+  "version": "10.0.78",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3386,7 +3386,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^10.0.76"
+    "@remnic/coding-graph": "^10.0.78"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-observe-helpers.test.ts

@@ -1,4 +1,6 @@
 import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
 /**
  * PendingObserveExtractionTracker settle hygiene — issue: `track`'s settle
  * callback only removed the pending entry when the extraction SUCCEEDED or
@@ -70,3 +72,157 @@ test("a wait overlapping a failing extraction still surfaces the error", async (
   reject(new Error("extraction failed"));
   await waiter;
 });
+
+/**
+ * Controller retention — issue: `track` copied every prior controller of the
+ * key into a fresh Set per tracked extraction, and never-settling promise
+ * chains keep every generation reachable, so overlapping stalled tracks grew
+ * quadratically (HeapRepro: ~543MB at 6000 tracks; measured 212.8MB at 4000
+ * pre-fix vs 4.2MB with the shared per-key set). The fix reuses one Set per
+ * key; `abortTracked` iterates a snapshot so a reentrant `track` fired from
+ * an abort listener keeps prior semantics (not aborted by the in-flight
+ * pass, iteration terminates).
+ */
+function stalled(): Promise<void> {
+  const { promise } = Promise.withResolvers<void>();
+  return promise;
+}
+
+function rejectingAfter(controller: AbortController): Promise<void> {
+  const { promise, reject } = Promise.withResolvers<void>();
+  controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
+  return promise;
+}
+
+// Runs the retention loop in one short-lived child process with --expose-gc,
+// so CI exercises it without exposing gc to the whole test tree. The
+// assertion keeps a wide margin (4.2MB measured post-fix vs 212.8MB pre-fix
+// at the same track count), not a fixed runner heap limit.
+function drain(stream: NodeJS.ReadableStream): Promise<string> {
+  return new Promise((resolve) => {
+    const chunks: string[] = [];
+    stream.on("data", (chunk) => chunks.push(String(chunk)));
+    stream.on("end", () => resolve(chunks.join("")));
+  });
+}
+
+async function retainedHeapInChild(): Promise<number> {
+  const trackerSource = fileURLToPath(new URL("./access-observe-helpers.js", import.meta.url));
+  const child = spawn(
+    process.execPath,
+    [
+      "--expose-gc",
+      "--input-type=module",
+      "--import",
+      "tsx",
+      "-e",
+      `import { pathToFileURL } from "node:url";
+const { PendingObserveExtractionTracker } = await import(pathToFileURL(process.argv.at(-1)));
+gc();
+const before = process.memoryUsage().heapUsed;
+const tracker = new PendingObserveExtractionTracker();
+const key = tracker.key("session-a", "alice", "default");
+for (let i = 0; i < 4000; i++) tracker.track(key, new Promise(() => {}), new AbortController());
+gc();
+console.log(JSON.stringify(process.memoryUsage().heapUsed - before));`,
+      trackerSource,
+    ],
+    { cwd: fileURLToPath(new URL("..", import.meta.url)), stdio: ["ignore", "pipe", "pipe"] },
+  );
+  const [stdout, stderr, code] = await Promise.all([
+    drain(child.stdout),
+    drain(child.stderr),
+    new Promise<number | null>((resolve) => child.on("close", resolve)),
+  ]);
+  assert.equal(code, 0, `retention child failed (${code}): ${stderr.slice(0, 400)}`);
+  const lastLine = stdout.trim().split("\n").at(-1);
+  assert.ok(lastLine !== undefined, `retention child printed no output: ${stderr.slice(0, 400)}`);
+  return JSON.parse(lastLine);
+}
+
+test("retained heap stays bounded across overlapping stalled tracks", { timeout: 15000 }, async () => {
+  const retained = await retainedHeapInChild();
+  assert.ok(
+    retained < 32 * 1024 * 1024,
+    `retained ${(retained / 1048576).toFixed(1)}MB for 4000 tracks; quadratic controller-set copies keep dead generations alive`,
+  );
+});
+
+test("cancel still aborts every distinct controller across overlapping tracks", () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const key = tracker.key("session-a", "alice", "default");
+  const controllers = Array.from({ length: 50 }, () => new AbortController());
+  for (const controller of controllers) {
+    tracker.track(key, stalled(), controller);
+  }
+  tracker.cancel("session-a", "alice", "default");
+  for (const controller of controllers) {
+    assert.ok(controller.signal.aborted, "every tracked controller must be aborted");
+  }
+});
+
+test("a controller admitted by a reentrant track during cancel is not aborted by that pass", () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const key = tracker.key("session-a", "alice", "default");
+  const first = new AbortController();
+  const reentrant = new AbortController();
+  first.signal.addEventListener(
+    "abort",
+    () => {
+      tracker.track(key, stalled(), reentrant);
+    },
+    { once: true },
+  );
+  tracker.track(key, stalled(), first);
+  tracker.cancel("session-a", "alice", "default");
+  assert.ok(first.signal.aborted);
+  assert.equal(reentrant.signal.aborted, false, "prior behavior: the in-flight abort pass must not abort later admissions");
+});
+
+test("each key aborts and cleans up in isolation", { timeout: 2000 }, async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const keyA = tracker.key("session-a", "alice", "default");
+  const keyB = tracker.key("session-b", "bob", "default");
+  const controllerA = new AbortController();
+  const controllerB = new AbortController();
+  tracker.track(keyA, rejectingAfter(controllerA), controllerA);
+  tracker.track(keyB, stalled(), controllerB);
+  tracker.cancel("session-a", "alice", "default");
+  assert.ok(controllerA.signal.aborted);
+  assert.equal(controllerB.signal.aborted, false);
+  await settle();
+  await tracker.wait("session-a", "alice", "default");
+});
+
+test("an aborted chain entry settles once every generation settles and cleans up", { timeout: 2000 }, async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const key = tracker.key("session-a", "alice", "default");
+  const first = new AbortController();
+  tracker.track(key, rejectingAfter(first), first);
+  const second = new AbortController();
+  const { promise: secondExtraction, resolve } = Promise.withResolvers<void>();
+  tracker.track(key, secondExtraction, second);
+  first.abort(preemptedExtractionError());
+  resolve();
+  await settle();
+  await tracker.wait("session-a", "alice", "default");
+});
+
+test("wait surfaces a chained non-preempted rejection", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const key = tracker.key("session-a", "alice", "default");
+  tracker.track(key, Promise.resolve(), new AbortController());
+  tracker.track(key, Promise.reject(new Error("extraction failed")), new AbortController());
+  await assert.rejects(tracker.wait("session-a", "alice", "default"), /extraction failed/);
+});
+
+test("a wait overlapping a preempted rejection returns without throwing", { timeout: 2000 }, async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const key = tracker.key("session-a", "alice", "default");
+  const controller = new AbortController();
+  tracker.track(key, rejectingAfter(controller), controller);
+  const waiter = tracker.wait("session-a", "alice", "default");
+  await Promise.resolve();
+  controller.abort(preemptedExtractionError());
+  await waiter;
+});

package/src/access-observe-helpers.ts

@@ -142,11 +142,9 @@ export class PendingObserveExtractionTracker {
           if (rejected) throw rejected.reason;
         })
       : extraction;
-    const entry = {
-      promise,
-      running: previous?.running ?? extraction,
-      controllers: new Set(previous ? [...previous.controllers, controller] : [controller]),
-    };
+    const controllers = previous?.controllers ?? new Set<AbortController>();
+    controllers.add(controller);
+    const entry = { promise, running: previous?.running ?? extraction, controllers };
     this.entries.set(key, entry);
     // Any settle (success OR rejection — preemption is just one rejection
     // kind) ends the pending entry; leaving a settled failure tracked wedged
@@ -201,7 +199,9 @@ export class PendingObserveExtractionTracker {
         (principal !== undefined && entryPrincipal !== (principal ?? "")) ||
         (namespace !== undefined && entryNamespace !== (namespace ?? ""))
       ) continue;
-      for (const controller of entry.controllers) controller.abort(reason);
+      // Snapshot: an abort listener may track() synchronously; iterating the
+      // shared live set would abort that new admission or never terminate.
+      for (const controller of [...entry.controllers]) controller.abort(reason);
     }
   }
 

package/src/local-llm-qos.test.ts

@@ -337,3 +337,62 @@ test("LocalLlmClient resolves queued work to null when request execution throws"
 
   assert.equal(result, null);
 });
+
+test("LocalLlmClient includes queue wait in the exhausted-abort warning", async () => {
+  const logs: string[] = [];
+  initLogger(
+    {
+      info(msg: string) {
+        logs.push(`info:${msg}`);
+      },
+      warn(msg: string) {
+        logs.push(`warn:${msg}`);
+      },
+      error(msg: string) {
+        logs.push(`error:${msg}`);
+      },
+      debug(msg: string) {
+        logs.push(`debug:${msg}`);
+      },
+    },
+    true,
+  );
+
+  const originalNow = Date.now;
+  let now = originalNow();
+  Date.now = () => now;
+  const client = new LocalLlmClient(createConfig());
+  client["isAvailable"] = true;
+  client["lastHealthCheck"] = Date.now();
+  const originalFetch = globalThis.fetch;
+  const holderResponse = Promise.withResolvers<Response>();
+  let calls = 0;
+  globalThis.fetch = async () => {
+    calls += 1;
+    if (calls === 1) return await holderResponse.promise;
+    throw new DOMException("request aborted", "AbortError");
+  };
+
+  try {
+    const holder = client.chatCompletion(
+      [{ role: "user", content: "hold" }],
+      { operation: "queue-holder", priority: "background" },
+    );
+    await tick();
+    const summarize = client.chatCompletion(
+      [{ role: "user", content: "summarize" }],
+      { operation: "lcm-summarize", priority: "background" },
+    );
+    now += 50;
+    holderResponse.resolve(okResponse("held"));
+    await holder;
+    assert.equal(await summarize, null);
+    assert.match(
+      logs.join("\n"),
+      /local LLM request aborted after \d+ attempt\(s\): op=lcm-summarize timeoutMs=\d+ model=test-local-model promptChars=\d+ durationMs=\d+ waitMs=50/,
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    Date.now = originalNow;
+  }
+});

package/src/local-llm.ts

@@ -1093,7 +1093,7 @@ export class LocalLlmClient {
       if (!response) {
         if (lastAbortError) {
           log.warn(
-            `local LLM request aborted after ${maxAttempts} attempt(s): op=${operation} timeoutMs=${effectiveTimeoutMs} model=${this.config.localLlmModel} promptChars=${promptChars} durationMs=${Date.now() - startedAtMs}`,
+            `local LLM request aborted after ${maxAttempts} attempt(s): op=${operation} timeoutMs=${effectiveTimeoutMs} model=${this.config.localLlmModel} promptChars=${promptChars} durationMs=${Date.now() - startedAtMs}${queueMeta ? ` waitMs=${startedAtMs - queueMeta.enqueuedAtMs}` : ""}`,
           );
         } else {
           log.warn(