@remnic/core 10.0.85 → 10.0.87

package/dist/chunk-TQ4SCPGQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/buffer.ts"],"sourcesContent":["import { log } from \"./logger.js\";\nimport { throwIfAborted } from \"./abort-error.js\";\nimport { scanSignals } from \"./signal.js\";\nimport { BufferSessionPersistence, type BufferStorage } from \"./buffer-persistence.js\";\nimport { selectEvictedBufferKeys } from \"./buffer-eviction.js\";\nimport type {\n  BufferEntryState,\n  BufferState,\n  BufferSurpriseEvent,\n  BufferTurn,\n  PluginConfig,\n  SignalLevel,\n} from \"./types.js\";\nimport { resolvePresentationCapabilities, resolveNamespaceCapabilities } from \"./capabilities.js\";\nimport { resolvePrincipal } from \"./namespaces/principal.js\";\nimport { scopeProfilePlanIdentity, subtractBufferTurns } from \"./buffer-turn-helpers.js\";\nimport { ExtractionDeadlineError } from \"./orchestration/extraction-run.js\";\nimport type { ExtractionBufferSnapshot } from \"./extraction-liveness.js\";\nimport {\n  bufferEntryCounts,\n  bufferTurnArrayIsSuffixOfSnapshot,\n  bufferTurnArraysEqual,\n  bufferTurnsEqual,\n  copyBufferTurn,\n  describeError,\n  entryActivityAt,\n  entryHoldsAcceptedCapture,\n  hasPinnedCaptureScope,\n  liveTurnsFromExtractionSnapshot,\n  matchingQueuedExtractionPrefixLength,\n  normalizeBufferState,\n  probeWithTimeout,\n  selectRetainedDeferredTurns,\n  type BufferEntryCounts,\n} from \"./buffer-turn-helpers.js\";\nimport { BufferAdmissionRefusedError, canAdmitNewEntryUnlocked } from \"./buffer-admission.js\";\nexport { BufferAdmissionRefusedError } from \"./buffer-admission.js\";\nimport type { AddTurnMutationResult, AddTurnOutcome, RetainedTurnCleanupOptions, TriggerDecision } from \"./buffer-types.js\";\n\nexport type { TriggerDecision, AddTurnOutcome, RetainedTurnCleanupOptions } from \"./buffer-types.js\";\n\n// Eviction hooks are pure functions of an entry; one shared instance serves\n// pruneEntries, the admission probe and the batch preflight.\nconst EVICTION_HOOKS = { activityAt: entryActivityAt, holdsAcceptedCapture: entryHoldsAcceptedCapture };\n\nexport type { BufferSurpriseProbe } from \"./buffer-types.js\";\nimport type { BufferSurpriseProbe, SurpriseTelemetryQueueEntry } from \"./buffer-types.js\";\n\n// Raised from 200 in #3303: live captures were being dropped at busy hours\n// while the single extraction worker drained a backlog.\nconst FALLBACK_MAX_BUFFER_SESSIONS = 1000;\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\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  /** Which sessions' persisted files are stale (per-session incremental saves). */\n  private readonly persistence = new BufferSessionPersistence();\n\n  constructor(\n    private readonly config: PluginConfig,\n    private readonly storage: BufferStorage,\n    surpriseProbe: BufferSurpriseProbe | null = null,\n  ) {\n    this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };\n    this.surpriseProbe = surpriseProbe;\n  }\n\n  /** Distinct sessions admitted before backpressure; configurable (#3303, raised from 200). */\n  private get maxSessionEntries(): number {\n    // parseConfig defaults, validates, and floors bufferMaxSessions at the I/O\n    // boundary; FALLBACK_MAX_BUFFER_SESSIONS covers direct constructions with\n    // configs from before the knob existed.\n    return this.config.bufferMaxSessions ?? FALLBACK_MAX_BUFFER_SESSIONS;\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  /** Evict oldest entries past this.maxSessionEntries and queue their session files for deletion. */\n  private pruneEntries(retainKeys: string[], maxCount = this.maxSessionEntries): void {\n    const entries = this.state.entries;\n    if (!entries) return;\n    const evicted = selectEvictedBufferKeys(entries, retainKeys, maxCount, EVICTION_HOOKS);\n    for (const key of evicted) delete entries[key];\n    this.persistence.markEvicted(evicted);\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 = normalizeBufferState(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  /** Snapshot of buffered, not-yet-extracted work across sessions (#2151): session count,\n   * pending-turn total, oldest buffered turn. Counts retained (#562) + active turns per entry. */\n  async getBufferSnapshot(): Promise<ExtractionBufferSnapshot> {\n    await this.load();\n    let bufferedSessionCount = 0;\n    let pendingTurnCount = 0;\n    let oldestMs = Number.POSITIVE_INFINITY;\n    let oldestTurnTimestamp: string | null = null;\n    const consider = (turns: BufferTurn[] | undefined): void => {\n      if (!Array.isArray(turns) || turns.length === 0) return;\n      bufferedSessionCount += 1;\n      pendingTurnCount += turns.length;\n      const first = turns[0]?.timestamp;\n      const parsed = typeof first === \"string\" ? Date.parse(first) : Number.NaN;\n      if (Number.isFinite(parsed) && parsed < oldestMs) {\n        oldestMs = parsed;\n        oldestTurnTimestamp = first ?? null;\n      }\n    };\n    const entries = this.state.entries;\n    if (entries) {\n      // Retained turns (deferred #562) are pending too - count with active (oldest-first), like getTurns().\n      for (const entry of Object.values(entries)) consider([...(entry?.retainedTurns ?? []), ...(entry?.turns ?? [])]);\n    } else {\n      consider(this.state.turns);\n    }\n    return { bufferedSessionCount, pendingTurnCount, oldestTurnTimestamp };\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    for (const key of Object.keys(this.state.entries ?? {})) {\n      this.persistence.markDeleted(key);\n    }\n    this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };\n    this.loaded = true;\n  }\n\n  private async saveUnlocked(reconcile?: { key: string; drained: import(\"./buffer-turn-helpers.js\").DrainedTurnSets }): Promise<void> {\n    const { handedOver, drainedTurns } = await this.persistence.persist(this.storage, this.state, (key) => this.peekEntry(key) ?? undefined, reconcile);\n    // A drain tombstone: the turns the drain extracted leave this copy too,\n    // so a stale owner never extracts (or persists) them a second time.\n    for (const [key, drained] of drainedTurns) {\n      const entry = this.peekEntry(key);\n      if (!entry) continue;\n      entry.turns = subtractBufferTurns(entry.turns, drained.turns);\n      if (entry.retainedTurns && entry.retainedTurns.length > 0) {\n        entry.retainedTurns = subtractBufferTurns(entry.retainedTurns, drained.retainedTurns);\n        if (entry.retainedTurns.length === 0) delete entry.retainedTurns;\n      }\n      if (key === \"default\") this.state.turns = entry.turns;\n    }\n    if (handedOver.length === 0) return;\n    // A drain claim now owns these sessions' turns (durable in the claim\n    // file): drop the in-memory entries so this process cannot resurrect\n    // them. A later observe for the same key starts a fresh entry whose\n    // turns flow into the claim at the next handover.\n    const entries = this.state.entries;\n    if (!entries) return;\n    for (const key of handedOver) {\n      delete entries[key];\n      if (key === \"default\") {\n        this.state.turns = [];\n      }\n    }\n  }\n\n  /** Sync gate for the extraction queue: is this session claimed by a buffer drain? */\n  isSessionClaimed(key: string): boolean {\n    return this.storage.isBufferSessionClaimed?.(key) === true;\n  }\n\n  /** Per-key pending counts over the IN-MEMORY state (counts only — no turn\n   *  payloads), for the daemon backlog scheduler's bounded candidate scan. */\n  entryCounts(): Map<string, BufferEntryCounts> {\n    return bufferEntryCounts(this.state);\n  }\n\n  async save(reconcile?: { key: string; drained: import(\"./buffer-turn-helpers.js\").DrainedTurnSets }): Promise<void> {\n    await this.enqueueMutation(async () => this.saveUnlocked(reconcile));\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    // resetToEmpty-only deletions are pending work too, even with no\n    // pending-save flag set.\n    if (!this.pendingSave && !this.persistence.hasPending()) 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). resetToEmpty-only deletions also land here without a\n        // pending-save flag.\n        if (!this.pendingSave && !this.persistence.hasPending()) 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  /** Admit atomically; refuse at capacity rather than evict accepted work. */\n  async addTurnBounded(bufferKey: string, turn: BufferTurn): Promise<AddTurnOutcome | null> {\n    const mutation = await this.enqueueMutation(async () => {\n      await this.loadUnlocked();\n      if (this.peekEntry(bufferKey) === null) {\n        this.makeRoomForEntryUnlocked();\n        if (Object.keys(this.state.entries ?? {}).length >= this.maxSessionEntries) {\n          log.warn(\n            `buffer[${bufferKey}]: durable capture refused at the session-entry cap (${this.maxSessionEntries})`,\n          );\n          return null;\n        }\n      }\n      return this.recordTurnUnlocked(bufferKey, turn);\n    });\n    if (mutation === null) return null;\n    return this.completeAddTurnOutcome(bufferKey, turn, mutation);\n  }\n  /**\n   * Admit a multi-session durable capture as one capacity transaction.\n   * Preflight every new key under the mutation lock before persisting any\n   * turn; refusal records nothing and drops nothing.\n   */\n  async addTurnsBounded(\n    batches: readonly { bufferKey: string; turns: readonly BufferTurn[] }[],\n  ): Promise<Array<{ bufferKey: string; turn: BufferTurn; outcome: AddTurnOutcome }> | null> {\n    const pending = await this.enqueueMutation(async () => {\n      await this.loadUnlocked();\n      const additions: Array<{ bufferKey: string; turn: BufferTurn }> = [];\n      for (const batch of batches) {\n        for (const turn of batch.turns) {\n          additions.push({ bufferKey: batch.bufferKey, turn });\n        }\n      }\n\n      const entries = this.state.entries ?? {};\n      const newKeys = [...new Set(\n        additions\n          .map(({ bufferKey }) => bufferKey)\n          .filter((bufferKey) => this.peekEntry(bufferKey) === null),\n      )];\n      const count = Object.keys(entries).length;\n      const requiredEvictions = Math.max(0, count + newKeys.length - this.maxSessionEntries);\n      if (requiredEvictions > 0) {\n        const target = Math.max(0, this.maxSessionEntries - newKeys.length);\n        const evicted = selectEvictedBufferKeys(entries, newKeys, target, EVICTION_HOOKS);\n        if (newKeys.length > 0 && evicted.length < requiredEvictions) return null;\n        for (const key of evicted) delete entries[key];\n        this.persistence.markEvicted(evicted);\n      }\n\n      const recorded: Array<{ bufferKey: string; turn: BufferTurn; mutation: AddTurnMutationResult }> = [];\n      for (const { bufferKey, turn } of additions) {\n        recorded.push({ bufferKey, turn, mutation: await this.recordTurnUnlocked(bufferKey, turn) });\n      }\n      return recorded;\n    });\n    if (pending === null) return null;\n\n    const outcomes: Array<{ bufferKey: string; turn: BufferTurn; outcome: AddTurnOutcome }> = [];\n    for (const item of pending) {\n      outcomes.push({\n        bufferKey: item.bufferKey,\n        turn: item.turn,\n        outcome: await this.completeAddTurnOutcome(item.bufferKey, item.turn, item.mutation),\n      });\n    }\n    return outcomes;\n  }\n\n  /** Free one slot only when an empty entry can be reclaimed. */\n  private makeRoomForEntryUnlocked(): void {\n    const entries = this.state.entries ?? {};\n    const target = Math.max(0, this.maxSessionEntries - 1);\n    const pinned = Object.keys(entries).filter((k) => k === \"default\" || entryHoldsAcceptedCapture(entries[k]));\n    if (pinned.length <= target) this.pruneEntries([], target);\n  }\n\n  async addTurnWithOutcome(\n    bufferKey: string,\n    turn: BufferTurn,\n  ): Promise<AddTurnOutcome> {\n    const mutation = await this.enqueueMutation(async () => {\n      await this.loadUnlocked();\n      if (\n        this.peekEntry(bufferKey) === null &&\n        !canAdmitNewEntryUnlocked(this.state.entries ?? {}, bufferKey, this.maxSessionEntries, EVICTION_HOOKS)\n      ) {\n        throw new BufferAdmissionRefusedError(bufferKey, this.maxSessionEntries);\n      }\n      return this.recordTurnUnlocked(bufferKey, turn);\n    });\n    return this.completeAddTurnOutcome(bufferKey, turn, mutation);\n  }\n\n  /** Run probes outside the mutation lock to avoid reentrancy deadlocks. */\n  private async completeAddTurnOutcome(\n    bufferKey: string,\n    turn: BufferTurn,\n    mutation: AddTurnMutationResult,\n  ): Promise<AddTurnOutcome> {\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    if (decision !== \"keep_buffering\" && extractionTurns === undefined) {\n      extractionTurns = [\n        ...mutation.retainedTurnsSnapshot,\n        ...mutation.activeTurnsSnapshot,\n      ];\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 signal = scanSignals(turn.content, this.config.highSignalPatterns);\n    entry.turns.push(turn);\n    const decision = this.evaluate(entry, signal.level);\n    // Snapshots serve only extraction decisions and surprise-eligible keep_buffering turns (probe, smart mode, sub-high signal); steady-state buffering copies nothing.\n    const surpriseEligible = this.surpriseProbe !== null && this.config.triggerMode === \"smart\" && signal.level !== \"high\";\n    const snapshotsNeeded = decision !== \"keep_buffering\" || surpriseEligible;\n    const priorTurns = snapshotsNeeded ? entry.turns.slice(0, -1) : [];\n    const activeTurnsSnapshot = snapshotsNeeded ? entry.turns.map(copyBufferTurn) : [];\n    const retainedTurnsSnapshot = snapshotsNeeded ? (entry.retainedTurns ?? []).map(copyBufferTurn) : [];\n    if (bufferKey === \"default\") this.state.turns = entry.turns;\n    const turnCountInWindow = entry.turns.length;\n\n    this.persistence.markDirty(bufferKey);\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;\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    originalTurns?: readonly BufferTurn[],\n  ): Promise<void> {\n    await this.enqueueMutation(async () => {\n      await this.loadUnlocked();\n      const entry = this.entryFor(bufferKey);\n      const retained = selectRetainedDeferredTurns(\n        entry.retainedTurns ?? [], turns, max, originalTurns,\n      );\n      if (retained.length > 0) entry.retainedTurns = retained;\n      else delete entry.retainedTurns;\n      this.persistence.markDirty(bufferKey);\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  /**\n   * Clear deferred retention copies for a force-flushed session. Normal\n   * extraction preserves these copies so a deferred candidate can be retried;\n   * an explicit force flush is the caller's request to drain that context.\n   */\n  async clearRetainedTurnsForSession(\n    sessionKey: string,\n    ownerPrincipal?: string,\n    options: RetainedTurnCleanupOptions = {},\n  ): Promise<void> {\n    if (typeof sessionKey !== \"string\" || sessionKey.length === 0) return;\n    const normalizedOwnerPrincipal =\n      typeof ownerPrincipal === \"string\" && ownerPrincipal.trim().length > 0\n        ? ownerPrincipal.trim()\n        : undefined;\n    const namespacesEnabled = resolveNamespaceCapabilities(this.config).namespaces === true;\n    const normalizedCleanupNamespace =\n      namespacesEnabled && options.writeNamespaceOverride !== undefined && options.writeNamespaceOverride.length > 0\n        ? options.writeNamespaceOverride\n        : undefined;\n    const assertLifecycle = (): void => {\n      throwIfAborted(options.abortSignal, \"extraction force-flush aborted\");\n      if (typeof options.deadlineMs === \"number\" && Date.now() >= options.deadlineMs) {\n        throw new ExtractionDeadlineError(\"retained_turn_cleanup\");\n      }\n    };\n    assertLifecycle();\n    await this.enqueueMutation(async () => {\n      assertLifecycle();\n      const hadPendingSave = this.pendingSave;\n      if (this.saveTimer) {\n        clearTimeout(this.saveTimer);\n        this.saveTimer = null;\n      }\n      await this.loadUnlocked();\n      assertLifecycle();\n      const bufferKeys = this.matchingSessionBufferKeysUnlocked(sessionKey);\n      if (bufferKeys.length === 0) {\n        if (hadPendingSave) {\n          assertLifecycle();\n          await this.saveNowRetainingPendingOnFailure(\"clearRetainedTurnsForSession\");\n        }\n        return;\n      }\n      let changed = false;\n      const matchesCleanupScope = (turn: BufferTurn): boolean => {\n        // Legacy unpinned turns keep their existing cleanup semantics.\n        if (\n          turn.writeNamespaceOverride !== undefined &&\n          normalizedCleanupNamespace !== undefined &&\n          turn.writeNamespaceOverride !== normalizedCleanupNamespace\n        ) {\n          return false;\n        }\n        // Equal write namespaces can still belong to different project bindings.\n        if (options.scopeProfileWritePlan && hasPinnedCaptureScope(turn)) {\n          if (\n            scopeProfilePlanIdentity(turn.scopeProfileWritePlan) !== scopeProfilePlanIdentity(options.scopeProfileWritePlan) &&\n            !(turn.acceptedCapture === true && turn.scopeProfileWritePlan === undefined)\n          ) {\n            return false;\n          }\n          const ctx = options.codingContext;\n          if (\n            ctx && turn.codingContext &&\n            (turn.codingContext.projectId !== ctx.projectId ||\n              turn.codingContext.rootPath !== ctx.rootPath ||\n              turn.codingContext.branch !== ctx.branch ||\n              turn.codingContext.defaultBranch !== ctx.defaultBranch)\n          ) {\n            return false;\n          }\n        }\n        return true;\n      };\n      const belongsToOwner = (turn: BufferTurn): boolean => {\n        if (turn.sessionKey !== sessionKey) return false;\n        if (!matchesCleanupScope(turn)) return false;\n        if (normalizedOwnerPrincipal === undefined) return true;\n        if (turn.sessionOwnerPrincipal === normalizedOwnerPrincipal) return true;\n        return (\n          turn.sessionOwnerPrincipal === undefined &&\n          resolvePrincipal(turn.sessionKey, this.config) === normalizedOwnerPrincipal\n        );\n      };\n      for (const bufferKey of bufferKeys) {\n        const entry = this.entryFor(bufferKey);\n        const retainedTurns = entry.retainedTurns ?? [];\n        const remainingTurns = retainedTurns.filter((turn) => !belongsToOwner(turn));\n        if (remainingTurns.length === retainedTurns.length) continue;\n        changed = true;\n        if (remainingTurns.length > 0) entry.retainedTurns = remainingTurns;\n        else delete entry.retainedTurns;\n        if (bufferKey === \"default\") this.state.turns = entry.turns;\n        this.persistence.markDirty(bufferKey);\n      }\n      if (changed || hadPendingSave) {\n        assertLifecycle();\n        await this.saveNowRetainingPendingOnFailure(\"clearRetainedTurnsForSession\");\n      }\n      assertLifecycle();\n    });\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  private matchingSessionBufferKeysUnlocked(sessionKey: string): string[] {\n    const matches: string[] = [];\n    const hasSessionTurns = (entry: BufferEntryState | null | undefined): boolean =>\n      [...(entry?.turns ?? []), ...(entry?.retainedTurns ?? [])].some(\n        (turn) => typeof turn.sessionKey === \"string\" && turn.sessionKey === sessionKey,\n      );\n    const directEntry = this.peekEntry(sessionKey);\n    if (hasSessionTurns(directEntry)) {\n      matches.push(sessionKey);\n    }\n\n    const entries = this.state.entries ?? {};\n    for (const [bufferKey, entry] of Object.entries(entries)) {\n      if (!matches.includes(bufferKey) && hasSessionTurns(entry)) {\n        matches.push(bufferKey);\n      }\n    }\n\n    return matches;\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    return this.matchingSessionBufferKeysUnlocked(sessionKey);\n  }\n\n  async clearAfterExtraction(\n    bufferKey = \"default\",\n    extractedTurns?: readonly BufferTurn[],\n    options?: { allowNonPrefix?: boolean },\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          if (options?.allowNonPrefix === true) {\n            const remainingTurns = [...entry.turns];\n            for (const extractedTurn of liveExtractedTurns) {\n              const matchingIndex = remainingTurns.findIndex((liveTurn) =>\n                bufferTurnsEqual(liveTurn, extractedTurn),\n              );\n              if (matchingIndex >= 0) {\n                remainingTurns.splice(matchingIndex, 1);\n                clearedLiveTurns = true;\n              }\n            }\n            if (clearedLiveTurns) entry.turns = remainingTurns;\n          } else {\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            }\n          }\n          if (!clearedLiveTurns) {\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.persistence.markDirty(bufferKey);\n      this.pruneEntries([bufferKey]);\n      await this.saveNowRetainingPendingOnFailure(\"clearAfterExtraction\");\n    });\n  }\n\n  /**\n   * Remove an extraction-window chunk from the buffer WITHOUT recording an\n   * extraction (trigger-drain drop path). Used when a chunk fails extraction\n   * repeatedly and must be dropped so the session can drain; the caller is\n   * responsible for the side-file copy and logging. Returns the number of\n   * live turns dropped; 0 when the turns no longer match. `allowNonPrefix`\n   * matches by identity, like `clearAfterExtraction`, for callers (native\n   * groups) whose chunk can sit behind a pinned capture.\n   */\n  async dropExtractionChunk(\n    bufferKey = \"default\",\n    turns: readonly BufferTurn[],\n    options?: { allowNonPrefix?: boolean },\n  ): Promise<number> {\n    return await this.enqueueMutation(async () => {\n      await this.loadUnlocked();\n      const entry = this.entryFor(bufferKey);\n      // A window's head can be deferred-retained turns (retainDeferredTurns): take those out of the chunk first.\n      const retained = [...(entry.retainedTurns ?? [])];\n      const liveTurns: BufferTurn[] = [];\n      for (const turn of turns) {\n        const at = retained.findIndex((kept) => bufferTurnsEqual(kept, turn));\n        if (at >= 0) retained.splice(at, 1);\n        else liveTurns.push(turn);\n      }\n      const retainedDropped = (entry.retainedTurns?.length ?? 0) - retained.length;\n      let remaining = entry.turns;\n      if (options?.allowNonPrefix === true) {\n        remaining = [...entry.turns];\n        for (const turn of liveTurns) {\n          const at = remaining.findIndex((live) => bufferTurnsEqual(live, turn));\n          if (at >= 0) remaining.splice(at, 1);\n        }\n      } else {\n        remaining = entry.turns.slice(matchingQueuedExtractionPrefixLength(entry.turns, liveTurns));\n      }\n      const matchedCount = entry.turns.length - remaining.length + retainedDropped;\n      if (matchedCount === 0) return 0;\n      if (this.saveTimer) {\n        clearTimeout(this.saveTimer);\n        this.saveTimer = null;\n      }\n      entry.turns = remaining;\n      if (retainedDropped > 0) {\n        if (retained.length > 0) entry.retainedTurns = retained;\n        else delete entry.retainedTurns;\n      }\n      if (bufferKey === \"default\") {\n        this.state.turns = entry.turns;\n      }\n      this.persistence.markDirty(bufferKey);\n      this.pruneEntries([bufferKey]);\n      await this.saveNowRetainingPendingOnFailure(\"dropExtractionChunk\");\n      return matchedCount;\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"],"mappings":"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","names":[]}

