@remnic/core 9.7.14 → 9.8.0

package/dist/{chunk-KSBEEMQF.js → chunk-TG6IHVE2.js}

@@ -3,13 +3,15 @@ import {
 } from "./chunk-H3FZVNRN.js";
 import {
   resolvePresentationCapabilities
-} from "./chunk-BFPETA3S.js";
+} from "./chunk-SCCO46KZ.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/buffer.ts
 var MAX_BUFFER_ENTRY_COUNT = 200;
+var BUFFER_SAVE_MAX_DEFER_MULTIPLIER = 5;
+var MAX_SET_TIMEOUT_MS = 2147483647;
 var SmartBuffer = class {
   constructor(config, storage, surpriseProbe = null) {
     this.config = config;
@@ -39,6 +41,19 @@ var SmartBuffer = class {
    * poison the chain (CLAUDE.md rule #40).
    */
   surpriseTelemetryWriteChain = Promise.resolve();
+  /**
+   * Debounced buffer-save state (issue #1909). Steady-state buffering used to
+   * serialize + rewrite the whole multi-session buffer on EVERY turn. We now
+   * coalesce those writes onto a trailing-edge timer; correctness boundaries
+   * (extraction trigger, extraction clear, shutdown) still force an immediate
+   * flush. `bufferSaveDebounceMs: 0` restores save-every-turn exactly.
+   */
+  saveTimer = null;
+  pendingSave = false;
+  /** Wall-clock ms when the currently-pending save was first scheduled (issue
+   * #1909). Null when nothing is pending. Used to bound deferral under sustained
+   * activity (see BUFFER_SAVE_MAX_DEFER_MULTIPLIER). */
+  firstPendingAtMs = null;
   enqueueMutation(op) {
     const run = this.mutationChain.catch(() => {
     }).then(op);
@@ -172,6 +187,127 @@ var SmartBuffer = class {
   async save() {
     await this.enqueueMutation(async () => this.saveUnlocked());
   }
+  /**
+   * Schedule a coalesced, TRUE trailing-edge buffer save (issue #1909). Only
+   * used for the debounced (`bufferSaveDebounceMs > 0`) steady-state buffering
+   * path; the debounce-off and correctness-boundary paths save inline within the
+   * mutation (see `recordTurnUnlocked`). Each call re-arms the timer from now so
+   * the write lands one full window after the LAST turn, not the first. To keep
+   * sustained activity from deferring the save without bound (which would widen
+   * the crash-loss window), once a pending save has been deferred
+   * BUFFER_SAVE_MAX_DEFER_MULTIPLIER windows it is flushed inline instead of
+   * re-armed. Runs inside the record mutation, so the inline save is awaited.
+   */
+  async scheduleSave() {
+    const ms = Math.min(this.config.bufferSaveDebounceMs, MAX_SET_TIMEOUT_MS);
+    const now = Date.now();
+    this.pendingSave = true;
+    if (this.firstPendingAtMs === null) this.firstPendingAtMs = now;
+    if (now - this.firstPendingAtMs >= ms * BUFFER_SAVE_MAX_DEFER_MULTIPLIER) {
+      clearTimeout(this.saveTimer ?? void 0);
+      this.saveTimer = null;
+      try {
+        await this.saveUnlocked();
+        this.pendingSave = false;
+        this.firstPendingAtMs = null;
+      } catch (err) {
+        log.warn(`buffer.scheduleSave: staleness-cap save failed, keeping it pending: ${describeError(err)}`);
+        this.saveTimer = setTimeout(() => {
+          this.saveTimer = null;
+          void this.flushPendingSave();
+        }, ms);
+        this.saveTimer.unref?.();
+      }
+      return;
+    }
+    clearTimeout(this.saveTimer ?? void 0);
+    this.saveTimer = setTimeout(() => {
+      this.saveTimer = null;
+      void this.flushPendingSave();
+    }, ms);
+    this.saveTimer.unref?.();
+  }
+  /** Cancel any armed debounced save without persisting. */
+  cancelScheduledSave() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+    this.pendingSave = false;
+    this.firstPendingAtMs = null;
+  }
+  /**
+   * Persist the current in-memory buffer state inline, keeping the global
+   * pending-save state armed until the write SUCCEEDS (issue #1909). On failure
+   * the save stays pending and — when debounced — a background retry timer is
+   * (re-)armed before the error propagates, so a graceful shutdown flush and the
+   * next timer tick both retry. A failed post-mutation save therefore can never
+   * silently drop buffered turns, including turns from OTHER sessions that were
+   * only in the debounced pending state. The pending flag is cleared (and any
+   * armed timer dropped) only after a durable write.
+   */
+  async saveNowRetainingPendingOnFailure(context) {
+    this.pendingSave = true;
+    if (this.firstPendingAtMs === null) this.firstPendingAtMs = Date.now();
+    try {
+      await this.saveUnlocked();
+    } catch (err) {
+      log.warn(
+        `buffer.${context}: inline save failed, keeping it pending for retry: ${describeError(err)}`
+      );
+      const ms = Math.min(this.config.bufferSaveDebounceMs, MAX_SET_TIMEOUT_MS);
+      if (ms > 0 && !this.saveTimer) {
+        this.saveTimer = setTimeout(() => {
+          this.saveTimer = null;
+          void this.flushPendingSave();
+        }, ms);
+        this.saveTimer.unref?.();
+      }
+      throw err;
+    }
+    this.cancelScheduledSave();
+  }
+  /**
+   * Force any pending debounced save to land now (issue #1909). Idempotent and
+   * safe to call from outside a mutation (timer tick, shutdown/dispose, or the
+   * surprise-promotion path in `addTurnWithOutcome`). Do NOT `await` this from
+   * inside a mutation — it enqueues its own mutation and would deadlock the
+   * serializer.
+   *
+   * `throwOnFailure` (review round 7 finding 5): when set, a failed write is
+   * rethrown AFTER the keep-pending + re-arm bookkeeping, so the surprise
+   * extraction boundary gets the same durability guarantee as the built-in
+   * extract triggers (which propagate saveUnlocked failures) instead of
+   * proceeding to extract_now on a non-durable triggering turn. Default false
+   * keeps the fail-open behavior for the timer/shutdown callers.
+   */
+  async flushPendingSave(opts) {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+    if (!this.pendingSave) return;
+    try {
+      await this.enqueueMutation(async () => {
+        if (!this.pendingSave) return;
+        await this.saveUnlocked();
+        this.pendingSave = false;
+        this.firstPendingAtMs = null;
+      });
+    } catch (err) {
+      log.warn(`buffer.flushPendingSave: save failed, keeping it pending for retry: ${describeError(err)}`);
+      const ms = Math.min(this.config.bufferSaveDebounceMs, MAX_SET_TIMEOUT_MS);
+      if (ms > 0 && !this.saveTimer) {
+        this.saveTimer = setTimeout(() => {
+          this.saveTimer = null;
+          void this.flushPendingSave();
+        }, ms);
+        this.saveTimer.unref?.();
+      }
+      if (opts?.throwOnFailure) throw err;
+      return;
+    }
+  }
   async addTurn(bufferKey, turn) {
     return (await this.addTurnWithOutcome(bufferKey, turn)).decision;
   }
@@ -200,6 +336,7 @@ var SmartBuffer = class {
             decision = "extract_now";
             triggered = true;
             extractionTurns = currentTurns;
+            await this.flushPendingSave({ throwOnFailure: true });
           } else {
             log.debug(
               `buffer[${bufferKey}]: surprise=${surprise.toFixed(3)} ignored because buffer changed before probe resolved`
@@ -243,7 +380,11 @@ var SmartBuffer = class {
     const decision = this.evaluate(entry, signal.level);
     const turnCountInWindow = entry.turns.length;
     this.pruneEntries([bufferKey]);
-    await this.saveUnlocked();
+    if (decision === "keep_buffering" && this.config.bufferSaveDebounceMs > 0) {
+      await this.scheduleSave();
+    } else {
+      await this.saveNowRetainingPendingOnFailure("recordTurn");
+    }
     return {
       decision,
       signalLevel: signal.level,
@@ -460,6 +601,10 @@ var SmartBuffer = class {
   }
   async clearAfterExtraction(bufferKey = "default", extractedTurns) {
     await this.enqueueMutation(async () => {
+      if (this.saveTimer) {
+        clearTimeout(this.saveTimer);
+        this.saveTimer = null;
+      }
       await this.loadUnlocked();
       const entry = this.entryFor(bufferKey);
       if (Array.isArray(extractedTurns)) {
@@ -483,7 +628,7 @@ var SmartBuffer = class {
           }
         }
         if (!clearedLiveTurns) {
-          await this.saveUnlocked();
+          await this.saveNowRetainingPendingOnFailure("clearAfterExtraction");
           return;
         }
       } else {
@@ -497,7 +642,7 @@ var SmartBuffer = class {
         this.state.extractionCount = entry.extractionCount;
       }
       this.pruneEntries([bufferKey]);
-      await this.saveUnlocked();
+      await this.saveNowRetainingPendingOnFailure("clearAfterExtraction");
     });
   }
   getExtractionCount(bufferKey = "default") {
@@ -625,4 +770,4 @@ function probeWithTimeout(inflight, timeoutMs) {
 export {
   SmartBuffer
 };
-//# sourceMappingURL=chunk-KSBEEMQF.js.map
+//# sourceMappingURL=chunk-TG6IHVE2.js.map

package/dist/chunk-TG6IHVE2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/buffer.ts"],"sourcesContent":["import { log } from \"./logger.js\";\nimport { scanSignals } from \"./signal.js\";\nimport type { StorageManager } from \"./storage.js\";\nimport type {\n  BufferEntryState,\n  BufferState,\n  BufferSurpriseEvent,\n  BufferTurn,\n  PluginConfig,\n  SignalLevel,\n} from \"./types.js\";\nimport { resolvePresentationCapabilities } from \"./capabilities.js\";\n\nexport type TriggerDecision = \"extract_now\" | \"extract_batch\" | \"keep_buffering\";\n\nexport interface AddTurnOutcome {\n  decision: TriggerDecision;\n  extractionTurns?: BufferTurn[];\n}\n\n/**\n * Optional surprise probe injected into `SmartBuffer`.\n *\n * Computes a D-MEM-style novelty score in `[0, 1]` for an incoming turn.\n * The buffer treats the probe as purely additive: if it is not provided, if\n * the feature flag is off, or if the probe throws/times out, the buffer\n * falls back to the existing signal/turn-count/time triggers unchanged.\n *\n * Callers are responsible for sampling recent memories and passing them\n * through the embedding pipeline — the buffer does not want to know about\n * storage, embeddings, or QMD.\n *\n * @param bufferKey Identifier for the active buffer (session/thread).\n * @param turn      The incoming turn whose novelty is being scored.\n * @param recentTurns Turns already buffered for this key (most recent first\n *                    is NOT guaranteed — treat as unordered corpus).\n * @returns A surprise score in `[0, 1]`, or `null` if no score could be\n *          produced (e.g. empty corpus, probe declined to embed).\n */\nexport interface BufferSurpriseProbe {\n  scoreTurn(\n    bufferKey: string,\n    turn: BufferTurn,\n    recentTurns: readonly BufferTurn[],\n  ): Promise<number | null>;\n}\n\nconst MAX_BUFFER_ENTRY_COUNT = 200;\n\n/**\n * Upper bound on how long a debounced buffer save may be deferred under\n * sustained activity (issue #1909). Each new turn re-arms the trailing-edge\n * timer, so a steady stream of turns could otherwise push the save out\n * indefinitely and widen the crash-loss window without bound. Once a pending\n * save has been deferred this many debounce windows, the next scheduled save\n * forces an inline flush instead of re-arming.\n */\nconst BUFFER_SAVE_MAX_DEFER_MULTIPLIER = 5;\n\n/**\n * Node's maximum 32-bit `setTimeout` delay (2^31-1 ms, ~24.8 days). A larger\n * value is overflow-clamped by Node to 1ms with a TimeoutOverflowWarning, so we\n * clamp defensively at every timer arm (issue #1909 review round 5) even though\n * parseConfig already caps `bufferSaveDebounceMs` — a directly-constructed config\n * could still exceed it.\n */\nconst MAX_SET_TIMEOUT_MS = 2_147_483_647;\n\n/**\n * Minimal data carried on the serialized telemetry write chain\n * (issue #563 PR 3).\n *\n * We intentionally do NOT capture the full `BufferTurn` here: under\n * slow filesystem latency the chain can back up, and retaining\n * `turn.content` for every pending append causes memory pressure on\n * large conversations. Only the fields the ledger row actually needs\n * cross the chain boundary.\n */\ninterface SurpriseTelemetryQueueEntry {\n  bufferKey: string;\n  turnRole: \"user\" | \"assistant\";\n  sessionKey: string | null;\n  surpriseScore: number;\n  triggered: boolean;\n  turnCountInWindow: number;\n  /**\n   * ISO timestamp captured at the moment the turn was scored, NOT when\n   * the ledger append eventually runs. Backpressure on the serialized\n   * write chain could otherwise shift event timestamps away from the\n   * real decision moment and distort the distribution report (p90\n   * inflated, current-threshold row misidentified).\n   */\n  timestamp: string;\n  /**\n   * Threshold value in force when `triggered` was computed. Must be\n   * snapshot here rather than read from `config` at emit time — a\n   * concurrent config change between queue and write would otherwise\n   * record `triggered=true` against a newer threshold the operator\n   * never set, distorting precision/recall interpretation.\n   */\n  threshold: number;\n}\n\ninterface AddTurnMutationResult {\n  decision: TriggerDecision;\n  signalLevel: SignalLevel;\n  priorTurns: BufferTurn[];\n  activeTurnsSnapshot: BufferTurn[];\n  retainedTurnsSnapshot: BufferTurn[];\n  turnCountInWindow: number;\n}\n\nexport class SmartBuffer {\n  private state: BufferState;\n  private loaded = false;\n  private loadPromise: Promise<void> | null = null;\n  private readonly surpriseProbe: BufferSurpriseProbe | null;\n  private mutationChain: Promise<unknown> = Promise.resolve();\n  /**\n   * Serialized write chain for `BUFFER_SURPRISE` telemetry events.\n   *\n   * The telemetry path is fire-and-forget (`addTurn` does not await the\n   * ledger append), but multiple concurrent appends would still settle\n   * out of order under variable filesystem latency. The report path\n   * assumes chronological ordering — it slices the tail of the ledger\n   * and treats the most recent entry as the current threshold in force.\n   * Chaining ensures each append only runs after the previous settles,\n   * preserving wall-clock order.\n   *\n   * We include a `.catch` on every link so a rejected append does not\n   * poison the chain (CLAUDE.md rule #40).\n   */\n  private surpriseTelemetryWriteChain: Promise<unknown> = Promise.resolve();\n\n  /**\n   * Debounced buffer-save state (issue #1909). Steady-state buffering used to\n   * serialize + rewrite the whole multi-session buffer on EVERY turn. We now\n   * coalesce those writes onto a trailing-edge timer; correctness boundaries\n   * (extraction trigger, extraction clear, shutdown) still force an immediate\n   * flush. `bufferSaveDebounceMs: 0` restores save-every-turn exactly.\n   */\n  private saveTimer: NodeJS.Timeout | null = null;\n  private pendingSave = false;\n  /** Wall-clock ms when the currently-pending save was first scheduled (issue\n   * #1909). Null when nothing is pending. Used to bound deferral under sustained\n   * activity (see BUFFER_SAVE_MAX_DEFER_MULTIPLIER). */\n  private firstPendingAtMs: number | null = null;\n\n  constructor(\n    private readonly config: PluginConfig,\n    private readonly storage: StorageManager,\n    surpriseProbe: BufferSurpriseProbe | null = null,\n  ) {\n    this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };\n    this.surpriseProbe = surpriseProbe;\n  }\n\n  private enqueueMutation<T>(op: () => Promise<T>): Promise<T> {\n    const run = this.mutationChain.catch(() => {}).then(op);\n    this.mutationChain = run.catch(() => {});\n    return run;\n  }\n\n  private entryFor(key: string): BufferEntryState {\n    if (!this.state.entries) {\n      this.state.entries = Object.create(null) as NonNullable<BufferState[\"entries\"]>;\n    }\n    const entries = this.state.entries as NonNullable<BufferState[\"entries\"]>;\n    if (Object.hasOwn(entries, key)) {\n      const stored = entries[key];\n      // Guard against corrupted state/buffer.json — if the stored entry\n      // is not a valid object shape, discard it and recreate.\n      if (stored && typeof stored === \"object\" && Array.isArray(stored.turns)) {\n        return stored;\n      }\n      // Corrupted — fall through to recreate.\n    }\n    const created: BufferEntryState = {\n      turns: [],\n      lastExtractionAt: null,\n      extractionCount: 0,\n    };\n    entries[key] = created;\n    return created;\n  }\n\n  private peekEntry(key: string): BufferEntryState | null {\n    const existing = this.state.entries?.[key];\n    if (existing) return existing;\n    if (key !== \"default\") return null;\n    return {\n      turns: Array.isArray(this.state.turns) ? this.state.turns : [],\n      lastExtractionAt: this.state.lastExtractionAt ?? null,\n      extractionCount:\n        typeof this.state.extractionCount === \"number\" ? this.state.extractionCount : 0,\n    };\n  }\n\n  private normalizeState(state: BufferState): BufferState {\n    const entries = Object.assign(\n      Object.create(null),\n      state.entries ?? {},\n    ) as NonNullable<BufferState[\"entries\"]>;\n    if (!entries.default) {\n      entries.default = {\n        turns: Array.isArray(state.turns) ? [...state.turns] : [],\n        lastExtractionAt: state.lastExtractionAt ?? null,\n        extractionCount:\n          typeof state.extractionCount === \"number\" ? state.extractionCount : 0,\n      };\n    }\n    return {\n      turns: entries.default.turns,\n      lastExtractionAt: entries.default.lastExtractionAt,\n      extractionCount: entries.default.extractionCount,\n      entries,\n    };\n  }\n\n  private entryActivityAt(entry: BufferEntryState): number {\n    const lastTurnAt = entry.turns.reduce((latest, turn) => {\n      const parsed = Date.parse(turn.timestamp);\n      return Number.isFinite(parsed) ? Math.max(latest, parsed) : latest;\n    }, -1);\n    const lastExtractionAt =\n      typeof entry.lastExtractionAt === \"string\"\n        ? Date.parse(entry.lastExtractionAt)\n        : Number.NaN;\n    return Math.max(\n      lastTurnAt,\n      Number.isFinite(lastExtractionAt) ? lastExtractionAt : -1,\n    );\n  }\n\n  private pruneEntries(retainKeys: string[]): void {\n    const entries = this.state.entries;\n    if (!entries) return;\n    const keys = Object.keys(entries);\n    if (keys.length <= MAX_BUFFER_ENTRY_COUNT) return;\n\n    const insertionOrder = new Map(keys.map((key, index) => [key, index]));\n    const byOldestActivity = (left: string, right: string): number => {\n      const leftAt = this.entryActivityAt(entries[left] ?? {\n        turns: [],\n        lastExtractionAt: null,\n        extractionCount: 0,\n      });\n      const rightAt = this.entryActivityAt(entries[right] ?? {\n        turns: [],\n        lastExtractionAt: null,\n        extractionCount: 0,\n      });\n      if (leftAt !== rightAt) return leftAt - rightAt;\n      return (insertionOrder.get(left) ?? 0) - (insertionOrder.get(right) ?? 0);\n    };\n    const candidates = keys.filter((key) => key !== \"default\" && !retainKeys.includes(key));\n    const emptyRemovable = candidates\n      .filter((key) => (entries[key]?.turns.length ?? 0) === 0)\n      .sort(byOldestActivity);\n\n    const removableCount = Math.max(0, keys.length - MAX_BUFFER_ENTRY_COUNT);\n    let evicted = emptyRemovable.slice(0, removableCount);\n    if (evicted.length < removableCount) {\n      // Retained failed extractions (#1908 retry retention) keep their turns in\n      // the buffer, so empty entries alone may not bring the map back under the\n      // cap during a provider outage. The cap is the documented bound — evict\n      // the oldest NON-empty sessions too rather than growing unboundedly\n      // (codex review).\n      const nonEmptyRemovable = candidates\n        .filter((key) => (entries[key]?.turns.length ?? 0) > 0)\n        .sort(byOldestActivity);\n      evicted = evicted.concat(nonEmptyRemovable.slice(0, removableCount - evicted.length));\n    }\n    for (const key of evicted) {\n      delete entries[key];\n    }\n    if (evicted.length > 0) {\n      // Loud degradation (extraction hot-loop hardening, Step 7): during a\n      // prolonged provider outage the breaker holds extraction off and buffered\n      // sessions accumulate. Eviction of the oldest empty session entries past\n      // MAX_BUFFER_ENTRY_COUNT is bounded and expected, but must be observable —\n      // not silent — so operators can see buffer pressure.\n      log.warn(\n        `buffer: pruned ${evicted.length} oldest session entr${evicted.length === 1 ? \"y\" : \"ies\"} ` +\n          `past MAX_BUFFER_ENTRY_COUNT=${MAX_BUFFER_ENTRY_COUNT}; buffered turn data for those sessions was dropped`,\n      );\n    }\n  }\n\n  private async loadUnlocked(): Promise<void> {\n    if (this.loaded) return;\n    if (!this.loadPromise) {\n      this.loadPromise = this.storage.loadBuffer()\n        .then((state) => {\n          this.state = this.normalizeState(state);\n          this.loaded = true;\n        })\n        .finally(() => {\n          this.loadPromise = null;\n        });\n    }\n    await this.loadPromise;\n  }\n\n  async load(): Promise<void> {\n    await this.enqueueMutation(async () => this.loadUnlocked());\n  }\n\n  /**\n   * Reset the buffer to an empty, usable state.\n   * Called when the persisted buffer file is corrupt and load() fails,\n   * so the buffer can still accept new turns for the rest of the session.\n   */\n  resetToEmpty(): void {\n    this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };\n    this.loaded = true;\n  }\n\n  private async saveUnlocked(): Promise<void> {\n    await this.storage.saveBuffer(this.state);\n  }\n\n  async save(): Promise<void> {\n    await this.enqueueMutation(async () => this.saveUnlocked());\n  }\n\n  /**\n   * Schedule a coalesced, TRUE trailing-edge buffer save (issue #1909). Only\n   * used for the debounced (`bufferSaveDebounceMs > 0`) steady-state buffering\n   * path; the debounce-off and correctness-boundary paths save inline within the\n   * mutation (see `recordTurnUnlocked`). Each call re-arms the timer from now so\n   * the write lands one full window after the LAST turn, not the first. To keep\n   * sustained activity from deferring the save without bound (which would widen\n   * the crash-loss window), once a pending save has been deferred\n   * BUFFER_SAVE_MAX_DEFER_MULTIPLIER windows it is flushed inline instead of\n   * re-armed. Runs inside the record mutation, so the inline save is awaited.\n   */\n  private async scheduleSave(): Promise<void> {\n    const ms = Math.min(this.config.bufferSaveDebounceMs, MAX_SET_TIMEOUT_MS);\n    const now = Date.now();\n    this.pendingSave = true;\n    if (this.firstPendingAtMs === null) this.firstPendingAtMs = now;\n    if (now - this.firstPendingAtMs >= ms * BUFFER_SAVE_MAX_DEFER_MULTIPLIER) {\n      // Staleness cap hit: persist now rather than deferring further. Drop the\n      // armed timer, attempt the write, and only mark clean on success — a\n      // failure keeps the save pending + re-arms so shutdown/the next timer\n      // retries (issue #1909 review round 2), never diverging memory from disk.\n      clearTimeout(this.saveTimer ?? undefined);\n      this.saveTimer = null;\n      try {\n        await this.saveUnlocked();\n        this.pendingSave = false;\n        this.firstPendingAtMs = null;\n      } catch (err) {\n        log.warn(`buffer.scheduleSave: staleness-cap save failed, keeping it pending: ${describeError(err)}`);\n        this.saveTimer = setTimeout(() => {\n          this.saveTimer = null;\n          void this.flushPendingSave();\n        }, ms);\n        this.saveTimer.unref?.();\n      }\n      return;\n    }\n    // True trailing edge: drop any armed timer and re-arm from now.\n    clearTimeout(this.saveTimer ?? undefined);\n    this.saveTimer = setTimeout(() => {\n      this.saveTimer = null;\n      void this.flushPendingSave();\n    }, ms);\n    this.saveTimer.unref?.();\n  }\n\n  /** Cancel any armed debounced save without persisting. */\n  private cancelScheduledSave(): void {\n    if (this.saveTimer) {\n      clearTimeout(this.saveTimer);\n      this.saveTimer = null;\n    }\n    this.pendingSave = false;\n    this.firstPendingAtMs = null;\n  }\n\n  /**\n   * Persist the current in-memory buffer state inline, keeping the global\n   * pending-save state armed until the write SUCCEEDS (issue #1909). On failure\n   * the save stays pending and — when debounced — a background retry timer is\n   * (re-)armed before the error propagates, so a graceful shutdown flush and the\n   * next timer tick both retry. A failed post-mutation save therefore can never\n   * silently drop buffered turns, including turns from OTHER sessions that were\n   * only in the debounced pending state. The pending flag is cleared (and any\n   * armed timer dropped) only after a durable write.\n   */\n  private async saveNowRetainingPendingOnFailure(context: string): Promise<void> {\n    this.pendingSave = true;\n    if (this.firstPendingAtMs === null) this.firstPendingAtMs = Date.now();\n    try {\n      await this.saveUnlocked();\n    } catch (err) {\n      log.warn(\n        `buffer.${context}: inline save failed, keeping it pending for retry: ${describeError(err)}`,\n      );\n      const ms = Math.min(this.config.bufferSaveDebounceMs, MAX_SET_TIMEOUT_MS);\n      if (ms > 0 && !this.saveTimer) {\n        this.saveTimer = setTimeout(() => {\n          this.saveTimer = null;\n          void this.flushPendingSave();\n        }, ms);\n        this.saveTimer.unref?.();\n      }\n      throw err;\n    }\n    this.cancelScheduledSave();\n  }\n\n  /**\n   * Force any pending debounced save to land now (issue #1909). Idempotent and\n   * safe to call from outside a mutation (timer tick, shutdown/dispose, or the\n   * surprise-promotion path in `addTurnWithOutcome`). Do NOT `await` this from\n   * inside a mutation — it enqueues its own mutation and would deadlock the\n   * serializer.\n   *\n   * `throwOnFailure` (review round 7 finding 5): when set, a failed write is\n   * rethrown AFTER the keep-pending + re-arm bookkeeping, so the surprise\n   * extraction boundary gets the same durability guarantee as the built-in\n   * extract triggers (which propagate saveUnlocked failures) instead of\n   * proceeding to extract_now on a non-durable triggering turn. Default false\n   * keeps the fail-open behavior for the timer/shutdown callers.\n   */\n  async flushPendingSave(opts?: { throwOnFailure?: boolean }): Promise<void> {\n    if (this.saveTimer) {\n      clearTimeout(this.saveTimer);\n      this.saveTimer = null;\n    }\n    if (!this.pendingSave) return;\n    try {\n      await this.enqueueMutation(async () => {\n        // Re-check under the serializer: a concurrent flush may have already\n        // persisted this pending save. Skip the redundant write (no phantom\n        // writes).\n        if (!this.pendingSave) return;\n        await this.saveUnlocked();\n        // Clear the pending flag INSIDE the same serialized mutation as the\n        // write (issue #1909 review). Clearing it after the enqueue await\n        // resolved raced an addTurn interleaving between the write and the\n        // clear: that turn's scheduleSave re-armed pendingSave + a timer, then\n        // this clear wiped it and the debounced flush was lost. Atomic\n        // write+clear means any addTurn runs wholly before (its turn is in the\n        // write) or wholly after (its pendingSave survives and its timer\n        // persists it).\n        this.pendingSave = false;\n        this.firstPendingAtMs = null;\n      });\n    } catch (err) {\n      // The write failed: memory and disk diverge (issue #1909 review round 2).\n      // Keep the save PENDING (do NOT clear pendingSave/firstPendingAtMs) so a\n      // graceful shutdown flush and the re-armed timer both retry it — clearing\n      // the flag here would drop the buffered turns permanently. Re-arm a\n      // background retry when debounced.\n      log.warn(`buffer.flushPendingSave: save failed, keeping it pending for retry: ${describeError(err)}`);\n      const ms = Math.min(this.config.bufferSaveDebounceMs, MAX_SET_TIMEOUT_MS);\n      if (ms > 0 && !this.saveTimer) {\n        this.saveTimer = setTimeout(() => {\n          this.saveTimer = null;\n          void this.flushPendingSave();\n        }, ms);\n        this.saveTimer.unref?.();\n      }\n      // Surprise-extraction boundary needs the durability guarantee — surface\n      // the failure so the caller does not proceed with a non-durable flush.\n      if (opts?.throwOnFailure) throw err;\n      return; // fail-open for timer/shutdown callers\n    }\n  }\n\n  async addTurn(bufferKey: string, turn: BufferTurn): Promise<TriggerDecision> {\n    return (await this.addTurnWithOutcome(bufferKey, turn)).decision;\n  }\n\n  async addTurnWithOutcome(\n    bufferKey: string,\n    turn: BufferTurn,\n  ): Promise<AddTurnOutcome> {\n    const mutation = await this.enqueueMutation(() => this.recordTurnUnlocked(bufferKey, turn));\n    let decision = mutation.decision;\n    let extractionTurns: BufferTurn[] | undefined;\n\n    // Surprise-gated flush (issue #563). Additive only: if the probe is\n    // disabled, unavailable, or the score is below threshold, the decision\n    // from the existing trigger logic stands. The probe only ever *promotes*\n    // `keep_buffering` → `extract_now`; it never suppresses an existing\n    // flush. This preserves the invariant that enabling surprise cannot\n    // *reduce* extraction frequency.\n    if (\n      decision === \"keep_buffering\" &&\n      resolvePresentationCapabilities(this.config).bufferSurpriseTrigger &&\n      this.surpriseProbe !== null &&\n      // Matching the existing \"smart\" branch: surprise is a lower-tier\n      // novelty signal that should not second-guess a high-signal hit\n      // (which already flushes) or fight `every_n` / `time_based` modes.\n      this.config.triggerMode === \"smart\" &&\n      mutation.signalLevel !== \"high\"\n    ) {\n      const surprise = await this.computeSurpriseSafe(bufferKey, turn, mutation.priorTurns);\n      if (surprise !== null) {\n        const shouldPromote = surprise > this.config.bufferSurpriseThreshold;\n        let triggered = false;\n        if (shouldPromote) {\n          const currentTurns = await this.getExtractionTurnsIfBufferSnapshotStillCurrent(\n            bufferKey,\n            mutation.activeTurnsSnapshot,\n            mutation.retainedTurnsSnapshot,\n          );\n          if (currentTurns) {\n            log.debug(\n              `buffer[${bufferKey}]: surprise=${surprise.toFixed(3)} > threshold=${this.config.bufferSurpriseThreshold} → extract_now`,\n            );\n            decision = \"extract_now\";\n            triggered = true;\n            extractionTurns = currentTurns;\n            // Issue #1909 (review): the record mutation for a `keep_buffering`\n            // turn only SCHEDULED a debounced save. Surprise now promotes it to\n            // extract_now AFTER that mutation, so force the buffer durable before\n            // the caller runs extraction — otherwise state/buffer.json lags the\n            // extracted turns by up to the debounce window on a crash. Safe to\n            // await here: we are outside the record mutation (deadlock-free).\n            // throwOnFailure (round 7 finding 5): match the built-in extract\n            // triggers — a failed durability write must NOT silently proceed to\n            // extract_now on a non-durable turn.\n            await this.flushPendingSave({ throwOnFailure: true });\n          } else {\n            log.debug(\n              `buffer[${bufferKey}]: surprise=${surprise.toFixed(3)} ignored because buffer changed before probe resolved`,\n            );\n          }\n        }\n        // Emit telemetry on every scored turn — both triggering and\n        // non-triggering — so operators can fit the threshold to real\n        // traffic distributions. Fire-and-forget: `addTurn` does NOT\n        // await the ledger append, so slow/contended filesystems cannot\n        // add JSONL-append latency to every `processTurn`. But we DO\n        // serialize writes through a promise chain so concurrent\n        // appends settle in wall-clock order — the report path assumes\n        // chronological tail rows and reads the most recent as the\n        // \"current\" threshold.\n        //\n        // Project only the fields we need into the queue entry rather\n        // than capturing the full `BufferTurn` — under slow filesystem\n        // latency the chain can back up, and we must not retain the\n        // (potentially large) `turn.content` string for every pending\n        // append.\n        this.queueSurpriseTelemetryWrite({\n          bufferKey,\n          turnRole: turn.role,\n          sessionKey:\n            typeof turn.sessionKey === \"string\" ? turn.sessionKey : null,\n          surpriseScore: surprise,\n          triggered,\n          turnCountInWindow: mutation.turnCountInWindow,\n          // Stamp at decision time so backpressure on the write chain\n          // does not shift the event's apparent moment away from when\n          // the turn was actually scored.\n          timestamp: new Date().toISOString(),\n          // Snapshot the threshold used to compute `triggered` so a\n          // concurrent config mutation cannot retroactively change\n          // what the ledger row claims the decision was against.\n          threshold: this.config.bufferSurpriseThreshold,\n        });\n      }\n    }\n\n    log.debug(\n      `buffer[${bufferKey}]: ${mutation.turnCountInWindow} turns, signal=${mutation.signalLevel}, decision=${decision}`,\n    );\n    return extractionTurns ? { decision, extractionTurns } : { decision };\n  }\n\n  private async recordTurnUnlocked(bufferKey: string, turn: BufferTurn): Promise<AddTurnMutationResult> {\n    await this.loadUnlocked();\n    const entry = this.entryFor(bufferKey);\n    const priorTurns = entry.turns.slice();\n    entry.turns.push(turn);\n    const activeTurnsSnapshot = entry.turns.map(copyBufferTurn);\n    const retainedTurnsSnapshot = (entry.retainedTurns ?? []).map(copyBufferTurn);\n    if (bufferKey === \"default\") {\n      this.state.turns = entry.turns;\n    }\n\n    const signal = scanSignals(turn.content, this.config.highSignalPatterns);\n    const decision = this.evaluate(entry, signal.level);\n    const turnCountInWindow = entry.turns.length;\n\n    this.pruneEntries([bufferKey]);\n    if (decision === \"keep_buffering\" && this.config.bufferSaveDebounceMs > 0) {\n      // Steady-state buffering: coalesce the whole-state serialize onto a\n      // trailing-edge timer (issue #1909) instead of rewriting per turn.\n      await this.scheduleSave();\n    } else {\n      // Persist immediately within this mutation (awaited) when either:\n      //  - the turn triggered extraction (the buffer must be durable), or\n      //  - debounce is disabled (bufferSaveDebounceMs <= 0), which reproduces\n      //    the legacy save-every-turn behavior byte-for-byte.\n      // Round 8 thread 4: the write is attempted BEFORE the pending state is\n      // cleared, and a failed write leaves it pending (+ a re-armed timer) for\n      // shutdown/timer retry instead of dropping the in-memory turns.\n      await this.saveNowRetainingPendingOnFailure(\"recordTurn\");\n    }\n    return {\n      decision,\n      signalLevel: signal.level,\n      priorTurns,\n      activeTurnsSnapshot,\n      retainedTurnsSnapshot,\n      turnCountInWindow,\n    };\n  }\n\n  private async getExtractionTurnsIfBufferSnapshotStillCurrent(\n    bufferKey: string,\n    activeTurnsSnapshot: readonly BufferTurn[],\n    retainedTurnsSnapshot: readonly BufferTurn[],\n  ): Promise<BufferTurn[] | null> {\n    return this.enqueueMutation(async () => {\n      await this.loadUnlocked();\n      const entry = this.peekEntry(bufferKey);\n      if (!entry) return null;\n      const retained = entry.retainedTurns ?? [];\n      const stillCurrent =\n        bufferTurnArrayIsSuffixOfSnapshot(entry.turns, activeTurnsSnapshot) &&\n        bufferTurnArraysEqual(retained, retainedTurnsSnapshot);\n      if (!stillCurrent) return null;\n      return [...retained, ...entry.turns];\n    });\n  }\n\n  /**\n   * Enqueue a telemetry append on the serialized write chain.\n   *\n   * The chain is a classic `writeChain = writeChain.then(fn).catch(...)`\n   * — each link waits for the previous to settle before its append\n   * starts, so out-of-order chronology cannot happen even under\n   * variable filesystem latency. We always attach `.catch` so one\n   * rejection does not poison the chain for the rest of the session\n   * (CLAUDE.md rule #40). The error is logged through\n   * `emitSurpriseEventSafe` itself, which swallows its own rejections.\n   *\n   * Public surface is deliberately narrow — only `addTurn` should call\n   * this, so the surprise telemetry path stays centralized.\n   */\n  private queueSurpriseTelemetryWrite(params: SurpriseTelemetryQueueEntry): void {\n    this.surpriseTelemetryWriteChain = this.surpriseTelemetryWriteChain\n      .then(() => this.emitSurpriseEventSafe(params))\n      .catch(() => {\n        // `emitSurpriseEventSafe` already handles the logging. We\n        // swallow here only so one failure does not break the chain\n        // for future writes.\n      });\n  }\n\n  /**\n   * Append a single `BUFFER_SURPRISE` telemetry row (issue #563 PR 3).\n   *\n   * Deliberately swallows write errors: the buffer must never fail to\n   * record a turn because the observation ledger is read-only, out of\n   * disk, or otherwise unhappy. The log line at debug lets operators\n   * confirm the path fired without polluting the error channel.\n   */\n  private async emitSurpriseEventSafe(\n    params: SurpriseTelemetryQueueEntry,\n  ): Promise<void> {\n    const storage = this.storage as StorageManager & {\n      appendBufferSurpriseEvents?: (\n        events: BufferSurpriseEvent[],\n      ) => Promise<number>;\n    };\n    if (typeof storage.appendBufferSurpriseEvents !== \"function\") {\n      // Older StorageManager / test double without the telemetry sink.\n      // Silently skip — core path is still covered by the log line above.\n      return;\n    }\n    const event: BufferSurpriseEvent = {\n      event: \"BUFFER_SURPRISE\",\n      // Use the decision-time stamp captured when the event was\n      // queued, NOT `Date.now()` here — backpressure on the write\n      // chain could otherwise shift timestamps into the future relative\n      // to when the turn was scored.\n      timestamp: params.timestamp,\n      bufferKey: params.bufferKey,\n      sessionKey: params.sessionKey,\n      turnRole: params.turnRole,\n      surpriseScore: params.surpriseScore,\n      // Use the snapshotted threshold from the queue entry, not the\n      // live config — see `SurpriseTelemetryQueueEntry.threshold`\n      // doc for the rationale.\n      threshold: params.threshold,\n      triggeredFlush: params.triggered,\n      turnCountInWindow: params.turnCountInWindow,\n    };\n    try {\n      await storage.appendBufferSurpriseEvents([event]);\n    } catch (err) {\n      // Same guard as `computeSurpriseSafe`: non-Error rejections must\n      // not crash the telemetry helper, which would defeat the whole\n      // point of isolating the ledger write from the hot path.\n      log.debug(\n        `buffer[${params.bufferKey}]: surprise telemetry write failed, continuing: ${describeError(err)}`,\n      );\n    }\n  }\n\n  /**\n   * Invoke the injected surprise probe defensively. Any error (probe throws,\n   * embedder unavailable, timeout) is swallowed and logged at debug: the\n   * surprise path must never crash the happy-path trigger evaluation. A\n   * `null` return indicates \"no score available, fall through to existing\n   * triggers\".\n   */\n  private async computeSurpriseSafe(\n    bufferKey: string,\n    turn: BufferTurn,\n    priorTurns: readonly BufferTurn[],\n  ): Promise<number | null> {\n    if (!this.surpriseProbe) return null;\n    try {\n      // Hard timeout around the probe so a hung embedder cannot stall\n      // `addTurn()` before `save()`. A slow probe would otherwise\n      // prevent the just-appended turn from ever being persisted. The\n      // timeout is a soft bound — we race it against the probe, take\n      // whichever settles first, and treat the timeout as\n      // \"probe unavailable, fall through\" rather than an error that\n      // surfaces to the caller.\n      const score = await probeWithTimeout(\n        this.surpriseProbe.scoreTurn(bufferKey, turn, priorTurns),\n        this.config.bufferSurpriseProbeTimeoutMs,\n      );\n      if (score === null) return null;\n      if (typeof score !== \"number\" || !Number.isFinite(score)) {\n        log.debug(\n          `buffer[${bufferKey}]: surprise probe returned non-finite score (${String(score)}), ignoring`,\n        );\n        return null;\n      }\n      // Defensive clamp: formula lives in buffer-surprise.ts, but we never\n      // want a misbehaving probe to inject an out-of-range value into the\n      // threshold comparison.\n      if (score < 0) return 0;\n      if (score > 1) return 1;\n      return score;\n    } catch (err) {\n      // `err` may be any thrown value — `throw null` and\n      // `Promise.reject(\"x\")` are both legal. Accessing `.message` on a\n      // non-Error would itself throw and defeat the failure-isolation\n      // contract, so describe the value safely.\n      log.debug(\n        `buffer[${bufferKey}]: surprise probe failed, falling back to existing triggers: ${describeError(err)}`,\n      );\n      return null;\n    }\n  }\n\n  private evaluate(entry: BufferEntryState, signalLevel: SignalLevel): TriggerDecision {\n    if (this.config.triggerMode === \"smart\") {\n      if (signalLevel === \"high\") return \"extract_now\";\n\n      if (entry.turns.length >= this.config.bufferMaxTurns) {\n        return \"extract_batch\";\n      }\n\n      if (entry.lastExtractionAt) {\n        const elapsed =\n          Date.now() - new Date(entry.lastExtractionAt).getTime();\n        if (elapsed >= this.config.bufferMaxMinutes * 60_000) {\n          return \"extract_batch\";\n        }\n      }\n\n      return \"keep_buffering\";\n    }\n\n    if (this.config.triggerMode === \"every_n\") {\n      return entry.turns.length >= this.config.bufferMaxTurns\n        ? \"extract_batch\"\n        : \"keep_buffering\";\n    }\n\n    if (this.config.triggerMode === \"time_based\") {\n      if (!entry.lastExtractionAt) {\n        return entry.turns.length >= this.config.bufferMaxTurns\n          ? \"extract_batch\"\n          : \"keep_buffering\";\n      }\n      const elapsed =\n        Date.now() - new Date(entry.lastExtractionAt).getTime();\n      return elapsed >= this.config.bufferMaxMinutes * 60_000\n        ? \"extract_batch\"\n        : \"keep_buffering\";\n    }\n\n    return \"keep_buffering\";\n  }\n\n  getTurns(bufferKey = \"default\"): BufferTurn[] {\n    const entry = this.peekEntry(bufferKey);\n    if (!entry) return [];\n    const retained = entry.retainedTurns ?? [];\n    // Retained turns (from a previous defer verdict, issue #562 PR 2) are\n    // prepended so the chronological order — oldest context first — is\n    // preserved for the next extraction pass.\n    return [...retained, ...entry.turns];\n  }\n\n  /**\n   * Retain a subset of the current turns across `clearAfterExtraction` so a\n   * future extraction pass sees the context behind a deferred candidate\n   * (issue #562, PR 2). Callers pass the turns that were seen during the\n   * current extraction; the buffer keeps the tail (latest `max` turns) as\n   * the retention window. Passing an empty array or `max <= 0` clears the\n   * retention slot instead.\n   */\n  async retainDeferredTurns(\n    bufferKey: string,\n    turns: BufferTurn[],\n    max = 10,\n  ): Promise<void> {\n    await this.enqueueMutation(async () => {\n      await this.loadUnlocked();\n      const entry = this.entryFor(bufferKey);\n      if (!Array.isArray(turns) || turns.length === 0 || max <= 0) {\n        delete entry.retainedTurns;\n      } else {\n        // Guard `slice(-max)` against `max === 0` (CLAUDE.md gotcha 27):\n        // `slice(-0)` equals `slice(0)` and would return ALL entries. We\n        // already early-return above when max <= 0.\n        const tail = turns.slice(-max);\n        // Copy explicit fields only — never spread an external object into a\n        // plain object because spread preserves any own `__proto__` /\n        // `constructor` keys that may have arrived via JSON deserialization\n        // of untrusted input (CodeQL js/prototype-polluting-assignment).\n        entry.retainedTurns = tail.map<BufferTurn>((t) => {\n          const copy: BufferTurn = {\n            role: t.role,\n            content: typeof t.content === \"string\" ? t.content : \"\",\n            timestamp:\n              typeof t.timestamp === \"string\"\n                ? t.timestamp\n                : new Date().toISOString(),\n          };\n          if (typeof t.sessionKey === \"string\") copy.sessionKey = t.sessionKey;\n          if (typeof t.logicalSessionKey === \"string\") {\n            copy.logicalSessionKey = t.logicalSessionKey;\n          }\n          if (\n            t.providerThreadId === null ||\n            typeof t.providerThreadId === \"string\"\n          ) {\n            copy.providerThreadId = t.providerThreadId;\n          }\n          if (typeof t.turnFingerprint === \"string\") {\n            copy.turnFingerprint = t.turnFingerprint;\n          }\n          if (typeof t.persistProcessedFingerprint === \"boolean\") {\n            copy.persistProcessedFingerprint = t.persistProcessedFingerprint;\n          }\n          if (typeof t.sourceConnector === \"string\") copy.sourceConnector = t.sourceConnector;\n          return copy;\n        });\n      }\n      await this.saveUnlocked();\n    });\n  }\n\n  /**\n   * Return the current retention window (issue #562, PR 2). Primarily for\n   * tests and diagnostics.\n   */\n  getRetainedDeferredTurns(bufferKey = \"default\"): BufferTurn[] {\n    const entry = this.peekEntry(bufferKey);\n    return entry?.retainedTurns ? [...entry.retainedTurns] : [];\n  }\n\n  async findBufferKeyForSession(sessionKey: string): Promise<string | null> {\n    const bufferKeys = await this.findBufferKeysForSession(sessionKey);\n    return bufferKeys[0] ?? null;\n  }\n\n  async findBufferKeysForSession(sessionKey: string): Promise<string[]> {\n    if (typeof sessionKey !== \"string\" || sessionKey.length === 0) return [];\n    await this.mutationChain.catch(() => {});\n    await this.load();\n\n    const matches: string[] = [];\n    const directEntry = this.peekEntry(sessionKey);\n    if ((directEntry?.turns.length ?? 0) > 0) {\n      matches.push(sessionKey);\n    }\n\n    const entries = this.state.entries ?? {};\n    for (const [bufferKey, entry] of Object.entries(entries)) {\n      if (\n        !matches.includes(bufferKey) &&\n        entry.turns.some(\n          (turn) =>\n            typeof turn.sessionKey === \"string\" && turn.sessionKey === sessionKey,\n        )\n      ) {\n        matches.push(bufferKey);\n      }\n    }\n\n    return matches;\n  }\n\n  async clearAfterExtraction(\n    bufferKey = \"default\",\n    extractedTurns?: readonly BufferTurn[],\n  ): Promise<void> {\n    await this.enqueueMutation(async () => {\n      // Drop any armed debounce TIMER so it cannot fire mid-mutation and race\n      // our post-clear write, but KEEP the pending-save state (issue #1909\n      // review round 13): the post-clear save below can fail, and clearing the\n      // pending flag here would strand buffered turns — including turns from\n      // OTHER sessions that only ever entered the debounced pending state — with\n      // nothing left to retry them. saveNowRetainingPendingOnFailure clears the\n      // pending state only after a durable write, or re-arms it on failure.\n      if (this.saveTimer) {\n        clearTimeout(this.saveTimer);\n        this.saveTimer = null;\n      }\n      await this.loadUnlocked();\n      const entry = this.entryFor(bufferKey);\n      if (Array.isArray(extractedTurns)) {\n        const liveExtractedTurns = liveTurnsFromExtractionSnapshot(\n          entry,\n          extractedTurns,\n        );\n        let clearedLiveTurns = false;\n        if (liveExtractedTurns.length > 0) {\n          const matchedCount = matchingQueuedExtractionPrefixLength(\n            entry.turns,\n            liveExtractedTurns,\n          );\n          if (matchedCount > 0) {\n            entry.turns = entry.turns.slice(matchedCount);\n            clearedLiveTurns = true;\n          } else {\n            log.debug(\n              `buffer[${bufferKey}]: extraction clear skipped because live turns changed before clear`,\n            );\n          }\n        }\n        if (!clearedLiveTurns) {\n          await this.saveNowRetainingPendingOnFailure(\"clearAfterExtraction\");\n          return;\n        }\n      } else {\n        entry.turns = [];\n      }\n      entry.lastExtractionAt = new Date().toISOString();\n      entry.extractionCount += 1;\n      if (bufferKey === \"default\") {\n        this.state.turns = entry.turns;\n        this.state.lastExtractionAt = entry.lastExtractionAt;\n        this.state.extractionCount = entry.extractionCount;\n      }\n      this.pruneEntries([bufferKey]);\n      await this.saveNowRetainingPendingOnFailure(\"clearAfterExtraction\");\n    });\n  }\n\n  getExtractionCount(bufferKey = \"default\"): number {\n    return this.peekEntry(bufferKey)?.extractionCount ?? 0;\n  }\n\n  /**\n   * Await any pending `BUFFER_SURPRISE` telemetry writes.\n   *\n   * The telemetry path is fire-and-forget from the hot path's point of\n   * view, but tests and before-exit hooks sometimes need to make sure\n   * the ledger has been flushed before they assert on its contents or\n   * close the process. This method resolves once the current chain\n   * head has settled; new writes scheduled after this call return a\n   * separate, later settlement.\n   *\n   * Never throws — the chain already catches its own rejections.\n   */\n  async flushSurpriseTelemetry(): Promise<void> {\n    await this.surpriseTelemetryWriteChain;\n  }\n}\n\n/**\n * Render an arbitrary thrown value as a short string for debug logging.\n *\n * JavaScript permits throwing *any* value (`throw null`,\n * `Promise.reject(\"x\")`, `throw { reason: \"timeout\" }`) — not just\n * `Error` instances. The defensive catch blocks in `SmartBuffer` must\n * never themselves throw while trying to log the failure, or they\n * would defeat the whole point of isolating the surprise path from the\n * core extraction decision.\n */\nfunction describeError(err: unknown): string {\n  if (err instanceof Error) return err.message;\n  if (err === null) return \"null\";\n  if (err === undefined) return \"undefined\";\n  if (typeof err === \"string\") return err;\n  try {\n    return JSON.stringify(err);\n  } catch {\n    return String(err);\n  }\n}\n\nfunction copyBufferTurn(turn: BufferTurn): BufferTurn {\n  const copy: BufferTurn = {\n    role: turn.role,\n    content: turn.content,\n    timestamp: turn.timestamp,\n  };\n  if (typeof turn.sessionKey === \"string\") copy.sessionKey = turn.sessionKey;\n  if (typeof turn.logicalSessionKey === \"string\") {\n    copy.logicalSessionKey = turn.logicalSessionKey;\n  }\n  if (\n    turn.providerThreadId === null ||\n    typeof turn.providerThreadId === \"string\"\n  ) {\n    copy.providerThreadId = turn.providerThreadId;\n  }\n  if (typeof turn.turnFingerprint === \"string\") {\n    copy.turnFingerprint = turn.turnFingerprint;\n  }\n  if (typeof turn.persistProcessedFingerprint === \"boolean\") {\n    copy.persistProcessedFingerprint = turn.persistProcessedFingerprint;\n  }\n  if (typeof turn.sourceConnector === \"string\") {\n    copy.sourceConnector = turn.sourceConnector;\n  }\n  return copy;\n}\n\nfunction bufferTurnsEqual(left: BufferTurn | undefined, right: BufferTurn): boolean {\n  if (!left) return false;\n  return (\n    left.role === right.role &&\n    left.content === right.content &&\n    left.timestamp === right.timestamp &&\n    left.sessionKey === right.sessionKey &&\n    left.logicalSessionKey === right.logicalSessionKey &&\n    left.providerThreadId === right.providerThreadId &&\n    left.turnFingerprint === right.turnFingerprint &&\n    left.persistProcessedFingerprint === right.persistProcessedFingerprint &&\n    left.sourceConnector === right.sourceConnector\n  );\n}\n\nfunction bufferTurnArraysEqual(\n  left: readonly BufferTurn[],\n  right: readonly BufferTurn[],\n): boolean {\n  return (\n    left.length === right.length &&\n    left.every((turn, index) => bufferTurnsEqual(turn, right[index]))\n  );\n}\n\nfunction bufferTurnArrayIsSuffixOfSnapshot(\n  liveTurns: readonly BufferTurn[],\n  snapshot: readonly BufferTurn[],\n): boolean {\n  if (liveTurns.length === 0 || liveTurns.length > snapshot.length) {\n    return false;\n  }\n  const offset = snapshot.length - liveTurns.length;\n  return liveTurns.every((turn, index) =>\n    bufferTurnsEqual(turn, snapshot[offset + index]),\n  );\n}\n\nfunction liveTurnsFromExtractionSnapshot(\n  entry: BufferEntryState,\n  extractedTurns: readonly BufferTurn[],\n): readonly BufferTurn[] {\n  const retainedTurns = entry.retainedTurns ?? [];\n  if (\n    retainedTurns.length > 0 &&\n    extractedTurns.length >= retainedTurns.length &&\n    retainedTurns.every((turn, index) =>\n      bufferTurnsEqual(extractedTurns[index], turn),\n    )\n  ) {\n    const withoutRetainedPrefix = extractedTurns.slice(retainedTurns.length);\n    if (\n      withoutRetainedPrefix.length > 0 &&\n      matchingPrefixLength(entry.turns, withoutRetainedPrefix) > 0\n    ) {\n      return withoutRetainedPrefix;\n    }\n  }\n  return extractedTurns;\n}\n\nfunction matchingPrefixLength(\n  liveTurns: readonly BufferTurn[],\n  extractedTurns: readonly BufferTurn[],\n): number {\n  let index = 0;\n  while (\n    index < liveTurns.length &&\n    index < extractedTurns.length &&\n    bufferTurnsEqual(liveTurns[index], extractedTurns[index])\n  ) {\n    index += 1;\n  }\n  return index;\n}\n\nfunction matchingQueuedExtractionPrefixLength(\n  liveTurns: readonly BufferTurn[],\n  extractedTurns: readonly BufferTurn[],\n): number {\n  let bestMatchedCount = 0;\n  for (let start = 0; start < extractedTurns.length; start += 1) {\n    const matchedCount = matchingPrefixLength(\n      liveTurns,\n      extractedTurns.slice(start),\n    );\n    if (matchedCount > bestMatchedCount) {\n      bestMatchedCount = matchedCount;\n      if (bestMatchedCount === liveTurns.length) break;\n    }\n  }\n  return bestMatchedCount;\n}\n\n/**\n * Sentinel error class for the probe timeout path. Catching it via\n * `instanceof` lets the buffer's surprise helper distinguish a timeout\n * from a probe rejection (which could carry operational context the\n * operator wants to see).\n */\nclass ProbeTimeoutError extends Error {\n  constructor(timeoutMs: number) {\n    super(`probe exceeded ${timeoutMs}ms`);\n    this.name = \"ProbeTimeoutError\";\n  }\n}\n\n/**\n * Race `inflight` against a timeout clock. Resolves with `inflight`'s\n * value if it settles first, otherwise rejects with `ProbeTimeoutError`.\n * The timer is cleared in both branches so a fast-resolving probe does\n * not leak a handle that would keep the Node event loop alive.\n */\nfunction probeWithTimeout<T>(\n  inflight: Promise<T>,\n  timeoutMs: number,\n): Promise<T> {\n  let timer: NodeJS.Timeout | null = null;\n  const timeout = new Promise<T>((_, reject) => {\n    timer = setTimeout(() => reject(new ProbeTimeoutError(timeoutMs)), timeoutMs);\n    // `.unref()` so the timer does not hold the event loop open if the\n    // caller decides the probe result is no longer interesting.\n    if (typeof (timer as NodeJS.Timeout).unref === \"function\") {\n      (timer as NodeJS.Timeout).unref();\n    }\n  });\n  return Promise.race([inflight, timeout]).finally(() => {\n    if (timer) clearTimeout(timer);\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-7K5Q6COX.js → chunk-TVVEYCNW.js}

@@ -1,9 +1,9 @@
-import {
-  appendRecallAuditEntry
-} from "./chunk-LBLXEFWK.js";
 import {
   detectRecallAnomalies
 } from "./chunk-RFYAYKTD.js";
+import {
+  appendRecallAuditEntry
+} from "./chunk-LBLXEFWK.js";
 
 // src/access-audit.ts
 var AccessAuditAdapter = class {
@@ -62,4 +62,4 @@ var AccessAuditAdapter = class {
 export {
   AccessAuditAdapter
 };
-//# sourceMappingURL=chunk-7K5Q6COX.js.map
+//# sourceMappingURL=chunk-TVVEYCNW.js.map

package/dist/{chunk-PK5XBDA6.js → chunk-U3ZAVRP3.js}

@@ -1,6 +1,6 @@
 import {
   isRecallDisclosure
-} from "./chunk-B3F4CWQR.js";
+} from "./chunk-YVKF3HEW.js";
 import {
   normalizeRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -292,4 +292,4 @@ export {
   RecallXrayBuilder,
   summarizeDisclosureTokens
 };
-//# sourceMappingURL=chunk-PK5XBDA6.js.map
+//# sourceMappingURL=chunk-U3ZAVRP3.js.map

package/dist/{chunk-ODPLEWB6.js → chunk-UFGFMWAD.js}

@@ -5,6 +5,11 @@ var DEFAULT_CROSS_NAMESPACE_BUDGET = Object.freeze({
   softLimit: 10,
   hardLimit: 30
 });
+function toBudgetWarning(decision) {
+  if (decision.reason !== "warn-over-soft") return void 0;
+  const { reservation: _reservation, ...warning } = decision;
+  return warning;
+}
 function effectiveConfig(raw) {
   const base = { ...DEFAULT_CROSS_NAMESPACE_BUDGET };
   if (!raw) return base;
@@ -33,6 +38,8 @@ function normalizeClock(now) {
 var CrossNamespaceBudget = class {
   config;
   buckets = /* @__PURE__ */ new Map();
+  /** Monotonic id source for reservation tokens (issue #1906 review #4). */
+  reservationSeq = 0;
   constructor(config) {
     this.config = effectiveConfig(config);
   }
@@ -66,39 +73,43 @@ var CrossNamespaceBudget = class {
     if (typeof principal !== "string" || principal.length === 0) {
       principal = "__anonymous__";
     }
-    const bucket = this.buckets.get(principal) ?? { timestamps: [] };
+    const bucket = this.buckets.get(principal) ?? { entries: [] };
     const cutoff = normalizedNow - windowMs;
-    while (bucket.timestamps.length > 0 && bucket.timestamps[0] < cutoff) {
-      bucket.timestamps.shift();
+    while (bucket.entries.length > 0 && bucket.entries[0].ts < cutoff) {
+      bucket.entries.shift();
     }
-    bucket.timestamps.push(normalizedNow);
+    const id = ++this.reservationSeq;
+    bucket.entries.push({ id, ts: normalizedNow });
     this.buckets.set(principal, bucket);
-    const count = bucket.timestamps.length;
+    const count = bucket.entries.length;
     if (count >= hardLimit) {
-      bucket.timestamps.pop();
-      if (bucket.timestamps.length === 0) {
+      bucket.entries.pop();
+      if (bucket.entries.length === 0) {
         this.buckets.delete(principal);
       }
       return {
         allowed: false,
         reason: "deny-over-hard",
-        count: bucket.timestamps.length,
+        count: bucket.entries.length,
         limit
       };
     }
+    const reservation = { principal, id };
     if (count > softLimit) {
       return {
         allowed: true,
         reason: "warn-over-soft",
         count,
-        limit
+        limit,
+        reservation
       };
     }
     return {
       allowed: true,
       reason: "allowed-under-soft",
       count,
-      limit
+      limit,
+      reservation
     };
   }
   /**
@@ -133,11 +144,11 @@ var CrossNamespaceBudget = class {
       principal = "__anonymous__";
     }
     const now = normalizeClock(args.now);
-    const bucket = this.buckets.get(principal) ?? { timestamps: [] };
+    const bucket = this.buckets.get(principal) ?? { entries: [] };
     const cutoff = now - windowMs;
     let liveCount = 0;
-    for (const ts of bucket.timestamps) {
-      if (ts >= cutoff) liveCount++;
+    for (const entry of bucket.entries) {
+      if (entry.ts >= cutoff) liveCount++;
     }
     const projected = liveCount + 1;
     if (projected >= hardLimit) {
@@ -171,6 +182,24 @@ var CrossNamespaceBudget = class {
     }
     return this.record(args.principal, args.now);
   }
+  /**
+   * Roll back the EXACT reservation made by an allowed {@link record} (issue
+   * #1906 review #4). When a recall reserves budget at admission but then fails
+   * or is aborted, the caller releases its own `reservation` token so the
+   * errored recall does not consume budget permanently — and, critically, does
+   * NOT evict a different concurrent recall's entry (which could expire early
+   * and reopen the limiter). A no-op when the token is absent or already gone.
+   * Evicts empty buckets.
+   */
+  release(reservation) {
+    if (!reservation) return;
+    const bucket = this.buckets.get(reservation.principal);
+    if (!bucket) return;
+    const index = bucket.entries.findIndex((entry) => entry.id === reservation.id);
+    if (index < 0) return;
+    bucket.entries.splice(index, 1);
+    if (bucket.entries.length === 0) this.buckets.delete(reservation.principal);
+  }
   /**
    * Clear all state. Intended for tests and for the orchestrator's
    * lifecycle `before_reset` hook.
@@ -190,10 +219,10 @@ var CrossNamespaceBudget = class {
     const cutoff = normalizedNow - this.config.windowMs;
     let evicted = 0;
     for (const [principal, bucket] of this.buckets.entries()) {
-      while (bucket.timestamps.length > 0 && bucket.timestamps[0] < cutoff) {
-        bucket.timestamps.shift();
+      while (bucket.entries.length > 0 && bucket.entries[0].ts < cutoff) {
+        bucket.entries.shift();
       }
-      if (bucket.timestamps.length === 0) {
+      if (bucket.entries.length === 0) {
         this.buckets.delete(principal);
         evicted++;
       }
@@ -208,6 +237,7 @@ var CrossNamespaceBudget = class {
 
 export {
   DEFAULT_CROSS_NAMESPACE_BUDGET,
+  toBudgetWarning,
   CrossNamespaceBudget
 };
-//# sourceMappingURL=chunk-ODPLEWB6.js.map
+//# sourceMappingURL=chunk-UFGFMWAD.js.map

package/dist/chunk-UFGFMWAD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cross-namespace-budget.ts"],"sourcesContent":["/**\n * Per-principal cross-namespace query-budget limiter (issue #565 PR 4/5).\n *\n * Detects and throttles bursts of recall-type operations that a principal\n * issues against namespaces *other than their own*. Thresholds come from the\n * memory-extraction threat model (`docs/security/memory-extraction-threat-model.md`\n * §6.2) and the ADAM baseline report (`docs/security/adam-baseline-2026-04.md`):\n * a T2-class same-namespace attacker plateaus at 61 queries in the published\n * baseline, so the default window is set well below that to force any\n * adaptive loop to noticeably slow down.\n *\n * Shape:\n * - Pure, in-process, per-principal sliding window. No persistence.\n * - Only cross-namespace reads count: a principal hitting only their own\n *   namespace is never throttled.\n * - The limiter is behind the `recallCrossNamespaceBudgetEnabled` feature\n *   flag (defaults to `false`) and is a no-op when disabled. This mirrors\n *   the canonical \"new filter/transform needs an enabled check\" pattern\n *   (see CLAUDE.md gotcha #30).\n *\n * The module has no side effects beyond incrementing its own counters, and\n * it does NOT take a clock dependency — callers pass the current epoch ms\n * (or let the default `Date.now()` do it) so tests can step time\n * deterministically.\n */\n\nexport interface CrossNamespaceBudgetConfig {\n  /** Feature flag. Defaults to false — a disabled limiter is always allow. */\n  enabled?: boolean;\n  /**\n   * Rolling window size in milliseconds. Counts decay out of the window\n   * as the clock advances. Default: 60_000 (1 minute).\n   */\n  windowMs?: number;\n  /**\n   * Soft cap. Once a principal has `softLimit` cross-namespace reads in the\n   * window, the limiter *records* a warning on the decision but still\n   * allows the call. Used by PR 5's anomaly detector to surface flags\n   * without blocking. Default: 10.\n   */\n  softLimit?: number;\n  /**\n   * Hard cap. Once `hardLimit` is reached, the limiter denies the call.\n   * Default: 30 — picked to be well below the T2 baseline of ~60 queries\n   * at half-plateau, so an ADAM-style adaptive loop is throttled before it\n   * meaningfully leaks.\n   */\n  hardLimit?: number;\n}\n\nexport const DEFAULT_CROSS_NAMESPACE_BUDGET: Required<CrossNamespaceBudgetConfig> =\n  Object.freeze({\n    enabled: false,\n    windowMs: 60_000,\n    softLimit: 10,\n    hardLimit: 30,\n  });\n\n/**\n * Why a call was denied / warned. Stable strings so callers can key log\n * lines and metrics on them.\n */\nexport type BudgetDecisionReason =\n  | \"allowed-same-namespace\"\n  | \"allowed-no-limit\"\n  | \"allowed-under-soft\"\n  | \"warn-over-soft\"\n  | \"deny-over-hard\";\n\n/**\n * Opaque token identifying the EXACT window entry a {@link CrossNamespaceBudget.record}\n * reserve created (issue #1906 review #4). Pass it to `release()` to remove\n * that specific entry — never \"the newest\", which under concurrency could evict\n * a different (newer) recall's reservation and reopen the limiter early.\n */\nexport interface BudgetReservation {\n  principal: string;\n  id: number;\n}\n\nexport interface BudgetDecision {\n  allowed: boolean;\n  reason: BudgetDecisionReason;\n  /** Cross-namespace reads by this principal currently in the window. */\n  count: number;\n  /** Active config snapshot at decision time. */\n  limit: {\n    softLimit: number;\n    hardLimit: number;\n    windowMs: number;\n  };\n  /**\n   * Present only when this decision RESERVED a window entry (an allowed\n   * `record()`), so the caller can later `release(reservation)` that exact\n   * entry on a failed/aborted recall. Absent on denials, peeks, and\n   * same-namespace/no-limit decisions.\n   */\n  reservation?: BudgetReservation;\n}\n\n/**\n * Response-safe projection of a soft-limit warning: a {@link BudgetDecision}\n * WITHOUT the server-only `reservation` rollback token (which carries the\n * principal id). This is what may be surfaced on HTTP/MCP recall responses and\n * persisted in idempotency-cache entries, so it must never carry internal quota\n * state (issue #1906 review round 10 #2).\n */\nexport type BudgetWarning = Omit<BudgetDecision, \"reservation\">;\n\n/**\n * Project a decision to its response-safe {@link BudgetWarning}, stripping the\n * internal `reservation` token. Returns `undefined` unless the decision is a\n * soft-limit warning (`warn-over-soft`) — so callers can assign the result to\n * `budgetWarning` directly.\n */\nexport function toBudgetWarning(decision: BudgetDecision): BudgetWarning | undefined {\n  if (decision.reason !== \"warn-over-soft\") return undefined;\n  const { reservation: _reservation, ...warning } = decision;\n  return warning;\n}\n\ninterface PrincipalBucket {\n  /** Cross-namespace reads in the active window, each tagged with a unique id\n   *  so a specific reservation can be released without disturbing others. */\n  entries: Array<{ id: number; ts: number }>;\n}\n\n/**\n * Normalize the provided config against the defaults and reject clearly\n * invalid shapes (non-positive windows, inverted limits). Never throws —\n * returns a safe effective config the limiter can use.\n */\nfunction effectiveConfig(\n  raw: CrossNamespaceBudgetConfig | undefined,\n): Required<CrossNamespaceBudgetConfig> {\n  const base = { ...DEFAULT_CROSS_NAMESPACE_BUDGET };\n  if (!raw) return base;\n  const out = { ...base };\n  if (typeof raw.enabled === \"boolean\") out.enabled = raw.enabled;\n  if (\n    typeof raw.windowMs === \"number\" &&\n    Number.isFinite(raw.windowMs) &&\n    raw.windowMs > 0\n  ) {\n    out.windowMs = raw.windowMs;\n  }\n  if (\n    typeof raw.softLimit === \"number\" &&\n    Number.isFinite(raw.softLimit) &&\n    raw.softLimit >= 0\n  ) {\n    out.softLimit = Math.floor(raw.softLimit);\n  }\n  if (\n    typeof raw.hardLimit === \"number\" &&\n    Number.isFinite(raw.hardLimit) &&\n    raw.hardLimit >= 1\n  ) {\n    // Floor the value, then defensively require the floored result is\n    // still >= 1. `raw.hardLimit = 0.5` previously passed the `> 0`\n    // gate and floored to 0, turning a minor misconfiguration into a\n    // full denial of cross-namespace reads. Now we fall back to the\n    // default instead.\n    const floored = Math.floor(raw.hardLimit);\n    if (floored >= 1) out.hardLimit = floored;\n  }\n  if (out.softLimit > out.hardLimit) {\n    // Inverted limits -> treat soft = hard so we never warn past the deny\n    // threshold. Defensive, should never happen with well-formed config.\n    out.softLimit = out.hardLimit;\n  }\n  return out;\n}\n\nfunction normalizeClock(now: number | undefined): number {\n  if (now === undefined) return Date.now();\n  if (Number.isFinite(now)) return Math.floor(now);\n  return 0;\n}\n\n/**\n * In-process cross-namespace budget limiter. Instantiate once per\n * orchestrator / access-service.\n *\n * Threadsafe-by-construction: Node.js is single-threaded per process for\n * application code, and the limiter never awaits between read-modify-write\n * operations on its internal state.\n */\nexport class CrossNamespaceBudget {\n  private readonly config: Required<CrossNamespaceBudgetConfig>;\n  private readonly buckets = new Map<string, PrincipalBucket>();\n  /** Monotonic id source for reservation tokens (issue #1906 review #4). */\n  private reservationSeq = 0;\n\n  constructor(config?: CrossNamespaceBudgetConfig) {\n    this.config = effectiveConfig(config);\n  }\n\n  /** Exposed for tests / audit surfaces. Never mutate the returned value. */\n  getConfig(): Required<CrossNamespaceBudgetConfig> {\n    return this.config;\n  }\n\n  /**\n   * Check whether `principal` is allowed to issue another cross-namespace\n   * read. Call site is expected to compare `principalNamespace` against\n   * `queryNamespace` and only pass through reads where they differ — the\n   * limiter treats every call as a cross-namespace event.\n   *\n   * @param principal Stable identifier for the calling principal (token\n   *   subject, session principal, etc.). Must be non-empty.\n   * @param now Epoch-ms clock read. Defaults to `Date.now()`; tests pass a\n   *   fixed value to step time deterministically.\n   */\n  record(principal: string, now?: number): BudgetDecision {\n    const normalizedNow = normalizeClock(now);\n    const { enabled, windowMs, softLimit, hardLimit } = this.config;\n    const limit = { softLimit, hardLimit, windowMs };\n\n    if (!enabled) {\n      return {\n        allowed: true,\n        reason: \"allowed-no-limit\",\n        count: 0,\n        limit,\n      };\n    }\n\n    if (typeof principal !== \"string\" || principal.length === 0) {\n      // A missing principal means \"we can't attribute this call\". Rather\n      // than fail open, treat it as a cross-namespace event against a\n      // shared bucket — denial-of-service risk is bounded because the\n      // bucket is scoped per-process.\n      principal = \"__anonymous__\";\n    }\n\n    const bucket = this.buckets.get(principal) ?? { entries: [] };\n    const cutoff = normalizedNow - windowMs;\n    // Drop entries that slid out of the window.\n    while (bucket.entries.length > 0 && bucket.entries[0]!.ts < cutoff) {\n      bucket.entries.shift();\n    }\n\n    // Count the current call against the window BEFORE deciding — a call\n    // that crosses the deny threshold should itself be denied, not the\n    // next one. This is what the threat model calls \"fail at the Nth,\n    // not the (N+1)th\".\n    const id = ++this.reservationSeq;\n    bucket.entries.push({ id, ts: normalizedNow });\n    this.buckets.set(principal, bucket);\n    const count = bucket.entries.length;\n\n    if (count >= hardLimit) {\n      // Denied: roll back the entry we just added so a repeated denied\n      // call does not push the bucket further into the future. This keeps\n      // the limiter stateless with respect to denied attempts.\n      bucket.entries.pop();\n      // Evict empty buckets (e.g. the first record after a long idle\n      // rolled the only entry out, then got denied and rolled back).\n      // Prevents unbounded map growth across many transient principals.\n      if (bucket.entries.length === 0) {\n        this.buckets.delete(principal);\n      }\n      return {\n        allowed: false,\n        reason: \"deny-over-hard\",\n        count: bucket.entries.length,\n        limit,\n      };\n    }\n\n    // Allowed: the entry stands as a reservation the caller can later release\n    // by token (issue #1906 review #4).\n    const reservation: BudgetReservation = { principal, id };\n    if (count > softLimit) {\n      return {\n        allowed: true,\n        reason: \"warn-over-soft\",\n        count,\n        limit,\n        reservation,\n      };\n    }\n\n    return {\n      allowed: true,\n      reason: \"allowed-under-soft\",\n      count,\n      limit,\n      reservation,\n    };\n  }\n\n  /**\n   * Read-only peek at whether a call would be allowed, WITHOUT recording a\n   * timestamp. Useful when the caller must inspect multiple namespaces before\n   * deciding to record a single event. The returned `count` reflects the\n   * current window state at call time.\n   */\n  peek(args: {\n    principal: string;\n    principalNamespace: string;\n    queryNamespace: string;\n    now?: number;\n  }): BudgetDecision {\n    const pn = args.principalNamespace;\n    const qn = args.queryNamespace;\n    const bothPresent =\n      typeof pn === \"string\" && pn.length > 0 &&\n      typeof qn === \"string\" && qn.length > 0;\n    if (bothPresent && pn === qn) {\n      return {\n        allowed: true,\n        reason: \"allowed-same-namespace\",\n        count: 0,\n        limit: {\n          softLimit: this.config.softLimit,\n          hardLimit: this.config.hardLimit,\n          windowMs: this.config.windowMs,\n        },\n      };\n    }\n    // Cross-namespace: simulate what record() would do without the push.\n    const { enabled, windowMs, softLimit, hardLimit } = this.config;\n    const limit = { softLimit, hardLimit, windowMs };\n    if (!enabled) {\n      return { allowed: true, reason: \"allowed-no-limit\", count: 0, limit };\n    }\n    let principal = args.principal;\n    if (typeof principal !== \"string\" || principal.length === 0) {\n      principal = \"__anonymous__\";\n    }\n    const now = normalizeClock(args.now);\n    const bucket = this.buckets.get(principal) ?? { entries: [] };\n    const cutoff = now - windowMs;\n    let liveCount = 0;\n    for (const entry of bucket.entries) {\n      if (entry.ts >= cutoff) liveCount++;\n    }\n    const projected = liveCount + 1; // +1 for the current call\n    if (projected >= hardLimit) {\n      return { allowed: false, reason: \"deny-over-hard\", count: liveCount, limit };\n    }\n    if (projected > softLimit) {\n      return { allowed: true, reason: \"warn-over-soft\", count: projected, limit };\n    }\n    return { allowed: true, reason: \"allowed-under-soft\", count: projected, limit };\n  }\n\n  /**\n   * Convenience guard that also skips the limiter when `principalNamespace`\n   * equals `queryNamespace` (same-namespace is never cross-namespace).\n   * Returns an `allowed-same-namespace` decision in that case.\n   */\n  check(args: {\n    principal: string;\n    principalNamespace: string;\n    queryNamespace: string;\n    now?: number;\n  }): BudgetDecision {\n    // Same-namespace short-circuit requires BOTH namespaces to be\n    // non-empty strings. Two empty/undefined namespaces at runtime\n    // would otherwise compare equal and fail-open — a critical bypass\n    // in a security-critical module. Force the limiter to engage when\n    // either side is missing so we never silently skip enforcement.\n    const pn = args.principalNamespace;\n    const qn = args.queryNamespace;\n    const bothPresent =\n      typeof pn === \"string\" && pn.length > 0 &&\n      typeof qn === \"string\" && qn.length > 0;\n    if (bothPresent && pn === qn) {\n      return {\n        allowed: true,\n        reason: \"allowed-same-namespace\",\n        count: 0,\n        limit: {\n          softLimit: this.config.softLimit,\n          hardLimit: this.config.hardLimit,\n          windowMs: this.config.windowMs,\n        },\n      };\n    }\n    return this.record(args.principal, args.now);\n  }\n\n  /**\n   * Roll back the EXACT reservation made by an allowed {@link record} (issue\n   * #1906 review #4). When a recall reserves budget at admission but then fails\n   * or is aborted, the caller releases its own `reservation` token so the\n   * errored recall does not consume budget permanently — and, critically, does\n   * NOT evict a different concurrent recall's entry (which could expire early\n   * and reopen the limiter). A no-op when the token is absent or already gone.\n   * Evicts empty buckets.\n   */\n  release(reservation: BudgetReservation | null | undefined): void {\n    if (!reservation) return;\n    const bucket = this.buckets.get(reservation.principal);\n    if (!bucket) return;\n    const index = bucket.entries.findIndex((entry) => entry.id === reservation.id);\n    if (index < 0) return;\n    bucket.entries.splice(index, 1);\n    if (bucket.entries.length === 0) this.buckets.delete(reservation.principal);\n  }\n\n  /**\n   * Clear all state. Intended for tests and for the orchestrator's\n   * lifecycle `before_reset` hook.\n   */\n  reset(): void {\n    this.buckets.clear();\n  }\n\n  /**\n   * Evict buckets whose entire timestamp list has slid out of the\n   * active window by `now`. Intended to be called periodically by a\n   * long-lived host process (e.g. from a maintenance cron) that sees\n   * many transient principals. Safe to call at any time; returns the\n   * number of buckets evicted.\n   */\n  gc(now?: number): number {\n    const normalizedNow = normalizeClock(now);\n    const cutoff = normalizedNow - this.config.windowMs;\n    let evicted = 0;\n    for (const [principal, bucket] of this.buckets.entries()) {\n      while (bucket.entries.length > 0 && bucket.entries[0]!.ts < cutoff) {\n        bucket.entries.shift();\n      }\n      if (bucket.entries.length === 0) {\n        this.buckets.delete(principal);\n        evicted++;\n      }\n    }\n    return evicted;\n  }\n\n  /** For tests: current number of live buckets. */\n  bucketCount(): number {\n    return this.buckets.size;\n  }\n}\n"],"mappings":";AAkDO,IAAM,iCACX,OAAO,OAAO;AAAA,EACZ,SAAS;AAAA,EACT,UAAU;AAAA,EACV,WAAW;AAAA,EACX,WAAW;AACb,CAAC;AA2DI,SAAS,gBAAgB,UAAqD;AACnF,MAAI,SAAS,WAAW,iBAAkB,QAAO;AACjD,QAAM,EAAE,aAAa,cAAc,GAAG,QAAQ,IAAI;AAClD,SAAO;AACT;AAaA,SAAS,gBACP,KACsC;AACtC,QAAM,OAAO,EAAE,GAAG,+BAA+B;AACjD,MAAI,CAAC,IAAK,QAAO;AACjB,QAAM,MAAM,EAAE,GAAG,KAAK;AACtB,MAAI,OAAO,IAAI,YAAY,UAAW,KAAI,UAAU,IAAI;AACxD,MACE,OAAO,IAAI,aAAa,YACxB,OAAO,SAAS,IAAI,QAAQ,KAC5B,IAAI,WAAW,GACf;AACA,QAAI,WAAW,IAAI;AAAA,EACrB;AACA,MACE,OAAO,IAAI,cAAc,YACzB,OAAO,SAAS,IAAI,SAAS,KAC7B,IAAI,aAAa,GACjB;AACA,QAAI,YAAY,KAAK,MAAM,IAAI,SAAS;AAAA,EAC1C;AACA,MACE,OAAO,IAAI,cAAc,YACzB,OAAO,SAAS,IAAI,SAAS,KAC7B,IAAI,aAAa,GACjB;AAMA,UAAM,UAAU,KAAK,MAAM,IAAI,SAAS;AACxC,QAAI,WAAW,EAAG,KAAI,YAAY;AAAA,EACpC;AACA,MAAI,IAAI,YAAY,IAAI,WAAW;AAGjC,QAAI,YAAY,IAAI;AAAA,EACtB;AACA,SAAO;AACT;AAEA,SAAS,eAAe,KAAiC;AACvD,MAAI,QAAQ,OAAW,QAAO,KAAK,IAAI;AACvC,MAAI,OAAO,SAAS,GAAG,EAAG,QAAO,KAAK,MAAM,GAAG;AAC/C,SAAO;AACT;AAUO,IAAM,uBAAN,MAA2B;AAAA,EACf;AAAA,EACA,UAAU,oBAAI,IAA6B;AAAA;AAAA,EAEpD,iBAAiB;AAAA,EAEzB,YAAY,QAAqC;AAC/C,SAAK,SAAS,gBAAgB,MAAM;AAAA,EACtC;AAAA;AAAA,EAGA,YAAkD;AAChD,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,OAAO,WAAmB,KAA8B;AACtD,UAAM,gBAAgB,eAAe,GAAG;AACxC,UAAM,EAAE,SAAS,UAAU,WAAW,UAAU,IAAI,KAAK;AACzD,UAAM,QAAQ,EAAE,WAAW,WAAW,SAAS;AAE/C,QAAI,CAAC,SAAS;AACZ,aAAO;AAAA,QACL,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA,QACP;AAAA,MACF;AAAA,IACF;AAEA,QAAI,OAAO,cAAc,YAAY,UAAU,WAAW,GAAG;AAK3D,kBAAY;AAAA,IACd;AAEA,UAAM,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,EAAE,SAAS,CAAC,EAAE;AAC5D,UAAM,SAAS,gBAAgB;AAE/B,WAAO,OAAO,QAAQ,SAAS,KAAK,OAAO,QAAQ,CAAC,EAAG,KAAK,QAAQ;AAClE,aAAO,QAAQ,MAAM;AAAA,IACvB;AAMA,UAAM,KAAK,EAAE,KAAK;AAClB,WAAO,QAAQ,KAAK,EAAE,IAAI,IAAI,cAAc,CAAC;AAC7C,SAAK,QAAQ,IAAI,WAAW,MAAM;AAClC,UAAM,QAAQ,OAAO,QAAQ;AAE7B,QAAI,SAAS,WAAW;AAItB,aAAO,QAAQ,IAAI;AAInB,UAAI,OAAO,QAAQ,WAAW,GAAG;AAC/B,aAAK,QAAQ,OAAO,SAAS;AAAA,MAC/B;AACA,aAAO;AAAA,QACL,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO,OAAO,QAAQ;AAAA,QACtB;AAAA,MACF;AAAA,IACF;AAIA,UAAM,cAAiC,EAAE,WAAW,GAAG;AACvD,QAAI,QAAQ,WAAW;AACrB,aAAO;AAAA,QACL,SAAS;AAAA,QACT,QAAQ;AAAA,QACR;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,MACL,SAAS;AAAA,MACT,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,KAAK,MAKc;AACjB,UAAM,KAAK,KAAK;AAChB,UAAM,KAAK,KAAK;AAChB,UAAM,cACJ,OAAO,OAAO,YAAY,GAAG,SAAS,KACtC,OAAO,OAAO,YAAY,GAAG,SAAS;AACxC,QAAI,eAAe,OAAO,IAAI;AAC5B,aAAO;AAAA,QACL,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,OAAO;AAAA,UACL,WAAW,KAAK,OAAO;AAAA,UACvB,WAAW,KAAK,OAAO;AAAA,UACvB,UAAU,KAAK,OAAO;AAAA,QACxB;AAAA,MACF;AAAA,IACF;AAEA,UAAM,EAAE,SAAS,UAAU,WAAW,UAAU,IAAI,KAAK;AACzD,UAAM,QAAQ,EAAE,WAAW,WAAW,SAAS;AAC/C,QAAI,CAAC,SAAS;AACZ,aAAO,EAAE,SAAS,MAAM,QAAQ,oBAAoB,OAAO,GAAG,MAAM;AAAA,IACtE;AACA,QAAI,YAAY,KAAK;AACrB,QAAI,OAAO,cAAc,YAAY,UAAU,WAAW,GAAG;AAC3D,kBAAY;AAAA,IACd;AACA,UAAM,MAAM,eAAe,KAAK,GAAG;AACnC,UAAM,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,EAAE,SAAS,CAAC,EAAE;AAC5D,UAAM,SAAS,MAAM;AACrB,QAAI,YAAY;AAChB,eAAW,SAAS,OAAO,SAAS;AAClC,UAAI,MAAM,MAAM,OAAQ;AAAA,IAC1B;AACA,UAAM,YAAY,YAAY;AAC9B,QAAI,aAAa,WAAW;AAC1B,aAAO,EAAE,SAAS,OAAO,QAAQ,kBAAkB,OAAO,WAAW,MAAM;AAAA,IAC7E;AACA,QAAI,YAAY,WAAW;AACzB,aAAO,EAAE,SAAS,MAAM,QAAQ,kBAAkB,OAAO,WAAW,MAAM;AAAA,IAC5E;AACA,WAAO,EAAE,SAAS,MAAM,QAAQ,sBAAsB,OAAO,WAAW,MAAM;AAAA,EAChF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,MAKa;AAMjB,UAAM,KAAK,KAAK;AAChB,UAAM,KAAK,KAAK;AAChB,UAAM,cACJ,OAAO,OAAO,YAAY,GAAG,SAAS,KACtC,OAAO,OAAO,YAAY,GAAG,SAAS;AACxC,QAAI,eAAe,OAAO,IAAI;AAC5B,aAAO;AAAA,QACL,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,OAAO;AAAA,UACL,WAAW,KAAK,OAAO;AAAA,UACvB,WAAW,KAAK,OAAO;AAAA,UACvB,UAAU,KAAK,OAAO;AAAA,QACxB;AAAA,MACF;AAAA,IACF;AACA,WAAO,KAAK,OAAO,KAAK,WAAW,KAAK,GAAG;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,QAAQ,aAAyD;AAC/D,QAAI,CAAC,YAAa;AAClB,UAAM,SAAS,KAAK,QAAQ,IAAI,YAAY,SAAS;AACrD,QAAI,CAAC,OAAQ;AACb,UAAM,QAAQ,OAAO,QAAQ,UAAU,CAAC,UAAU,MAAM,OAAO,YAAY,EAAE;AAC7E,QAAI,QAAQ,EAAG;AACf,WAAO,QAAQ,OAAO,OAAO,CAAC;AAC9B,QAAI,OAAO,QAAQ,WAAW,EAAG,MAAK,QAAQ,OAAO,YAAY,SAAS;AAAA,EAC5E;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,QAAc;AACZ,SAAK,QAAQ,MAAM;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAG,KAAsB;AACvB,UAAM,gBAAgB,eAAe,GAAG;AACxC,UAAM,SAAS,gBAAgB,KAAK,OAAO;AAC3C,QAAI,UAAU;AACd,eAAW,CAAC,WAAW,MAAM,KAAK,KAAK,QAAQ,QAAQ,GAAG;AACxD,aAAO,OAAO,QAAQ,SAAS,KAAK,OAAO,QAAQ,CAAC,EAAG,KAAK,QAAQ;AAClE,eAAO,QAAQ,MAAM;AAAA,MACvB;AACA,UAAI,OAAO,QAAQ,WAAW,GAAG;AAC/B,aAAK,QAAQ,OAAO,SAAS;AAC7B;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,cAAsB;AACpB,WAAO,KAAK,QAAQ;AAAA,EACtB;AACF;","names":[]}

package/dist/{chunk-4KJLYTLS.js → chunk-V57NLO5P.js}

@@ -1,6 +1,6 @@
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/storage-guards.ts
 var PROJECTION_FALLBACK_WARN_INTERVAL_MS = 5 * 6e4;
@@ -32,4 +32,4 @@ export {
   assertMemoryFrontmatterId,
   warnProjectionFallback
 };
-//# sourceMappingURL=chunk-4KJLYTLS.js.map
+//# sourceMappingURL=chunk-V57NLO5P.js.map

package/dist/{chunk-FLVL4L3L.js → chunk-VDX2J7OX.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-WEHSQBFR.js";
 import {
   encryptCapsuleFile
-} from "./chunk-437S3G37.js";
+} from "./chunk-DQEMWVMT.js";
 import {
   CAPSULE_SCHEMA_VERSION,
   EXPORT_FORMAT
@@ -261,4 +261,4 @@ export {
   exportCapsule,
   isValidCapsuleSince
 };
-//# sourceMappingURL=chunk-FLVL4L3L.js.map
+//# sourceMappingURL=chunk-VDX2J7OX.js.map

package/dist/{chunk-7XGSIUP5.js → chunk-W4FBGYGK.js}

@@ -216,4 +216,4 @@ export {
   getCausalTrajectoryStoreStatus,
   searchCausalTrajectories
 };
-//# sourceMappingURL=chunk-7XGSIUP5.js.map
+//# sourceMappingURL=chunk-W4FBGYGK.js.map