@remnic/core 1.1.11 → 1.1.13

package/dist/chunk-JBMSGZEQ.js

@@ -1,441 +0,0 @@
-import {
-  scanSignals
-} from "./chunk-XYIK4LF6.js";
-import {
-  log
-} from "./chunk-2ODBA7MQ.js";
-
-// src/buffer.ts
-var MAX_BUFFER_ENTRY_COUNT = 200;
-var SmartBuffer = class {
-  constructor(config, storage, surpriseProbe = null) {
-    this.config = config;
-    this.storage = storage;
-    this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };
-    this.surpriseProbe = surpriseProbe;
-  }
-  config;
-  storage;
-  state;
-  loaded = false;
-  surpriseProbe;
-  /**
-   * Serialized write chain for `BUFFER_SURPRISE` telemetry events.
-   *
-   * The telemetry path is fire-and-forget (`addTurn` does not await the
-   * ledger append), but multiple concurrent appends would still settle
-   * out of order under variable filesystem latency. The report path
-   * assumes chronological ordering — it slices the tail of the ledger
-   * and treats the most recent entry as the current threshold in force.
-   * Chaining ensures each append only runs after the previous settles,
-   * preserving wall-clock order.
-   *
-   * We include a `.catch` on every link so a rejected append does not
-   * poison the chain (CLAUDE.md rule #40).
-   */
-  surpriseTelemetryWriteChain = Promise.resolve();
-  entryFor(key) {
-    this.state.entries ??= {};
-    if (key === "__proto__" || key === "constructor" || key === "prototype") {
-      key = `__safe_${key}`;
-    }
-    if (Object.hasOwn(this.state.entries, key)) {
-      const stored = this.state.entries[key];
-      if (stored && typeof stored === "object" && Array.isArray(stored.turns)) {
-        return stored;
-      }
-    }
-    const created = {
-      turns: [],
-      lastExtractionAt: null,
-      extractionCount: 0
-    };
-    this.state.entries[key] = created;
-    return created;
-  }
-  peekEntry(key) {
-    if (key === "__proto__" || key === "constructor" || key === "prototype") {
-      key = `__safe_${key}`;
-    }
-    const existing = this.state.entries?.[key];
-    if (existing) return existing;
-    if (key !== "default") return null;
-    return {
-      turns: Array.isArray(this.state.turns) ? this.state.turns : [],
-      lastExtractionAt: this.state.lastExtractionAt ?? null,
-      extractionCount: typeof this.state.extractionCount === "number" ? this.state.extractionCount : 0
-    };
-  }
-  normalizeState(state) {
-    const entries = state.entries ?? {};
-    if (!entries.default) {
-      entries.default = {
-        turns: Array.isArray(state.turns) ? [...state.turns] : [],
-        lastExtractionAt: state.lastExtractionAt ?? null,
-        extractionCount: typeof state.extractionCount === "number" ? state.extractionCount : 0
-      };
-    }
-    return {
-      turns: entries.default.turns,
-      lastExtractionAt: entries.default.lastExtractionAt,
-      extractionCount: entries.default.extractionCount,
-      entries
-    };
-  }
-  entryActivityAt(entry) {
-    const lastTurnAt = entry.turns.reduce((latest, turn) => {
-      const parsed = Date.parse(turn.timestamp);
-      return Number.isFinite(parsed) ? Math.max(latest, parsed) : latest;
-    }, -1);
-    const lastExtractionAt = typeof entry.lastExtractionAt === "string" ? Date.parse(entry.lastExtractionAt) : Number.NaN;
-    return Math.max(
-      lastTurnAt,
-      Number.isFinite(lastExtractionAt) ? lastExtractionAt : -1
-    );
-  }
-  pruneEntries(retainKeys) {
-    const entries = this.state.entries;
-    if (!entries) return;
-    const keys = Object.keys(entries);
-    if (keys.length <= MAX_BUFFER_ENTRY_COUNT) return;
-    const insertionOrder = new Map(keys.map((key, index) => [key, index]));
-    const removable = keys.filter((key) => key !== "default" && !retainKeys.includes(key)).filter((key) => (entries[key]?.turns.length ?? 0) === 0).sort((left, right) => {
-      const leftAt = this.entryActivityAt(entries[left] ?? {
-        turns: [],
-        lastExtractionAt: null,
-        extractionCount: 0
-      });
-      const rightAt = this.entryActivityAt(entries[right] ?? {
-        turns: [],
-        lastExtractionAt: null,
-        extractionCount: 0
-      });
-      if (leftAt !== rightAt) return leftAt - rightAt;
-      return (insertionOrder.get(left) ?? 0) - (insertionOrder.get(right) ?? 0);
-    });
-    const removableCount = Math.max(0, keys.length - MAX_BUFFER_ENTRY_COUNT);
-    for (const key of removable.slice(0, removableCount)) {
-      delete entries[key];
-    }
-  }
-  async load() {
-    if (this.loaded) return;
-    this.state = this.normalizeState(await this.storage.loadBuffer());
-    this.loaded = true;
-  }
-  /**
-   * Reset the buffer to an empty, usable state.
-   * Called when the persisted buffer file is corrupt and load() fails,
-   * so the buffer can still accept new turns for the rest of the session.
-   */
-  resetToEmpty() {
-    this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };
-    this.loaded = true;
-  }
-  async save() {
-    await this.storage.saveBuffer(this.state);
-  }
-  async addTurn(bufferKey, turn) {
-    await this.load();
-    const entry = this.entryFor(bufferKey);
-    entry.turns.push(turn);
-    if (bufferKey === "default") {
-      this.state.turns = entry.turns;
-    }
-    const signal = scanSignals(turn.content, this.config.highSignalPatterns);
-    let decision = this.evaluate(entry, signal.level);
-    if (decision === "keep_buffering" && this.config.bufferSurpriseTriggerEnabled && this.surpriseProbe !== null && // Matching the existing "smart" branch: surprise is a lower-tier
-    // novelty signal that should not second-guess a high-signal hit
-    // (which already flushes) or fight `every_n` / `time_based` modes.
-    this.config.triggerMode === "smart" && signal.level !== "high") {
-      const surprise = await this.computeSurpriseSafe(bufferKey, turn, entry);
-      if (surprise !== null) {
-        const triggered = surprise > this.config.bufferSurpriseThreshold;
-        if (triggered) {
-          log.debug(
-            `buffer[${bufferKey}]: surprise=${surprise.toFixed(3)} > threshold=${this.config.bufferSurpriseThreshold} \u2192 extract_now`
-          );
-          decision = "extract_now";
-        }
-        this.queueSurpriseTelemetryWrite({
-          bufferKey,
-          turnRole: turn.role,
-          sessionKey: typeof turn.sessionKey === "string" ? turn.sessionKey : null,
-          surpriseScore: surprise,
-          triggered,
-          turnCountInWindow: entry.turns.length,
-          // Stamp at decision time so backpressure on the write chain
-          // does not shift the event's apparent moment away from when
-          // the turn was actually scored.
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          // Snapshot the threshold used to compute `triggered` so a
-          // concurrent config mutation cannot retroactively change
-          // what the ledger row claims the decision was against.
-          threshold: this.config.bufferSurpriseThreshold
-        });
-      }
-    }
-    log.debug(
-      `buffer[${bufferKey}]: ${entry.turns.length} turns, signal=${signal.level}, decision=${decision}`
-    );
-    this.pruneEntries([bufferKey]);
-    await this.save();
-    return decision;
-  }
-  /**
-   * Enqueue a telemetry append on the serialized write chain.
-   *
-   * The chain is a classic `writeChain = writeChain.then(fn).catch(...)`
-   * — each link waits for the previous to settle before its append
-   * starts, so out-of-order chronology cannot happen even under
-   * variable filesystem latency. We always attach `.catch` so one
-   * rejection does not poison the chain for the rest of the session
-   * (CLAUDE.md rule #40). The error is logged through
-   * `emitSurpriseEventSafe` itself, which swallows its own rejections.
-   *
-   * Public surface is deliberately narrow — only `addTurn` should call
-   * this, so the surprise telemetry path stays centralized.
-   */
-  queueSurpriseTelemetryWrite(params) {
-    this.surpriseTelemetryWriteChain = this.surpriseTelemetryWriteChain.then(() => this.emitSurpriseEventSafe(params)).catch(() => {
-    });
-  }
-  /**
-   * Append a single `BUFFER_SURPRISE` telemetry row (issue #563 PR 3).
-   *
-   * Deliberately swallows write errors: the buffer must never fail to
-   * record a turn because the observation ledger is read-only, out of
-   * disk, or otherwise unhappy. The log line at debug lets operators
-   * confirm the path fired without polluting the error channel.
-   */
-  async emitSurpriseEventSafe(params) {
-    const storage = this.storage;
-    if (typeof storage.appendBufferSurpriseEvents !== "function") {
-      return;
-    }
-    const event = {
-      event: "BUFFER_SURPRISE",
-      // Use the decision-time stamp captured when the event was
-      // queued, NOT `Date.now()` here — backpressure on the write
-      // chain could otherwise shift timestamps into the future relative
-      // to when the turn was scored.
-      timestamp: params.timestamp,
-      bufferKey: params.bufferKey,
-      sessionKey: params.sessionKey,
-      turnRole: params.turnRole,
-      surpriseScore: params.surpriseScore,
-      // Use the snapshotted threshold from the queue entry, not the
-      // live config — see `SurpriseTelemetryQueueEntry.threshold`
-      // doc for the rationale.
-      threshold: params.threshold,
-      triggeredFlush: params.triggered,
-      turnCountInWindow: params.turnCountInWindow
-    };
-    try {
-      await storage.appendBufferSurpriseEvents([event]);
-    } catch (err) {
-      log.debug(
-        `buffer[${params.bufferKey}]: surprise telemetry write failed, continuing: ${describeError(err)}`
-      );
-    }
-  }
-  /**
-   * Invoke the injected surprise probe defensively. Any error (probe throws,
-   * embedder unavailable, timeout) is swallowed and logged at debug: the
-   * surprise path must never crash the happy-path trigger evaluation. A
-   * `null` return indicates "no score available, fall through to existing
-   * triggers".
-   */
-  async computeSurpriseSafe(bufferKey, turn, entry) {
-    if (!this.surpriseProbe) return null;
-    const prior = entry.turns.length > 0 ? entry.turns.slice(0, -1) : [];
-    try {
-      const score = await probeWithTimeout(
-        this.surpriseProbe.scoreTurn(bufferKey, turn, prior),
-        this.config.bufferSurpriseProbeTimeoutMs
-      );
-      if (score === null) return null;
-      if (typeof score !== "number" || !Number.isFinite(score)) {
-        log.debug(
-          `buffer[${bufferKey}]: surprise probe returned non-finite score (${String(score)}), ignoring`
-        );
-        return null;
-      }
-      if (score < 0) return 0;
-      if (score > 1) return 1;
-      return score;
-    } catch (err) {
-      log.debug(
-        `buffer[${bufferKey}]: surprise probe failed, falling back to existing triggers: ${describeError(err)}`
-      );
-      return null;
-    }
-  }
-  evaluate(entry, signalLevel) {
-    if (this.config.triggerMode === "smart") {
-      if (signalLevel === "high") return "extract_now";
-      if (entry.turns.length >= this.config.bufferMaxTurns) {
-        return "extract_batch";
-      }
-      if (entry.lastExtractionAt) {
-        const elapsed = Date.now() - new Date(entry.lastExtractionAt).getTime();
-        if (elapsed >= this.config.bufferMaxMinutes * 6e4) {
-          return "extract_batch";
-        }
-      }
-      return "keep_buffering";
-    }
-    if (this.config.triggerMode === "every_n") {
-      return entry.turns.length >= this.config.bufferMaxTurns ? "extract_batch" : "keep_buffering";
-    }
-    if (this.config.triggerMode === "time_based") {
-      if (!entry.lastExtractionAt) {
-        return entry.turns.length >= this.config.bufferMaxTurns ? "extract_batch" : "keep_buffering";
-      }
-      const elapsed = Date.now() - new Date(entry.lastExtractionAt).getTime();
-      return elapsed >= this.config.bufferMaxMinutes * 6e4 ? "extract_batch" : "keep_buffering";
-    }
-    return "keep_buffering";
-  }
-  getTurns(bufferKey = "default") {
-    const entry = this.peekEntry(bufferKey);
-    if (!entry) return [];
-    const retained = entry.retainedTurns ?? [];
-    return [...retained, ...entry.turns];
-  }
-  /**
-   * Retain a subset of the current turns across `clearAfterExtraction` so a
-   * future extraction pass sees the context behind a deferred candidate
-   * (issue #562, PR 2). Callers pass the turns that were seen during the
-   * current extraction; the buffer keeps the tail (latest `max` turns) as
-   * the retention window. Passing an empty array or `max <= 0` clears the
-   * retention slot instead.
-   */
-  async retainDeferredTurns(bufferKey, turns, max = 10) {
-    await this.load();
-    const entry = this.entryFor(bufferKey);
-    if (!Array.isArray(turns) || turns.length === 0 || max <= 0) {
-      delete entry.retainedTurns;
-    } else {
-      const tail = turns.slice(-max);
-      entry.retainedTurns = tail.map((t) => {
-        const copy = {
-          role: t.role,
-          content: typeof t.content === "string" ? t.content : "",
-          timestamp: typeof t.timestamp === "string" ? t.timestamp : (/* @__PURE__ */ new Date()).toISOString()
-        };
-        if (typeof t.sessionKey === "string") copy.sessionKey = t.sessionKey;
-        if (typeof t.logicalSessionKey === "string") {
-          copy.logicalSessionKey = t.logicalSessionKey;
-        }
-        if (t.providerThreadId === null || typeof t.providerThreadId === "string") {
-          copy.providerThreadId = t.providerThreadId;
-        }
-        if (typeof t.turnFingerprint === "string") {
-          copy.turnFingerprint = t.turnFingerprint;
-        }
-        if (typeof t.persistProcessedFingerprint === "boolean") {
-          copy.persistProcessedFingerprint = t.persistProcessedFingerprint;
-        }
-        return copy;
-      });
-    }
-    await this.save();
-  }
-  /**
-   * Return the current retention window (issue #562, PR 2). Primarily for
-   * tests and diagnostics.
-   */
-  getRetainedDeferredTurns(bufferKey = "default") {
-    const entry = this.peekEntry(bufferKey);
-    return entry?.retainedTurns ? [...entry.retainedTurns] : [];
-  }
-  async findBufferKeyForSession(sessionKey) {
-    const bufferKeys = await this.findBufferKeysForSession(sessionKey);
-    return bufferKeys[0] ?? null;
-  }
-  async findBufferKeysForSession(sessionKey) {
-    if (typeof sessionKey !== "string" || sessionKey.length === 0) return [];
-    await this.load();
-    const matches = [];
-    const directEntry = this.peekEntry(sessionKey);
-    if ((directEntry?.turns.length ?? 0) > 0) {
-      matches.push(sessionKey);
-    }
-    const entries = this.state.entries ?? {};
-    for (const [bufferKey, entry] of Object.entries(entries)) {
-      if (!matches.includes(bufferKey) && entry.turns.some(
-        (turn) => typeof turn.sessionKey === "string" && turn.sessionKey === sessionKey
-      )) {
-        matches.push(bufferKey);
-      }
-    }
-    return matches;
-  }
-  async clearAfterExtraction(bufferKey = "default") {
-    await this.load();
-    const entry = this.entryFor(bufferKey);
-    entry.turns = [];
-    entry.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
-    entry.extractionCount += 1;
-    if (bufferKey === "default") {
-      this.state.turns = entry.turns;
-      this.state.lastExtractionAt = entry.lastExtractionAt;
-      this.state.extractionCount = entry.extractionCount;
-    }
-    this.pruneEntries([bufferKey]);
-    await this.save();
-  }
-  getExtractionCount(bufferKey = "default") {
-    return this.peekEntry(bufferKey)?.extractionCount ?? 0;
-  }
-  /**
-   * Await any pending `BUFFER_SURPRISE` telemetry writes.
-   *
-   * The telemetry path is fire-and-forget from the hot path's point of
-   * view, but tests and before-exit hooks sometimes need to make sure
-   * the ledger has been flushed before they assert on its contents or
-   * close the process. This method resolves once the current chain
-   * head has settled; new writes scheduled after this call return a
-   * separate, later settlement.
-   *
-   * Never throws — the chain already catches its own rejections.
-   */
-  async flushSurpriseTelemetry() {
-    await this.surpriseTelemetryWriteChain;
-  }
-};
-function describeError(err) {
-  if (err instanceof Error) return err.message;
-  if (err === null) return "null";
-  if (err === void 0) return "undefined";
-  if (typeof err === "string") return err;
-  try {
-    return JSON.stringify(err);
-  } catch {
-    return String(err);
-  }
-}
-var ProbeTimeoutError = class extends Error {
-  constructor(timeoutMs) {
-    super(`probe exceeded ${timeoutMs}ms`);
-    this.name = "ProbeTimeoutError";
-  }
-};
-function probeWithTimeout(inflight, timeoutMs) {
-  let timer = null;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new ProbeTimeoutError(timeoutMs)), timeoutMs);
-    if (typeof timer.unref === "function") {
-      timer.unref();
-    }
-  });
-  return Promise.race([inflight, timeout]).finally(() => {
-    if (timer) clearTimeout(timer);
-  });
-}
-
-export {
-  SmartBuffer
-};
-//# sourceMappingURL=chunk-JBMSGZEQ.js.map