package/dist/{chunk-E7V5AK7I.js → chunk-TRMZHGIX.js}

@@ -1,3 +1,6 @@
+import {
+  applyCarriedMemorySnippets
+} from "./chunk-SP4DB6SX.js";
 import {
   entityMentionCacheGeneration,
   entityMentionIdentity,
@@ -23,9 +26,6 @@ import {
   detectEntityQueryMode,
   isStructuralEntityFollowUpQuery
 } from "./chunk-MKYRCCSN.js";
-import {
-  applyCarriedMemorySnippets
-} from "./chunk-SP4DB6SX.js";
 import {
   collectNativeKnowledgeChunks
 } from "./chunk-2DQ2XREU.js";
@@ -34,14 +34,14 @@ import {
 } from "./chunk-NVKO5YKP.js";
 import {
   compareEntityTimestamps
-} from "./chunk-ELWI2R6H.js";
+} from "./chunk-CC4V7HNP.js";
+import {
+  normalizeEntityName
+} from "./chunk-YXZG5TVN.js";
 import {
   normalizeEntityText,
   resolveRequestedEntitySectionKeys
 } from "./chunk-ZIKENA2C.js";
-import {
-  normalizeEntityName
-} from "./chunk-YXZG5TVN.js";
 import {
   truncateGraphemeSafe
 } from "./chunk-PJKTFXE2.js";
