@remnic/core 10.0.75 → 10.0.76

package/dist/{chunk-URS56HGW.js → chunk-TD5VTVPT.js}

@@ -1,7 +1,7 @@
 import {
   ExtractionDrain,
   TurnIngestionCoordinator
-} from "./chunk-VYOAYFDV.js";
+} from "./chunk-HR6NTVYZ.js";
 import {
   headerConnector,
   renderExtractionConversation,
@@ -440,4 +440,4 @@ export {
   ClaimBufferStorage,
   BufferDrainRunner
 };
-//# sourceMappingURL=chunk-URS56HGW.js.map
+//# sourceMappingURL=chunk-TD5VTVPT.js.map

package/dist/index.js

@@ -181,7 +181,7 @@ import {
   writeManifest,
   writeMeetingEpisodeMemory,
   writeTimelineState
-} from "./chunk-VYOAYFDV.js";
+} from "./chunk-HR6NTVYZ.js";
 import {
   WEARABLE_SOURCE_PREFIX,
   buildExtractionTurns,

package/dist/orchestration/backlog-scheduler.js

@@ -1,7 +1,7 @@
 import {
   BufferDrainRunner
-} from "../chunk-URS56HGW.js";
-import "../chunk-VYOAYFDV.js";
+} from "../chunk-TD5VTVPT.js";
+import "../chunk-HR6NTVYZ.js";
 import "../chunk-B36ACJG7.js";
 import "../chunk-PLGBPFEO.js";
 import "../chunk-5PHOU5QI.js";

package/dist/orchestration/buffer-drain-runner.js

@@ -1,8 +1,8 @@
 import {
   BufferDrainRunner,
   ClaimBufferStorage
-} from "../chunk-URS56HGW.js";
-import "../chunk-VYOAYFDV.js";
+} from "../chunk-TD5VTVPT.js";
+import "../chunk-HR6NTVYZ.js";
 import "../chunk-B36ACJG7.js";
 import "../chunk-PLGBPFEO.js";
 import "../chunk-5PHOU5QI.js";

package/dist/orchestration/extraction-queue-coordinator.d.ts