package/dist/chunk-JBMSGZEQ.js.map

@@ -1 +0,0 @@
-{"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\";\n\nexport type TriggerDecision = \"extract_now\" | \"extract_batch\" | \"keep_buffering\";\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 * 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\nexport class SmartBuffer {\n  private state: BufferState;\n  private loaded = false;\n  private readonly surpriseProbe: BufferSurpriseProbe | null;\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  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 entryFor(key: string): BufferEntryState {\n    this.state.entries ??= {};\n    // Reject prototype-polluting keys outright so no downstream\n    // assignment can mutate Object.prototype.\n    if (key === \"__proto__\" || key === \"constructor\" || key === \"prototype\") {\n      key = `__safe_${key}`;\n    }\n    if (Object.hasOwn(this.state.entries, key)) {\n      const stored = this.state.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    this.state.entries[key] = created;\n    return created;\n  }\n\n  private peekEntry(key: string): BufferEntryState | null {\n    // Apply the same prototype-pollution guard as entryFor so reads and\n    // writes use the same key namespace for dangerous keys.\n    if (key === \"__proto__\" || key === \"constructor\" || key === \"prototype\") {\n      key = `__safe_${key}`;\n    }\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 = state.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 removable = keys\n      .filter((key) => key !== \"default\" && !retainKeys.includes(key))\n      .filter((key) => (entries[key]?.turns.length ?? 0) === 0)\n      .sort((left, right) => {\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\n    const removableCount = Math.max(0, keys.length - MAX_BUFFER_ENTRY_COUNT);\n    for (const key of removable.slice(0, removableCount)) {\n      delete entries[key];\n    }\n  }\n\n  async load(): Promise<void> {\n    if (this.loaded) return;\n    this.state = this.normalizeState(await this.storage.loadBuffer());\n    this.loaded = true;\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  async save(): Promise<void> {\n    await this.storage.saveBuffer(this.state);\n  }\n\n  async addTurn(bufferKey: string, turn: BufferTurn): Promise<TriggerDecision> {\n    await this.load();\n    const entry = this.entryFor(bufferKey);\n    entry.turns.push(turn);\n    if (bufferKey === \"default\") {\n      this.state.turns = entry.turns;\n    }\n\n    const signal = scanSignals(turn.content, this.config.highSignalPatterns);\n    let decision = this.evaluate(entry, signal.level);\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      this.config.bufferSurpriseTriggerEnabled &&\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      signal.level !== \"high\"\n    ) {\n      const surprise = await this.computeSurpriseSafe(bufferKey, turn, entry);\n      if (surprise !== null) {\n        const triggered = surprise > this.config.bufferSurpriseThreshold;\n        if (triggered) {\n          log.debug(\n            `buffer[${bufferKey}]: surprise=${surprise.toFixed(3)} > threshold=${this.config.bufferSurpriseThreshold} → extract_now`,\n          );\n          decision = \"extract_now\";\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: entry.turns.length,\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}]: ${entry.turns.length} turns, signal=${signal.level}, decision=${decision}`,\n    );\n\n    this.pruneEntries([bufferKey]);\n    await this.save();\n    return decision;\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    entry: BufferEntryState,\n  ): Promise<number | null> {\n    if (!this.surpriseProbe) return null;\n    // The current turn was just pushed into entry.turns; exclude it from the\n    // corpus so the probe never compares a turn to itself.\n    const prior = entry.turns.length > 0\n      ? entry.turns.slice(0, -1)\n      : [];\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, prior),\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.load();\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        return copy;\n      });\n    }\n    await this.save();\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.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(bufferKey = \"default\"): Promise<void> {\n    await this.load();\n    const entry = this.entryFor(bufferKey);\n    entry.turns = [];\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.save();\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\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":[]}