@@ -927,4 +927,4 @@ export {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours
 };
-//# sourceMappingURL=chunk-E7V5AK7I.js.map
+//# sourceMappingURL=chunk-TRMZHGIX.js.map

package/dist/{chunk-WBDIZWJQ.js → chunk-TSS3D7ZY.js}

@@ -1,6 +1,6 @@
 import {
   isGenericRecallExcludedPath
-} from "./chunk-WYPCJK6K.js";
+} from "./chunk-QKERFEJS.js";
 import {
   normalizeProjectionPreview
 } from "./chunk-SCU65EZI.js";
@@ -209,4 +209,4 @@ export {
   browsePatternMatches,
   runMemoryBrowse
 };
-//# sourceMappingURL=chunk-WBDIZWJQ.js.map
+//# sourceMappingURL=chunk-TSS3D7ZY.js.map

package/dist/{chunk-HVFX2N2G.js → chunk-UAUV3BWS.js}

@@ -8,13 +8,10 @@ import {
 } from "./chunk-MPC7TYTZ.js";
 import {
   importCapsule
-} from "./chunk-JFH6JAGY.js";
+} from "./chunk-G67EUQAB.js";
 import {
   isSharedContextWriteInputError
 } from "./chunk-IFBSZGW3.js";
-import {
-  UNATTRIBUTED_ACCESS_WRITE_ORIGIN
-} from "./chunk-OGXXGHW6.js";
 import {
   ACTIVE_DECISION_STATUSES,
   CodegraphRuntimeError,
@@ -34,14 +31,17 @@ import {
   serializeDecisionRecord
 } from "./chunk-TFEHSPGQ.js";
 import {
-  WriteQuarantineStore
-} from "./chunk-BANSBRNX.js";
+  UNATTRIBUTED_ACCESS_WRITE_ORIGIN
+} from "./chunk-OGXXGHW6.js";
 import {
   WHO_KNOWS_DEFAULT_LIMIT,
   computeWhoKnows,
   loadWhoKnowsEntities,
   validateWhoKnowsInput
-} from "./chunk-Y43X3E24.js";
+} from "./chunk-IBDWYRDR.js";
+import {
+  WriteQuarantineStore
+} from "./chunk-BANSBRNX.js";
 import {
   trustResultFor
 } from "./chunk-GNVZQ5JN.js";