@@ -82,15 +82,10 @@ export declare class ExtractionQueueCoordinator {
     /** How many tasks may run at once (test seam + diagnostics). */
     get maxConcurrency(): number;
     /**
-     * Enqueue a task and start the processor when capacity is free. This is
-     * the production entry point — the orchestrator's `queueBufferedExtraction`
-     * builds each task closure and hands it here with its buffer key.
-     *
-     * Per-key coalescing: a queued-not-started task for key K is superseded by
-     * a newer enqueue for K instead of stacking another full turn snapshot
-     * behind it (extraction reads live state at run time, so the newest
-     * closure is the authoritative one). Keyless tasks are independent work
-     * and never coalesce.
+     * Enqueue a task and start the processor when capacity is free. Each task
+     * keeps its own captured work and settlement; keyed tasks serialize behind
+     * other tasks for that key. A front task may jump the queue but does not
+     * discard queued work.
      */
     enqueue(task: ExtractionQueueTask, options?: ExtractionQueueEnqueueOptions): boolean;
     /**

package/dist/orchestration/extraction-queue-coordinator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extraction-queue-coordinator.d.ts","sourceRoot":"","sources":["../../src/orchestration/extraction-queue-coordinator.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"extraction-queue-coordinator.d.ts","sourceRoot":"","sources":["../../src/orchestration/extraction-queue-coordinator.ts"],"names":[],"mappings":"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"}

package/dist/orchestrator.js

@@ -4,7 +4,7 @@ import {
   graphPathRelativeToStorage,
   mergeGraphExpandedResults,
   qmdStartupCollectionChecksWithTimeout
-} from "./chunk-VYOAYFDV.js";
+} from "./chunk-HR6NTVYZ.js";
 import "./chunk-B36ACJG7.js";
 import "./chunk-PLGBPFEO.js";
 import {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "10.0.75",
+  "version": "10.0.76",
   "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.75"
+    "@remnic/coding-graph": "^10.0.76"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/orchestration/extraction-queue-coordinator.ts

@@ -112,29 +112,14 @@ export class ExtractionQueueCoordinator {
   }
 
   /**
-   * Enqueue a task and start the processor when capacity is free. This is
-   * the production entry point — the orchestrator's `queueBufferedExtraction`
-   * builds each task closure and hands it here with its buffer key.
-   *
-   * Per-key coalescing: a queued-not-started task for key K is superseded by
-   * a newer enqueue for K instead of stacking another full turn snapshot
-   * behind it (extraction reads live state at run time, so the newest
-   * closure is the authoritative one). Keyless tasks are independent work
-   * and never coalesce.
+   * Enqueue a task and start the processor when capacity is free. Each task
+   * keeps its own captured work and settlement; keyed tasks serialize behind
+   * other tasks for that key. A front task may jump the queue but does not
+   * discard queued work.
    */
   enqueue(task: ExtractionQueueTask, options?: ExtractionQueueEnqueueOptions): boolean {
     if (!this.accepting) return false;
     const key = options?.key;
-    if (key !== undefined) {
-      const queuedAt = this.queue.findIndex((entry) => entry.key === key);
-      if (!options?.front && queuedAt >= 0) {
-        this.queue[queuedAt] = { run: task, key };
-        return true;
-      }
-      if (options?.front && queuedAt >= 0) {
-        this.queue.splice(queuedAt, 1);
-      }
-    }
     const entry: QueueEntry = { run: task, key };
     if (options?.front) {
       this.preemptRunning(options.key);

package/src/orchestrator-extraction-queue.test.ts

@@ -1,10 +1,13 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
+import { queueBufferedCaptureScopeGroups } from "./orchestration/extraction-task-queueing.js";
 import { ExtractionQueueCoordinator, type ExtractionPreemptHandle, type ExtractionQueueTask } from "./orchestration/extraction-queue-coordinator.js";
 import { initLogger, type LoggerBackend } from "./logger.js";
 import { abortError } from "./abort-error.js";
 
+import type { BufferTurn } from "./types.js";
+
 interface LogEntry {
   level: "info" | "warn" | "error" | "debug";
   message: string;
@@ -35,10 +38,9 @@ function createCoordinator(): ExtractionQueueCoordinator {
   return new ExtractionQueueCoordinator();
 }
 
-// ── Per-key coalescing: a queued-not-started task is superseded by a newer
-// enqueue for the same key instead of stacking another full snapshot ────────
+// ── Per-key FIFO: queued tasks retain their own captured scope and settlement ─
 
-test("a newer enqueue for a queued-not-started key replaces the queued task", async () => {
+test("same-key queued tasks both run in FIFO order", async () => {
   const coordinator = createCoordinator();
   const busy = Promise.withResolvers<void>();
   const releaseBusy = Promise.withResolvers<void>();
@@ -56,15 +58,15 @@ test("a newer enqueue for a queued-not-started key replaces the queued task", as
     ran.push("fresh");
   }, { key: "s1" });
 
-  assert.equal(coordinator.length, 1, "the stale snapshot must be replaced, not stacked");
+  assert.equal(coordinator.length, 2, "same-key tasks remain queued independently");
 
   releaseBusy.resolve();
   assert.equal(await coordinator.waitForIdle(5_000), true);
-  assert.deepEqual(ran, ["fresh"], "only the newest task for the key runs");
+  assert.deepEqual(ran, ["stale", "fresh"], "each caller's task runs in FIFO order");
   assert.equal(coordinator.isProcessing, false);
 });
 
-test("coalescing keeps the superseded entry's position for other keys", async () => {
+test("same-key tasks keep their FIFO positions relative to other keys", async () => {
   const coordinator = createCoordinator();
   const busy = Promise.withResolvers<void>();
   const releaseBusy = Promise.withResolvers<void>();
@@ -90,10 +92,10 @@ test("coalescing keeps the superseded entry's position for other keys", async ()
 
   releaseBusy.resolve();
   assert.equal(await coordinator.waitForIdle(5_000), true);
-  assert.deepEqual(ran, ["k1", "k2-fresh", "k3"], "k2 keeps its queue slot; the newest payload wins");
+  assert.deepEqual(ran, ["k1", "k2-stale", "k2-fresh", "k3"]);
 });
 
-test("a front enqueue supersedes a queued same-key task and keeps preemption", async () => {
+test("a front enqueue preserves queued same-key work and keeps preemption", async () => {
   const coordinator = createCoordinator();
   const busy = Promise.withResolvers<void>();
   const releaseBusy = Promise.withResolvers<void>();
@@ -121,15 +123,15 @@ test("a front enqueue supersedes a queued same-key task and keeps preemption", a
     ran.push("flush-fresh");
   }, { key: "s1", front: true });
 
-  assert.equal(coordinator.length, 1, "the superseded queued task must be dropped");
+  assert.equal(coordinator.length, 2, "front work does not discard queued same-key work");
 
   releaseBusy.resolve();
   assert.equal(await coordinator.waitForIdle(5_000), true);
   assert.equal(preempted, true, "front enqueue still preempts the running automatic work");
-  assert.deepEqual(ran, ["flush-fresh"]);
+  assert.deepEqual(ran, ["flush-fresh", "queued-stale"]);
 });
 
-test("keyless tasks never coalesce", async () => {
+test("keyless tasks remain independent", async () => {
   const coordinator = createCoordinator();
   const busy = Promise.withResolvers<void>();
   const releaseBusy = Promise.withResolvers<void>();
@@ -153,7 +155,7 @@ test("keyless tasks never coalesce", async () => {
   assert.deepEqual(ran, ["first", "second"]);
 });
 
-test("a coalesced enqueue of a running key waits behind the active task", async () => {
+test("same-key enqueues behind an active task retain both queued tasks in FIFO order", async () => {
   const coordinator = createCoordinator();
   const busy = Promise.withResolvers<void>();
   const releaseBusy = Promise.withResolvers<void>();
@@ -174,7 +176,7 @@ test("a coalesced enqueue of a running key waits behind the active task", async
 
   releaseBusy.resolve();
   assert.equal(await coordinator.waitForIdle(5_000), true);
-  assert.deepEqual(order, ["running", "queued-second"]);
+  assert.deepEqual(order, ["running", "queued-first", "queued-second"]);
 });
 
 // ── Issue #549 ─────────────────────────────────────────────────────────────
@@ -627,3 +629,58 @@ test("tryReserveKey refuses active and queued keys, and releases idempotently",
   assert.equal(queue.tryReserveKey("s1"), true, "a settled key reserves again");
   queue.releaseKeyReservation("s1");
 });
+
+test("same-key capture scope groups both run and settle their caller promises", async () => {
+  const coordinator = createCoordinator();
+  const busy = Promise.withResolvers<void>();
+  const releaseBusy = Promise.withResolvers<void>();
+  const ran: string[] = [];
+  const extractions: Promise<void>[] = [];
+
+  coordinator.enqueue(async () => {
+    busy.resolve();
+    await releaseBusy.promise;
+  });
+  await busy.promise;
+
+  const acceptedTurns: BufferTurn[] = [
+    {
+      role: "user",
+      content: "scope A",
+      timestamp: "2026-11-05T00:00:00.000Z",
+      sessionKey: "s1",
+      acceptedCapture: true,
+      writeNamespaceOverride: "namespace-a",
+      principalOverride: "principal-a",
+    },
+    {
+      role: "user",
+      content: "scope B",
+      timestamp: "2026-11-05T00:00:01.000Z",
+      sessionKey: "s1",
+      acceptedCapture: true,
+      writeNamespaceOverride: "namespace-b",
+      principalOverride: "principal-b",
+    },
+  ];
+  queueBufferedCaptureScopeGroups(
+    async (_turns, _reason, options) => {
+      const accepted = coordinator.enqueue(async () => {
+        const namespace = options?.writeNamespaceOverride;
+        assert.ok(namespace);
+        ran.push(namespace);
+        options?.onTaskSettled?.();
+      }, { key: options?.bufferKey });
+      if (!accepted) throw new Error("queue unexpectedly rejected extraction");
+    },
+    acceptedTurns,
+    "s1",
+    { onExtractionQueued: (promise) => extractions.push(promise) },
+  );
+
+  assert.equal(extractions.length, 2, "each captured scope has its own completion promise");
+  releaseBusy.resolve();
+  assert.equal(await coordinator.waitForIdle(5_000), true);
+  await Promise.all(extractions);
+  assert.deepEqual(ran, ["namespace-a", "namespace-b"]);
+});