@remnic/core 10.0.60 → 10.0.62

package/src/storage.ts

@@ -144,6 +144,7 @@ import {
 } from "./lifecycle/tombstones.js";
 import { supersessionKeysForFact } from "./temporal-supersession.js";
 import { BufferSessionFiles } from "./storage/buffer-session-files.js";
+import { BufferDrainClaims, type BufferSessionSaveOutcome } from "./storage/buffer-drain-claims.js";
 import { runSupersessionSideEffects, type SupersessionAuditOptions } from "./storage/supersession-side-effects.js";
 import { saveDroppedExtractionChunk as saveDroppedChunk } from "./storage/dropped-extraction-chunk.js";
 import type {
@@ -5144,18 +5145,10 @@ export class StorageManager extends TombstoneBlockedCaptureIndexHost {
             );
           } catch (err) {
             if (priorDest === null) {
-              await recordArchiveDelete(this.baseDir, destPath, () =>
-                unlink(destPath).then(
-                  () => true,
-                  () => false
-                )
-              );
+              await recordArchiveDelete(this.baseDir, destPath, () => unlink(destPath).then(() => true, () => false));
             } else {
               await recordArchiveDelete(this.baseDir, destPath, () =>
-                this.writeStorageSecureFile(destPath, priorDest).then(
-                  () => true,
-                  () => false
-                )
+                this.writeStorageSecureFile(destPath, priorDest).then(() => true, () => false)
               );
             }
             throw err;
@@ -5524,8 +5517,12 @@ export class StorageManager extends TombstoneBlockedCaptureIndexHost {
   }
   async loadBuffer(): Promise<BufferState> { return this.bufferSessionFiles().load(); }
   async saveBuffer(state: BufferState): Promise<void> { await this.bufferSessionFiles().reconcile(state); }
-  async saveBufferSession(key: string, entry: BufferEntryState): Promise<void> { await this.bufferSessionFiles().save(key, entry); }
+  async saveBufferSession(key: string, entry: BufferEntryState): Promise<BufferSessionSaveOutcome> { return await this.bufferSessionFiles().save(key, entry); }
   async deleteBufferSession(key: string): Promise<void> { await this.bufferSessionFiles().remove(key); }
+  /** Sync gate check for the extraction queue: is this session claimed by a buffer drain? */
+  isBufferSessionClaimed(key: string): boolean { return this.bufferSessionFiles().isClaimed(key); }
+  /** The drain-claim store for this memory root (CLI drain + worker). */
+  bufferDrainClaims(): BufferDrainClaims { return this.bufferSessionFiles().claims; }
   saveDroppedExtractionChunk(bufferKey: string, reason: string, turns: readonly import("./types.js").BufferTurn[]): Promise<string> { // storage/dropped-extraction-chunk.ts
     return saveDroppedChunk(this.stateDir, (file, content) => this.writeStorageSecureFile(file, content), bufferKey, reason, turns);
   }

package/src/testing/subjects/extraction-lifecycle.test.ts

@@ -17,6 +17,7 @@ import assert from "node:assert/strict";
 import path from "node:path";
 
 import { Orchestrator } from "../../orchestrator.js";
+import { BufferDrainRunner } from "../../orchestration/buffer-drain-runner.js";
 import { resolveNamespaceStorageRoot } from "../../namespaces/storage.js";
 import type { BufferTurn, PluginConfig } from "../../types.js";
 import {
@@ -135,6 +136,37 @@ async function assertHarmonicEpisode(memoryDir: string, sessionKey?: string): Pr
   if (sessionKey) assert.equal(status.latestNode?.sessionKey, sessionKey);
 }
 
+
+/**
+ * The out-of-process drain path: a buffered session is claimed into a drain
+ * claim, the drain extracts it through the same pipeline, and the claim ends
+ * empty. The live buffer keeps its in-memory copy; the drain tombstone makes
+ * the owner subtract the drained turn instead of writing it back.
+ */
+async function exerciseBufferDrain(state: ExtractionLifecycleState): Promise<void> {
+  // Its own memory root and orchestrator: the drain must not perturb the
+  // row's own extraction calls or fact counts.
+  const memoryDir = await mkTempMemoryDir("extraction-drain-row");
+  const cfg = makeHarmonicLifecycleConfig(memoryDir, { extraction: { spanMode: "on" } });
+  const orchestrator = new Orchestrator(cfg);
+  state.orchestrators.push(orchestrator);
+  stubExtraction(orchestrator, (turns) => spanBearingResult(turns));
+  const sessionKey = "drain-row-session";
+  const content = "The drain row retains the canary gate detail for the teal dashboard.";
+  await orchestrator.buffer.addTurn(sessionKey, {
+    role: "user",
+    content,
+    timestamp: new Date().toISOString(),
+    sessionKey,
+  });
+  await orchestrator.buffer.save();
+  const runner = new BufferDrainRunner(orchestrator);
+  assert.equal(await runner.claim(sessionKey, "subject-drain"), true, "the drain claims the buffered session");
+  const outcome = await runner.drainSession(sessionKey, { ownerId: "subject-drain" });
+  assert.equal(outcome.status, "drained", "the drain empties the claimed session");
+  assert.equal(outcome.turnsRemaining, 0, "no turn is left claimed");
+}
+
 const subject: LifecycleSubject<ExtractionLifecycleState> = {
   async setup(row: MatrixRow): Promise<ExtractionLifecycleState> {
     const memoryDir = await mkTempMemoryDir(`extraction-${row.id}`);
@@ -254,6 +286,7 @@ const subject: LifecycleSubject<ExtractionLifecycleState> = {
         return;
       }
       case "before-reset": {
+        await exerciseBufferDrain(state);
         // Buffer a low-signal turn, then fire a before_reset flush whose abort
         // trips mid-extraction. The abort wiring (the signal threaded from
         // flushSession into runExtraction, guarding `before_persist` and
@@ -419,6 +452,7 @@ const subject: LifecycleSubject<ExtractionLifecycleState> = {
         return;
       }
       case "before-reset": {
+        await exerciseBufferDrain(state);
         assert.equal(
           state.abortFlushRejected,
           true,

package/src/types.ts

@@ -719,6 +719,8 @@ export interface PluginConfig
   reasoningEffort: ReasoningEffort;
   triggerMode: TriggerMode;
   bufferMaxTurns: number;
+  /** Distinct sessions the extraction buffer admits before backpressure (#3303). */
+  bufferMaxSessions: number;
   bufferMaxMinutes: number;
   /**
    * Debounce window (ms) for persisting the smart buffer to `state/buffer.json`