@@ -59,7 +59,7 @@ import {
 } from "./chunk-JWX2Q6HS.js";
 import {
   summarizeHourlyStatus
-} from "./chunk-ZWTHVUT5.js";
+} from "./chunk-3UZ2VMKD.js";
 import {
   planSessionTranscriptMigration
 } from "./chunk-WWDO7ZWM.js";
@@ -68,7 +68,10 @@ import {
 } from "./chunk-45VUHDV2.js";
 import {
   runRecallWhy
-} from "./chunk-VZELUMKK.js";
+} from "./chunk-NQP4ZYGG.js";
+import {
+  renderNavigationResult
+} from "./chunk-KIW3OOZE.js";
 import {
   DEFAULT_TRAVERSE_LIMIT,
   selectTraverseNeighbors
@@ -77,8 +80,8 @@ import {
   assertIdInNavigationWindow
 } from "./chunk-5KVT6G5U.js";
 import {
-  renderNavigationResult
-} from "./chunk-KIW3OOZE.js";
+  takeNavigateBudget
+} from "./chunk-VYDGHJIN.js";
 import {
   planDisclosureStep
 } from "./chunk-KZSGBWOJ.js";
@@ -95,27 +98,24 @@ import {
   estimateRecallTokens,
   summarizeDisclosureTokens
 } from "./chunk-7O2MC42R.js";
-import {
-  takeNavigateBudget
-} from "./chunk-VYDGHJIN.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-E5QEF3JO.js";
+} from "./chunk-YRZPBN46.js";
 import {
   ReplicaDivergenceMonitor
-} from "./chunk-B6SPPYGJ.js";
+} from "./chunk-7IWRLYFJ.js";
 import {
   buildEmbeddingAwareSnapshotStream
-} from "./chunk-FMFCQRDM.js";
+} from "./chunk-ZANNIXXE.js";
 import {
   recordMemoryOutcome
 } from "./chunk-UD7UNYRD.js";
 import {
   runMemoryBrowse
-} from "./chunk-WBDIZWJQ.js";
+} from "./chunk-TSS3D7ZY.js";
 import {
   isSearchExcludedPath
-} from "./chunk-WYPCJK6K.js";
+} from "./chunk-QKERFEJS.js";
 import {
   coerceIncludedMemories
 } from "./chunk-2YA5N2BY.js";
@@ -124,16 +124,16 @@ import {
 } from "./chunk-YLTU2DC4.js";
 import {
   readProjectedHarmonicGraph
-} from "./chunk-GBOYOL5L.js";
+} from "./chunk-3PJEDHLD.js";
 import {
   wrapWorkLayerContext
 } from "./chunk-EI6V5UXY.js";
 import {
   CONNECTOR_LABEL_MAX_LENGTH
-} from "./chunk-JX3E4XCW.js";
+} from "./chunk-PDOOUXCS.js";
 import {
   isValidConnectorId
-} from "./chunk-QA3Y2O6H.js";
+} from "./chunk-YAVIBVCU.js";
 import {
   formatProfileTraceAscii
 } from "./chunk-DOWACHYO.js";
@@ -154,6 +154,9 @@ import {
   composeRecallContext,
   renderAuthorityBoundContent
 } from "./chunk-NVKO5YKP.js";
+import {
+  callDeepRecallPolicyLlm
+} from "./chunk-ZGFLIK5H.js";
 import {
   renderDeepRecallResult
 } from "./chunk-RF2SMMPP.js";
@@ -163,13 +166,14 @@ import {
 import {
   runBudgetedDeepRecall
 } from "./chunk-HXFIILGF.js";
+import {
+  CorpusWatermarkCache,
+  computeServiceCorpusCensus
+} from "./chunk-D5EV6Y2L.js";
 import {
   CrossNamespaceBudget,
   toBudgetWarning
 } from "./chunk-UFGFMWAD.js";
-import {
-  callDeepRecallPolicyLlm
-} from "./chunk-ZGFLIK5H.js";
 import {
   buildProposedActions,
   buildQualityScore,
@@ -177,30 +181,30 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-VCVEMQJK.js";
+} from "./chunk-JM2YZKCQ.js";
 import {
-  CorpusWatermarkCache,
-  computeServiceCorpusCensus
-} from "./chunk-CCU7URRP.js";
+  ExtractionDeadlineError
+} from "./chunk-BIVKPQ6Q.js";
 import {
   LocalLlmClient
-} from "./chunk-73YVMZ7D.js";
+} from "./chunk-2G4TV2ML.js";
+import {
+  isCapsuleImportArchiveInputError,
+  validateCapsuleImportArchive
+} from "./chunk-FKBGK3NC.js";
 import {
   defaultCapsulesDir
 } from "./chunk-ZY2MNJR6.js";
-import {
-  ExtractionDeadlineError
-} from "./chunk-4IWEPQEV.js";
 import {
   FileCalendarSource,
   buildBriefing,
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-GJVGFKOU.js";
+} from "./chunk-CYCEROPR.js";
 import {
   withBriefingDeadline
-} from "./chunk-X2KO4FK5.js";
+} from "./chunk-FNFURZBZ.js";
 import {
   CORRECTION_TEXT_MAX,
   CorrectionContractError,
@@ -227,7 +231,7 @@ import {
 } from "./chunk-AWD36R4D.js";
 import {
   resolveEffectiveDeepRecallConfig
-} from "./chunk-AJG2TAMR.js";
+} from "./chunk-IEEV27BC.js";
 import {
   buildProcedurePersistBody,
   normalizeProcedureSteps,
@@ -236,19 +240,19 @@ import {
 import {
   filterTrajectoriesByLookbackDays,
   readCausalTrajectoryRecords
-} from "./chunk-VEFGHRKV.js";
+} from "./chunk-ZOJUWVAU.js";
 import {
   parseEntityFile,
   parseFrontmatter,
   qmdCollectionPathParts,
   qmdResultPathCandidates,
   selfDeps
-} from "./chunk-ELWI2R6H.js";
+} from "./chunk-CC4V7HNP.js";
 import {
   embeddingBacklogExceeds,
   isSearchHealthDegraded,
   namespaceCollectionName
-} from "./chunk-H34INI3P.js";
+} from "./chunk-KVSOEVAF.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -284,7 +288,7 @@ import {
   groupTurnsByExtractionScope,
   hasPinnedCaptureScope,
   scopeProfilePlanIdentity
-} from "./chunk-WLNWFHX3.js";
+} from "./chunk-UXXK523X.js";
 import {
   delegateExtractionForceFlush
 } from "./chunk-RMMA44HE.js";
@@ -331,7 +335,7 @@ import {
 } from "./chunk-YLXETSAH.js";
 import {
   splitCanonicalWriteRequest
-} from "./chunk-YNBMBL4C.js";
+} from "./chunk-4XYAWK5H.js";
 import {
   buildWithBriefingLocation,
   daySummaryAutoOptions
@@ -353,16 +357,16 @@ import {
 } from "./chunk-R6HMAIKM.js";
 import {
   reapplyCategoryCoercion
-} from "./chunk-GYNRNKMW.js";
+} from "./chunk-YMJRLT7S.js";
 import {
   exportCapsule
-} from "./chunk-BUKK5SWA.js";
+} from "./chunk-7LCGFUMB.js";
 import {
   evaluateActionConfidence
 } from "./chunk-Z2YFLXHU.js";
 import {
   createOfflineSyncManifestStream
-} from "./chunk-KHZVAISH.js";
+} from "./chunk-UWRHHRDK.js";
 import {
   offlineSyncStorageForSnapshot
 } from "./chunk-TIGYOZBU.js";
@@ -390,12 +394,13 @@ import {
   displayErrorDetail
 } from "./chunk-RL6NEVXT.js";
 import {
+  assertNamespaceAllowed,
   assertOperationAuthorizationAllowed,
   capabilityAllowsOp,
   enforceNamespaceAllowList,
   isNamespaceAllowed,
   tokenCapabilityStore
-} from "./chunk-YO2JEX2Z.js";
+} from "./chunk-OGBQMY46.js";
 import {
   SUPPORT_PASSPORT_ATTRIBUTE_KEYS,
   SUPPORT_PASSPORT_CARD_TAG,
@@ -445,7 +450,7 @@ import {
   buildOfflineSyncSnapshotFromBase,
   normalizeOfflineSyncChangeset,
   readOfflineSyncFileContentChunk
-} from "./chunk-CLVILSBR.js";
+} from "./chunk-OZNBZJ3S.js";
 import {
   compileOfflineSyncExcludeGlobs
 } from "./chunk-63LFM77Z.js";
@@ -464,7 +469,7 @@ import {
   memorySearchThroughScope,
   mergeMemorySearchDefaultFallback,
   resolveMemorySearchDefaultFallback
-} from "./chunk-S5CQI2KF.js";
+} from "./chunk-B3GKQ6DU.js";
 import {
   canReadNamespace,
   canWriteNamespace,
@@ -519,7 +524,7 @@ import {
   EngramAccessForbiddenError,
   EngramAccessInputError,
   NamespaceNotWritableError
-} from "./chunk-LGEH473S.js";
+} from "./chunk-CJCTKL6Y.js";
 import {
   abortError,
   isAbortError,
@@ -561,11 +566,9 @@ import {
 
 // src/access-service.ts
 import { createHash as createHash13 } from "crypto";
-import { constants as fsConstants2 } from "fs";
 import { readdirSync, unlinkSync } from "fs";
 import { stat as stat3 } from "fs/promises";
 import * as nodeFs2 from "fs/promises";
-import { ZodError } from "zod";
 
 // src/coding/decision-surfaces.ts
 var DECISION_SUBCOMMANDS = [
@@ -4324,6 +4327,12 @@ function defineOperation(spec) {
         throw new EngramAccessInputError(formatZodIssues(parseResult.error));
       }
       assertOperationAuthorizationAllowed(tokenCapabilityStore.getStore(), spec);
+      if (operationRequiresAuthorizedNamespace(spec.name)) {
+        const parsedNamespace = parseResult.data.namespace;
+        if (parsedNamespace) {
+          assertNamespaceAllowed(tokenCapabilityStore.getStore(), parsedNamespace);
+        }
+      }
       return spec.handler(parseResult.data, { ...ctx, rawInput });
     }
   };
@@ -17972,6 +17981,9 @@ var EngramAccessService = class extends SupportPassportAccessServiceBase {
    * `versioning` defaults to the orchestrator's page-versioning config so
    * `mode: "overwrite"` automatically snapshots prior content without the
    * caller having to construct the config object.
+   *
+   * Remote callers (HTTP and MCP) may only import from the destination
+   * namespace's capsule store; the CLI keeps unrestricted local paths.
    */
   async capsuleImport(opts) {
     const { namespace, principal, root: explicitRoot, memoryDir: explicitMemoryDir, ...importOptions } = opts;
@@ -17984,47 +17996,17 @@ var EngramAccessService = class extends SupportPassportAccessServiceBase {
       maxVersionsPerPage: this.orchestrator.config.versioningMaxPerPage,
       sidecarDir: this.orchestrator.config.versioningSidecarDir
     };
-    await this.validateCapsuleImportArchivePath(importOptions.archivePath);
+    await validateCapsuleImportArchive(importOptions.archivePath, storage.dir);
     try {
       return await importCapsule({ ...importOptions, root, memoryDir, versioning });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      if (this.isCapsuleImportArchiveInputError(err, message)) {
+      if (isCapsuleImportArchiveInputError(err, message)) {
         throw new EngramAccessInputError(`capsule import failed: ${message}`);
       }
       throw err;
     }
   }
-  async validateCapsuleImportArchivePath(archivePath) {
-    let archiveStat;
-    try {
-      archiveStat = await stat3(archivePath);
-    } catch (err) {
-      if (!this.isCapsuleImportPathInputFsError(err)) throw err;
-      const message = err instanceof Error ? err.message : String(err);
-      throw new EngramAccessInputError(`capsule import failed: archive is not readable: ${message}`);
-    }
-    if (!archiveStat.isFile()) {
-      throw new EngramAccessInputError("capsule import failed: archivePath must point to a file");
-    }
-    try {
-      await nodeFs2.access(archivePath, fsConstants2.R_OK);
-    } catch (err) {
-      if (!this.isCapsuleImportPathInputFsError(err)) throw err;
-      const message = err instanceof Error ? err.message : String(err);
-      throw new EngramAccessInputError(`capsule import failed: archive is not readable: ${message}`);
-    }
-  }
-  isCapsuleImportPathInputFsError(err) {
-    const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
-    return code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "EPERM" || code === "ELOOP";
-  }
-  isCapsuleImportArchiveInputError(err, message) {
-    if (err instanceof ZodError) return true;
-    const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
-    if (typeof code === "string" && code.startsWith("Z_")) return true;
-    return message.startsWith("importCapsule: archive") || message.startsWith("importCapsule: bundle") || message.startsWith("importCapsule: manifest") || message.startsWith("importCapsule: record") || /incorrect header check|invalid stored block lengths|not in gzip format|unexpected end of file/i.test(message);
-  }
   /**
    * Export a capsule archive from the orchestrator's memory directory.
    *
@@ -18804,4 +18786,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-HVFX2N2G.js.map
+//# sourceMappingURL=chunk-UAUV3BWS.js.map