@remnic/core 10.0.83 → 10.0.85

package/dist/chunk-ONN2E5QD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/orchestration/buffer-drain-runner.ts"],"sourcesContent":["/** Claim-backed extraction-buffer drain (`remnic buffer drain` worker AND the */\n\nimport { hostname } from \"node:os\";\nimport type { BufferStorage } from \"../buffer-persistence.js\";\nimport { type ExtractionScopeGroup, describeError, groupTurnsByExtractionScope } from \"../buffer-turn-helpers.js\";\nimport { SmartBuffer } from \"../buffer.js\";\nimport { resolveMemoryLifecycleCapabilities } from \"../capabilities.js\";\nimport { shouldSkipImplicitExtraction } from \"../explicit-capture.js\";\nimport { log } from \"../logger.js\";\nimport type { ResolvedScopeProfilePlan } from \"../namespaces/scope-profiles.js\";\nimport type { Orchestrator } from \"../orchestrator.js\";\nimport { headerConnector, renderExtractionConversation, resolveSourceConnector } from \"../source-agent-qualifier.js\";\nimport type { BufferDrainClaims, DrainLease } from \"../storage/buffer-drain-claims.js\";\nimport type { BufferEntryState, BufferState, BufferTurn, PluginConfig } from \"../types.js\";\nimport { ExtractionDrain } from \"./extraction-drain.js\";\nimport type { ExtractionRunResult } from \"./extraction-run.js\";\nimport { selfDeps } from \"./self-deps.js\";\nimport { TurnIngestionCoordinator, type TurnIngestionDeps } from \"./turn-ingestion.js\";\n\nexport type DrainSessionStatus = \"drained\" | \"deferred\" | \"failed\" | \"skipped\";\n\nexport interface DrainSessionOutcome {\n  key: string;\n  status: DrainSessionStatus;\n  /** Turns the claim held when the drain started. */\n  turnsAtStart: number;\n  /** Turns still in the claim when the drain stopped. */\n  turnsRemaining: number;\n  /** Facts the extraction persisted during this run. */\n  persistedCount: number;\n  /** Durable outputs (memories + entities) the extraction wrote. */\n  durableOutputCount: number;\n  /** Why the session was skipped or deferred (machine-readable). */\n  reason?: string;\n  /** Current-policy denials: scope groups whose authorization no longer holds. */\n  denied?: { reason: string; turns: number }[];\n}\n\n/** Extraction results that mean \"current policy refuses this scope\": the\n * turns are valid backlog whose captured scope is no longer writable. */\nconst DENIED_SCOPE_REASONS: ReadonlySet<string> = new Set([\n  \"pinned_namespace_unavailable\",\n  \"namespace_write_revoked\",\n  \"scope_profile_revoked\",\n  // The resolved profile has no writable layer: the same current-policy\n  // refusal family, surfaced from inside the shared runExtraction gate.\n  \"scope_profile_no_writable_layer\",\n  // captureMode=explicit: ordinary buffered conversation turns never create\n  // memories; only deliberately accepted captures drain.\n  \"capture_mode_explicit\",\n]);\n\nexport interface BufferDrainRunnerOptions {\n  /** Identity of this drainer; owns the lease it takes. */\n  ownerId: string;\n  /** Lease lifetime in ms. The heartbeat keeps it alive while draining. */\n  leaseMs?: number;\n  /** Cancels the run at the next chunk boundary. */\n  signal?: AbortSignal;\n  /** Progress callback (per session, and per claim transition). */\n  onEvent?: (event: DrainRunnerEvent) => void;\n}\n\n/** A failed drain run: the reason a chunk or the session could not finish. */\nexport type DrainExtractionError = Error;\n\nexport type DrainRunnerEvent =\n  | { type: \"session_started\"; key: string; turns: number }\n  | { type: \"session_finished\"; key: string; outcome: DrainSessionOutcome };\n\nconst DEFAULT_LEASE_MS = 120_000;\n\n/**\n * A `BufferStorage` view of one drain claim: the claim file IS the buffer.\n * Writes are the drain's progress (what is left to extract), so every\n * successfully extracted chunk is durably removed before the next one runs.\n *\n * `seen` is the drainer's own view of the claim: the entry it loaded, then the\n * entry it last wrote. Each progress write is diffed against it, so a write\n * records only the turns extracted since the previous one.\n */\nexport class ClaimBufferStorage implements BufferStorage {\n  private seen: BufferEntryState;\n\n  constructor(\n    private readonly claims: BufferDrainClaims,\n    private readonly key: string,\n    private readonly ownerId: string,\n    entry: BufferEntryState\n  ) {\n    this.seen = entry;\n  }\n\n  async loadBuffer(): Promise<BufferState> {\n    const entries: NonNullable<BufferState[\"entries\"]> = Object.create(null);\n    entries[this.key] = {\n      turns: this.seen.turns,\n      retainedTurns: this.seen.retainedTurns,\n      lastExtractionAt: this.seen.lastExtractionAt,\n      extractionCount: this.seen.extractionCount,\n    };\n    return {\n      turns: this.seen.turns,\n      lastExtractionAt: this.seen.lastExtractionAt,\n      extractionCount: this.seen.extractionCount,\n      entries,\n    };\n  }\n\n  async saveBuffer(state: BufferState): Promise<void> {\n    // Whole-state fallback (the claim covers one session): persist the entry.\n    const entry = state.entries?.[this.key];\n    await this.writeProgress(entry ?? { turns: [], lastExtractionAt: null, extractionCount: 0 });\n  }\n\n  async saveBufferSession(key: string, entry: BufferEntryState): Promise<void> {\n    if (key !== this.key) {\n      await this.claims.writeEntry(key, this.ownerId, entry, undefined);\n      return;\n    }\n    await this.writeProgress(entry);\n  }\n\n  private async writeProgress(entry: BufferEntryState): Promise<void> {\n    await this.claims.writeEntry(this.key, this.ownerId, entry, this.seen);\n    // Copy the lists: the buffer keeps mutating its own arrays after a save.\n    this.seen = { ...entry, turns: [...entry.turns], retainedTurns: entry.retainedTurns ? [...entry.retainedTurns] : undefined };\n  }\n\n  async deleteBufferSession(): Promise<void> {\n    // The claim is removed by the ack path, never by a buffer eviction: the\n    // drain decides when the session is finished.\n  }\n}\n\n/** Per-invocation isolated execution context for one claim drain. */\ninterface ClaimDrainExecution {\n  claimBuffer: SmartBuffer;\n  coordinator: TurnIngestionCoordinator;\n  executionDrain: ExtractionDrain;\n}\n\n/** The scopeProfileWritePlan option a scope group forwards to the queue. */\ninterface GroupPlanOption {\n  scopeProfileWritePlan?: ResolvedScopeProfilePlan | null;\n}\n\n/** Durable counters a drain pass contributed. */\ninterface GroupCounts {\n  persistedCount: number;\n  durableOutputCount: number;\n}\n\n/** Pending turns across canonical + retained copies (the honest backlog count). */\nfunction pendingTurnCount(entry: BufferEntryState | undefined): number {\n  if (!entry) return 0;\n  return entry.turns.length + (entry.retainedTurns?.length ?? 0);\n}\n\n/** Load one claimed session. An unclaimed key is nothing to drain. */\nasync function loadClaimedSession(\n  claims: BufferDrainClaims,\n  key: string\n): Promise<\n  | { kind: \"notClaimed\"; notClaimed: DrainSessionOutcome }\n  | { kind: \"claimed\"; claim: { entry: BufferEntryState }; turnsAtStart: number }\n> {\n  const claim = await claims.load(key);\n  if (!claim) {\n    return {\n      kind: \"notClaimed\",\n      notClaimed: {\n        key,\n        status: \"skipped\",\n        turnsAtStart: 0,\n        turnsRemaining: 0,\n        persistedCount: 0,\n        durableOutputCount: 0,\n        reason: \"not_claimed\",\n      },\n    };\n  }\n  return { kind: \"claimed\", claim, turnsAtStart: pendingTurnCount(claim.entry) };\n}\n\nfunction busyLeaseOutcome(key: string, turnsAtStart: number): DrainSessionOutcome {\n  return {\n    key,\n    status: \"skipped\",\n    turnsAtStart,\n    turnsRemaining: turnsAtStart,\n    persistedCount: 0,\n    durableOutputCount: 0,\n    reason: \"claimed_by_another_drain\",\n  };\n}\n\n/** Take the lease unless this drainer already holds it. A busy lease means\n *  another drainer owns the claim — skip without touching content. */\nasync function adoptLease(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  leaseMs: number\n): Promise<DrainSessionOutcome | null> {\n  const held = await claims.adopt(key, {\n    ownerId,\n    pid: process.pid,\n    host: hostname(),\n    acquiredAt: new Date().toISOString(),\n    heartbeatAt: new Date().toISOString(),\n    leaseMs,\n  });\n  return held === \"busy\" ? busyLeaseOutcome(key, pendingTurnCount((await claims.load(key))?.entry)) : null;\n}\n\nfunction assembleOutcome(\n  key: string,\n  turnsAtStart: number,\n  verdict: { status: DrainSessionStatus; reason?: string; turnsRemaining: number },\n  counts: { persistedCount: number; durableOutputCount: number },\n  denied: Map<string, number>\n): DrainSessionOutcome {\n  const outcome: DrainSessionOutcome = {\n    key,\n    status: verdict.status,\n    turnsAtStart,\n    turnsRemaining: verdict.turnsRemaining,\n    persistedCount: counts.persistedCount,\n    durableOutputCount: counts.durableOutputCount,\n  };\n  if (denied.size > 0) outcome.denied = [...denied].map(([deniedReason, turns]) => ({ reason: deniedReason, turns }));\n  if (verdict.reason !== undefined) outcome.reason = verdict.reason;\n  return outcome;\n}\n\n/** Ack an EMPTY claim. The ack verdict is the truth: live ingress can merge\n *  between the empty read and the ack — a not_empty ack means pending work\n *  exists; reload it, release OUR lease, report deferred, never a false\n *  drained. */\nasync function ackEmptyClaim(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  turnsAtStart: number\n): Promise<DrainSessionOutcome> {\n  const ackOutcome = await claims.ack(key, ownerId);\n  if (ackOutcome !== \"acked\") {\n    const reloaded = await claims.load(key);\n    const turnsRemaining = pendingTurnCount(reloaded?.entry);\n    await claims.releaseLease(key, ownerId);\n    return {\n      key,\n      status: \"deferred\",\n      turnsAtStart,\n      turnsRemaining,\n      persistedCount: 0,\n      durableOutputCount: 0,\n      reason: ackOutcome === \"not_empty\" ? \"ack_not_empty\" : \"ack_not_owner\",\n    };\n  }\n  return { key, status: \"drained\", turnsAtStart, turnsRemaining: 0, persistedCount: 0, durableOutputCount: 0 };\n}\n\n/** another drainer took the claim, so this run must stop instead of writing */\nfunction startLeaseHeartbeat(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  leaseMs: number,\n  abort: AbortController\n): NodeJS.Timeout {\n  const heartbeat = setInterval(\n    () => {\n      void claims\n        .heartbeat(key, ownerId, leaseMs)\n        .then((state) => {\n          if (state === \"lost\") abort.abort(new Error(`buffer drain: lease lost for session ${key}`));\n        })\n        .catch((err: Error) => {\n          // A heartbeat that cannot be renewed is a lease that cannot be held:\n          // stop this run cleanly at the next chunk boundary (the next run\n          // resumes it).\n          abort.abort(new Error(`buffer drain: lease heartbeat failed for session ${key}: ${describeError(err)}`));\n        });\n    },\n    Math.max(1_000, Math.floor(leaseMs / 3))\n  );\n  heartbeat.unref?.();\n  return heartbeat;\n}\n\n/** coordinator bound to it, and the no-drop chunked drain. Built per */\nfunction buildClaimExecution(\n  orchestrator: Orchestrator,\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  claim: { entry: BufferEntryState }\n): ClaimDrainExecution {\n  const claimBuffer = new SmartBuffer(orchestrator.config, new ClaimBufferStorage(claims, key, ownerId, claim.entry));\n  const isolatedRun = orchestrator.extractionRunCoordinatorForBuffer(claimBuffer);\n  const coordinator = new TurnIngestionCoordinator(selfDeps<TurnIngestionDeps>(orchestrator));\n  const config = orchestrator.config;\n  const ingestionDeps = selfDeps<TurnIngestionDeps>(orchestrator);\n  // No-drop: a repeatedly failing chunk stays in the claim as durable\n  // retryable backlog — never side-filed, never counted as processed.\n  const executionDrain = new ExtractionDrain(\n    {\n      config: {\n        extractionMinUserTurns: config.extractionMinUserTurns,\n        extractionMinChars: config.extractionMinChars,\n        extractionMaxTurnChars: config.extractionMaxTurnChars,\n        extractionChunkDropAfterFailures: config.extractionChunkDropAfterFailures,\n      },\n      extractionWindowBudgetChars: () => ingestionDeps.extractionWindowBudgetChars?.() ?? Number.POSITIVE_INFINITY,\n      // Render-exact chunk sizing: the model clamp bounds the CONVERSATION\n      // (truncateLocalExtractionConversation), so measure exactly that —\n      // with the SAME source-classification gate extract() applies when it\n      // prepends the connector header (header margin included when the\n      // engine would render it).\n      measureRenderedTurns: (turns) => {\n        const sourceConnector = resolveMemoryLifecycleCapabilities(config).extractionScopeClassification\n          ? resolveSourceConnector(turns)\n          : undefined;\n        return renderExtractionConversation(\n          turns.map((turn) => ({ ...turn, content: turn.content.trim().slice(0, config.extractionMaxTurnChars) })),\n          headerConnector(sourceConnector)\n        ).conversation.length;\n      },\n      runExtraction: (turns, runOptions) => isolatedRun.runExtraction(turns, runOptions),\n      getStorage: () => ingestionDeps.getStorage(),\n      buffer: claimBuffer,\n    },\n    { dropFailedChunks: false }\n  );\n  return { claimBuffer, coordinator, executionDrain };\n}\n\n/** Plan semantics for one scope group: a pinned plan forwards as-is; a\n *  planless ACCEPTED group pins null (existing flush behavior); unpinned\n *  legacy groups pass NO option so runExtraction resolves the CURRENT\n *  profile. */\nfunction planOptionForGroup(group: ExtractionScopeGroup): GroupPlanOption {\n  if (group.scopeProfileWritePlan !== undefined) return { scopeProfileWritePlan: group.scopeProfileWritePlan };\n  if (group.turns.some((turn) => turn.acceptedCapture === true)) return { scopeProfileWritePlan: null };\n  return {};\n}\n\n/** captureMode=explicit: ordinary buffered conversation turns never create\n *  memories — only deliberately accepted captures drain. */\nfunction explicitModeDenied(group: ExtractionScopeGroup, config: PluginConfig): boolean {\n  return shouldSkipImplicitExtraction(config) && !group.turns.some((turn) => turn.acceptedCapture === true);\n}\n\ninterface GroupOutcome {\n  turns: number;\n  result?: ExtractionRunResult;\n}\n\ninterface ScopeDrainContext {\n  config: PluginConfig;\n  key: string;\n  signal: AbortSignal;\n  claimBuffer: SmartBuffer;\n  coordinator: TurnIngestionCoordinator;\n  executionDrain: ExtractionDrain;\n  turns: BufferTurn[];\n}\n\n/** Drain a claimed session's turns ONE captured-scope group at a time: each\n *  group keeps its own namespace/principal/plan pins, and the shared\n *  extraction boundary re-applies CURRENT authorization from the turn's\n *  ORIGINAL coding binding before any write. Groups run sequentially (FIFO\n *  per key — the queue's same-key exclusion would serialize them anyway); a\n *  denied group never blocks or clears the other groups. */\nasync function drainScopeGroups(\n  ctx: ScopeDrainContext\n): Promise<{ groupOutcomes: GroupOutcome[]; groupError?: DrainExtractionError }> {\n  const groupOutcomes: GroupOutcome[] = [];\n  let groupError: DrainExtractionError | undefined;\n  for (const group of groupTurnsByExtractionScope(ctx.turns)) {\n    if (ctx.signal.aborted) break;\n    if (explicitModeDenied(group, ctx.config)) {\n      log.warn(\n        `buffer drain: session ${ctx.key} denied capture_mode_explicit (${group.turns.length} ordinary turn(s) retained)`\n      );\n      groupOutcomes.push({\n        turns: group.turns.length,\n        result: { status: \"skipped\", reason: \"capture_mode_explicit\", persistedCount: 0, durableOutputCount: 0 },\n      });\n      continue;\n    }\n    const settleGate = Promise.withResolvers<{ cause?: unknown; result?: ExtractionRunResult }>();\n    let done = false;\n    const onSettle = (cause: unknown, result?: ExtractionRunResult): void => {\n      if (done) return;\n      done = true;\n      settleGate.resolve({ cause, result });\n    };\n    // Settlement and callback EXIT are tracked separately: the lease is\n    // released only after BOTH the queued closure settled and fully exited\n    // (an abort settles through its listener while the closure may still be\n    // persisting).\n    const exited = Promise.withResolvers<void>();\n    void ctx.coordinator\n      .queueBufferedExtraction(group.turns, \"trigger_mode\", {\n        bufferKey: ctx.key,\n        clearBufferAfterExtraction: true,\n        clearMatchingTurns: true,\n        skipDedupeCheck: true,\n        skipCharThreshold: true,\n        skipUserTurnThreshold: true,\n        // Automatic background work yields to fail-closed foreground flushes\n        // (preemptRunning), same as the live trigger path.\n        preemptable: true,\n        abortSignal: ctx.signal,\n        writeNamespaceOverride: group.writeNamespaceOverride,\n        principalOverride: group.principalOverride,\n        ...planOptionForGroup(group),\n        execution: { buffer: ctx.claimBuffer, drain: ctx.executionDrain },\n        onTaskSettled: (error, result) => settleGate.resolve({ cause: error, result }),\n        onTaskExit: () => exited.resolve(),\n      })\n      .catch((cause: DrainExtractionError) => onSettle(cause));\n    const [verdict] = await Promise.all([settleGate.promise, exited.promise]);\n    const settled = verdict;\n    if (settled.cause !== undefined) {\n      // SAFETY: settle captures whatever the queued closure rejected with;\n      // every drain rejection site throws Error values, and a rejection is\n      // always a DrainExtractionError in this path.\n      groupError = settled.cause as Error;\n      break;\n    }\n    groupOutcomes.push({ turns: group.turns.length, result: settled.result });\n  }\n  return { groupOutcomes, groupError };\n}\n\n/** Denied scope groups: policy refusals leave their turns pending (the group\n *  result's turns were NOT cleared), aggregated per reason so a drain is\n *  never reported complete while denied backlog remains. */\nfunction deniedByReason(groupOutcomes: readonly GroupOutcome[]): Map<string, number> {\n  const denied = new Map<string, number>();\n  for (const entry of groupOutcomes) {\n    if (entry.result?.status !== \"skipped\" || !DENIED_SCOPE_REASONS.has(entry.result.reason ?? \"\")) continue;\n    denied.set(entry.result.reason!, (denied.get(entry.result.reason!) ?? 0) + entry.turns);\n  }\n  return denied;\n}\n\nfunction lastGroupReason(groupOutcomes: readonly GroupOutcome[]): string | undefined {\n  for (let index = groupOutcomes.length - 1; index >= 0; index -= 1) {\n    const reason = groupOutcomes[index]?.result?.reason;\n    if (reason !== undefined) return reason;\n  }\n  return undefined;\n}\n\n/** the session file is gone for good — but the ack verdict is the truth (live */\nasync function settleDrainVerdict(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  groupOutcomes: readonly GroupOutcome[],\n  groupError: DrainExtractionError | undefined,\n  turnsRemaining: number\n): Promise<{ status: DrainSessionStatus; reason?: string; turnsRemaining: number }> {\n  if (turnsRemaining === 0) return await ackOrReload(claims, key, ownerId);\n  if (groupError) {\n    await claims.releaseLease(key, ownerId);\n    return { status: \"failed\", reason: describeError(groupError), turnsRemaining };\n  }\n  await claims.releaseLease(key, ownerId);\n  const reason =\n    groupOutcomes.find((entry) => entry.result?.reason !== undefined && DENIED_SCOPE_REASONS.has(entry.result.reason!))\n      ?.result?.reason ??\n    lastGroupReason(groupOutcomes) ??\n    \"deferred\";\n  return { status: \"deferred\", reason, turnsRemaining };\n}\n\n/** Ack an emptied claim; a not-acked verdict means live ingress merged (or\n *  the lease moved) — reload the honest pending count and release OUR lease,\n *  keeping the source. */\nasync function ackOrReload(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string\n): Promise<{ status: DrainSessionStatus; reason?: string; turnsRemaining: number }> {\n  const ackOutcome = await claims.ack(key, ownerId);\n  if (ackOutcome === \"acked\") return { status: \"drained\", turnsRemaining: 0 };\n  const reloaded = await claims.load(key);\n  const turnsRemaining = pendingTurnCount(reloaded?.entry);\n  await claims.releaseLease(key, ownerId);\n  return { status: \"deferred\", reason: ackOutcome === \"not_empty\" ? \"ack_not_empty\" : \"ack_not_owner\", turnsRemaining };\n}\n\nfunction groupCounts(groupOutcomes: readonly GroupOutcome[]): GroupCounts {\n  return {\n    persistedCount: groupOutcomes.reduce((sum, entry) => sum + (entry.result?.persistedCount ?? 0), 0),\n    durableOutputCount: groupOutcomes.reduce((sum, entry) => sum + (entry.result?.durableOutputCount ?? 0), 0),\n  };\n}\n\nexport interface DrainScanEntry {\n  key: string;\n  turns: number;\n  claimed: boolean;\n}\n\n/** Session-buffer listings: a claimed session reports its CLAIM's pending\n *  count (the live buffer copy may lag the claim), an unclaimed one its\n *  buffer entry. */\nasync function bufferSessionListings(\n  claims: BufferDrainClaims,\n  entries: Record<string, BufferEntryState>\n): Promise<{ listings: DrainScanEntry[]; seen: Set<string> }> {\n  const listings: DrainScanEntry[] = [];\n  const seen = new Set<string>();\n  for (const [key, entry] of Object.entries(entries)) {\n    seen.add(key);\n    const claim = claims.isClaimed(key) ? await claims.load(key) : null;\n    listings.push({\n      key,\n      turns: claim ? pendingTurnCount(claim.entry) : pendingTurnCount(entry),\n      claimed: claim !== null,\n    });\n  }\n  return { listings, seen };\n}\n\n/** Claims the buffer state no longer lists (drained by an earlier run whose\n *  claim file outlived its session file). */\nasync function orphanClaimListings(claims: BufferDrainClaims, seen: Set<string>): Promise<DrainScanEntry[]> {\n  const out: DrainScanEntry[] = [];\n  for (const listed of await claims.list()) {\n    if (seen.has(listed.key)) continue;\n    out.push({ key: listed.key, turns: listed.turnCount, claimed: true });\n  }\n  return out;\n}\n\n/** The drain runs on the caller's abort signal combined with this run's own\n *  lease-loss controller. */\nfunction drainAbortSignal(callerSignal: AbortSignal | undefined, abort: AbortController): AbortSignal {\n  return callerSignal ? AbortSignal.any([callerSignal, abort.signal]) : abort.signal;\n}\n\n/** One heartbeat-protected claim drain: run every scope group, settle the\n *  verdict against the claim store, and assemble the honest outcome. The\n *  heartbeat is cleared by the caller on every exit path. */\nasync function runClaimDrain(\n  ctx: {\n    orchestrator: Orchestrator;\n    claims: BufferDrainClaims;\n    key: string;\n    ownerId: string;\n    claimBuffer: SmartBuffer;\n    coordinator: TurnIngestionCoordinator;\n    executionDrain: ExtractionDrain;\n    turns: BufferTurn[];\n    turnsAtStart: number;\n    config: PluginConfig;\n    signal: AbortSignal;\n  },\n  options: BufferDrainRunnerOptions,\n  heartbeat: NodeJS.Timeout\n): Promise<DrainSessionOutcome> {\n  // Reconcile only identities recorded as durably extracted under this\n  // owner's claim lease. The claim lock is released before entering the live\n  // buffer mutation queue, preserving the buffer→claim lock order used by\n  // concurrent ingress saves.\n  const reconcileDrainedTurns = async (): Promise<void> => {\n    const drained = await ctx.claims.drainedTurnsForOwner(ctx.key, ctx.ownerId);\n    if (drained !== null) await ctx.orchestrator.buffer.save({ key: ctx.key, drained });\n  };\n\n  // An emptied claim acks here: the ack verdict is the truth (drained), or\n  // live ingress merged between the read and the ack — deferred, source kept.\n  if (ctx.turns.length === 0) {\n    await reconcileDrainedTurns();\n    const outcome = await ackEmptyClaim(ctx.claims, ctx.key, ctx.ownerId, ctx.turnsAtStart);\n    options.onEvent?.({ type: \"session_finished\", key: ctx.key, outcome });\n    return outcome;\n  }\n  const { groupOutcomes, groupError } = await drainScopeGroups(ctx);\n  await reconcileDrainedTurns();\n  // Heartbeat cleared on EVERY exit path: a rejected drain must not keep\n  // renewing the lease forever (cleared in the caller's finally).\n  const remaining = await ctx.claims.load(ctx.key);\n  const { status, reason, turnsRemaining } = await settleDrainVerdict(\n    ctx.claims,\n    ctx.key,\n    ctx.ownerId,\n    groupOutcomes,\n    groupError,\n    pendingTurnCount(remaining?.entry)\n  );\n  const outcome = assembleOutcome(\n    ctx.key,\n    ctx.turnsAtStart,\n    { status, reason, turnsRemaining },\n    groupCounts(groupOutcomes),\n    deniedByReason(groupOutcomes)\n  );\n  log.info(`buffer drain: session ${ctx.key} ${status} (${outcome.turnsRemaining} turn(s) remaining)`);\n  options.onEvent?.({ type: \"session_finished\", key: ctx.key, outcome });\n  return outcome;\n}\n\nexport class BufferDrainRunner {\n  constructor(private readonly orchestrator: Orchestrator) {}\n\n  /** The claim store of this orchestrator's memory root. */\n  get claims(): BufferDrainClaims {\n    return this.orchestrator.storage.bufferDrainClaims();\n  }\n\n  /**\n   * Drain one claimed session. The caller owns the lease (it may have taken\n   * it already); this method verifies ownership before touching content.\n   */\n  async drainSession(key: string, options: BufferDrainRunnerOptions): Promise<DrainSessionOutcome> {\n    const claims = this.claims;\n    const leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;\n    const claimed = await loadClaimedSession(claims, key);\n    if (claimed.kind === \"notClaimed\") return claimed.notClaimed;\n    const { claim, turnsAtStart } = claimed;\n    options.onEvent?.({ type: \"session_started\", key, turns: turnsAtStart });\n\n    // Take the lease unless this drainer already holds it.\n    const busy = await adoptLease(claims, key, options.ownerId, leaseMs);\n    if (busy !== null) {\n      const outcome = busy;\n      options.onEvent?.({ type: \"session_finished\", key, outcome });\n      return outcome;\n    }\n\n    // The claim is the buffer for this run: every successful chunk is removed\n    // from it, so a kill leaves exactly the un-extracted turns.\n    const { claimBuffer, coordinator, executionDrain } = buildClaimExecution(\n      this.orchestrator,\n      claims,\n      key,\n      options.ownerId,\n      claim\n    );\n    await claimBuffer.load();\n\n    // The claim's turns (retained first, like the live buffer's order).\n    const turns = [...(claim.entry.retainedTurns ?? []), ...claim.entry.turns];\n\n    // A lost lease means another drainer took the claim: stop instead of\n    // writing progress into a claim this run no longer owns.\n    const abort = new AbortController();\n    const signal = drainAbortSignal(options.signal, abort);\n    const heartbeat = startLeaseHeartbeat(claims, key, options.ownerId, leaseMs, abort);\n    try {\n      return await runClaimDrain(\n        {\n          orchestrator: this.orchestrator,\n          claims,\n          key,\n          ownerId: options.ownerId,\n          claimBuffer,\n          coordinator,\n          executionDrain,\n          turns,\n          turnsAtStart,\n          config: this.orchestrator.config,\n          signal,\n        },\n        options,\n        heartbeat\n      );\n    } finally {\n      clearInterval(heartbeat);\n    }\n  }\n\n  /** Claim a session file for the drain. Returns false when it is not claimable. */\n  async claim(key: string, ownerId: string, leaseMs = DEFAULT_LEASE_MS): Promise<boolean> {\n    const lease: DrainLease = {\n      ownerId,\n      pid: process.pid,\n      host: hostname(),\n      acquiredAt: new Date().toISOString(),\n      heartbeatAt: new Date().toISOString(),\n      leaseMs,\n    };\n    return (await this.claims.claimFromSessionFile(key, lease)) === \"claimed\";\n  }\n\n  /** Sessions with buffered turns, claimed or not (CLI scan). */\n  async scan(): Promise<DrainScanEntry[]> {\n    const sessions = await this.orchestrator.storage.loadBuffer();\n    const { listings, seen } = await bufferSessionListings(this.claims, sessions.entries ?? {});\n    return [...listings, ...(await orphanClaimListings(this.claims, seen))];\n  }\n}\n"],"mappings":"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","names":["outcome"]}

package/dist/{chunk-XHGYZRVW.js → chunk-OSTFDWZJ.js}

@@ -1,9 +1,9 @@
 import {
   resolveDefaultNamespaceRoot
-} from "./chunk-KESJ5XX3.js";
+} from "./chunk-MYCCO6AA.js";
 import {
   StorageManager
-} from "./chunk-WAD32CZG.js";
+} from "./chunk-ELWI2R6H.js";
 import {
   composeLocationDayBody,
   composeLocationDayMeta,
@@ -23,7 +23,7 @@ import {
   serializeLocationDay,
   updateLocationSourceDay,
   writeLocationDay
-} from "./chunk-2D7BTSDW.js";
+} from "./chunk-ANZZLRUX.js";
 import {
   resolveNamespaceCapabilities
 } from "./chunk-C5LWPYS3.js";
@@ -728,4 +728,4 @@ export {
   runLocationBackfill,
   runLocationCliCommand
 };
-//# sourceMappingURL=chunk-XHGYZRVW.js.map
+//# sourceMappingURL=chunk-OSTFDWZJ.js.map

package/dist/{chunk-BXLOS5AJ.js → chunk-OWHERGF2.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-765K3SAT.js";
 import {
   encryptCapsuleFile
-} from "./chunk-DQEMWVMT.js";
+} from "./chunk-UVYI6VIX.js";
 import {
   computeTransferOutputRel,
   isTransferPathExcluded
@@ -109,4 +109,4 @@ async function enforceRetention(outDirAbs, retentionDays) {
 export {
   backupMemoryDir
 };
-//# sourceMappingURL=chunk-BXLOS5AJ.js.map
+//# sourceMappingURL=chunk-OWHERGF2.js.map

package/dist/{chunk-WC475JOG.js → chunk-P225W4RQ.js}

@@ -1,6 +1,6 @@
 import {
   runGraphEdgeDecayMaintenanceAcrossNamespaces
-} from "./chunk-K36RMINQ.js";
+} from "./chunk-GOZXQNIM.js";
 import {
   normalizeDreamsStatusWindowHours
 } from "./chunk-PQM3B54K.js";
@@ -8,7 +8,7 @@ import {
   executeResolution,
   isValidResolutionVerb,
   runPreferenceDriftScan
-} from "./chunk-2RUTN7PR.js";
+} from "./chunk-S7GJNA3K.js";
 import {
   getRecallTimingStatus,
   isRecallTimingsOperator
@@ -21,13 +21,13 @@ import {
   defineOperation,
   parseNamespacePreflightWriteOp,
   resolveAuthorizedNamespaceWritablePreflight
-} from "./chunk-6LCWKS62.js";
+} from "./chunk-HVFX2N2G.js";
 import {
   parseSharedWriteOutputControls
 } from "./chunk-IFBSZGW3.js";
 import {
   validateBriefingFormat
-} from "./chunk-YUTG35M4.js";
+} from "./chunk-GJVGFKOU.js";
 import {
   parseDeepRecallMaxSteps
 } from "./chunk-AJG2TAMR.js";
@@ -44,7 +44,7 @@ import {
   recallRequestSchema,
   retainedCategoryAlias,
   suggestionSubmitRequestSchema
-} from "./chunk-HWHNQVRV.js";
+} from "./chunk-GYNRNKMW.js";
 import {
   enforceNamespaceAllowList,
   tokenCapabilityStore
@@ -618,4 +618,4 @@ defineOperation({ name: "graph_events", description: "SSE graph events.", schema
 defineOperation({ name: "chat_message", description: "Chat message.", schema: strictSchema({ message: S.str, chatSessionId: S.str }), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
 defineOperation({ name: "chat_events", description: "SSE chat events.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { stream: "sse" } }) });
 defineOperation({ name: "adapters_status", description: "Adapter registry metadata (issue #1850 round 5). Marker op: the HTTP transport builds the response from its own adapterRegistry, but the op still must be registered so it appears in listRegisteredOperations and enforceTokenOp can gate it for scoped tokens.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
-//# sourceMappingURL=chunk-WC475JOG.js.map
+//# sourceMappingURL=chunk-P225W4RQ.js.map

package/dist/{chunk-TFA6HPOA.js → chunk-QCP75JGO.js}

@@ -1,3 +1,7 @@
+import {
+  searchConversationIndex,
+  searchConversationIndexFaissFailOpen
+} from "./chunk-A7Q43EUZ.js";
 import {
   failOpenFaissHealth
 } from "./chunk-F4TWWUMP.js";
@@ -5,10 +9,6 @@ import {
   rebuildConversationChunksFailOpen,
   upsertConversationChunksFailOpen
 } from "./chunk-72A4L5JJ.js";
-import {
-  searchConversationIndex,
-  searchConversationIndexFaissFailOpen
-} from "./chunk-A7Q43EUZ.js";
 
 // src/conversation-index/backend.ts
 function createConversationIndexBackend(options) {
@@ -235,4 +235,4 @@ function createFaissBackend(getFaiss) {
 export {
   createConversationIndexBackend
 };
-//# sourceMappingURL=chunk-TFA6HPOA.js.map
+//# sourceMappingURL=chunk-QCP75JGO.js.map

package/dist/{chunk-JRVMCZE3.js → chunk-QEYTRFR3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-BT7NVCML.js";
 import {
   isMemorySubject
-} from "./chunk-IZJQNDGI.js";
+} from "./chunk-R6HMAIKM.js";
 import {
   assemblePersistedBody
 } from "./chunk-JDSVLVCG.js";
@@ -443,4 +443,4 @@ export {
   buildAccessWriteRequestFingerprint,
   buildObserveRequestFingerprint
 };
-//# sourceMappingURL=chunk-JRVMCZE3.js.map
+//# sourceMappingURL=chunk-QEYTRFR3.js.map

package/dist/chunk-QV2VZKD5.js

@@ -0,0 +1,31 @@
+import {
+  isErrnoCode
+} from "./chunk-KNA3BXXL.js";
+
+// src/transfer/capsule-gunzip.ts
+import { gunzipSync } from "zlib";
+var CAPSULE_IMPORT_MAX_GUNZIP_BYTES = 64 * 1024 * 1024;
+function gunzipCapsuleArchive(raw, caller, archiveAbs) {
+  try {
+    return gunzipSync(raw, {
+      maxOutputLength: CAPSULE_IMPORT_MAX_GUNZIP_BYTES
+    }).toString("utf-8");
+  } catch (cause) {
+    if (isErrnoCode(cause, "ERR_BUFFER_TOO_LARGE")) {
+      throw new Error(
+        `${caller}: archive decompressed size exceeds limit of ${CAPSULE_IMPORT_MAX_GUNZIP_BYTES} bytes`,
+        cause instanceof Error ? { cause } : void 0
+      );
+    }
+    throw new Error(
+      `${caller}: archive is not a valid gzip file: ${archiveAbs}`,
+      cause instanceof Error ? { cause } : void 0
+    );
+  }
+}
+
+export {
+  CAPSULE_IMPORT_MAX_GUNZIP_BYTES,
+  gunzipCapsuleArchive
+};
+//# sourceMappingURL=chunk-QV2VZKD5.js.map

package/dist/chunk-QV2VZKD5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transfer/capsule-gunzip.ts"],"sourcesContent":["import { gunzipSync } from \"node:zlib\";\n\nimport { isErrnoCode } from \"../utils/errno.js\";\n\n/**\n * Hard cap on decompressed capsule JSON for import, merge and inspect. `gunzipSync` without\n * `maxOutputLength` allocates whatever the stream claims, so a small\n * highly-compressible gzip can OOM the process. 64 MiB is enough for ordinary\n * capsules and stops classic bomb shapes at the zlib edge.\n */\nexport const CAPSULE_IMPORT_MAX_GUNZIP_BYTES = 64 * 1024 * 1024;\n\n/**\n * Gunzip a capsule archive buffer with a hard decompressed-size cap.\n * `caller` is the public API name used in error messages (`importCapsule`,\n * `mergeCapsule`, `capsule inspect`).\n */\nexport function gunzipCapsuleArchive(\n  raw: Buffer,\n  caller: string,\n  archiveAbs: string,\n): string {\n  try {\n    return gunzipSync(raw, {\n      maxOutputLength: CAPSULE_IMPORT_MAX_GUNZIP_BYTES,\n    }).toString(\"utf-8\");\n  } catch (cause) {\n    if (isErrnoCode(cause, \"ERR_BUFFER_TOO_LARGE\")) {\n      throw new Error(\n        `${caller}: archive decompressed size exceeds limit of ${CAPSULE_IMPORT_MAX_GUNZIP_BYTES} bytes`,\n        cause instanceof Error ? { cause } : undefined,\n      );\n    }\n    throw new Error(\n      `${caller}: archive is not a valid gzip file: ${archiveAbs}`,\n      cause instanceof Error ? { cause } : undefined,\n    );\n  }\n}\n"],"mappings":";;;;;AAAA,SAAS,kBAAkB;AAUpB,IAAM,kCAAkC,KAAK,OAAO;AAOpD,SAAS,qBACd,KACA,QACA,YACQ;AACR,MAAI;AACF,WAAO,WAAW,KAAK;AAAA,MACrB,iBAAiB;AAAA,IACnB,CAAC,EAAE,SAAS,OAAO;AAAA,EACrB,SAAS,OAAO;AACd,QAAI,YAAY,OAAO,sBAAsB,GAAG;AAC9C,YAAM,IAAI;AAAA,QACR,GAAG,MAAM,gDAAgD,+BAA+B;AAAA,QACxF,iBAAiB,QAAQ,EAAE,MAAM,IAAI;AAAA,MACvC;AAAA,IACF;AACA,UAAM,IAAI;AAAA,MACR,GAAG,MAAM,uCAAuC,UAAU;AAAA,MAC1D,iBAAiB,QAAQ,EAAE,MAAM,IAAI;AAAA,IACvC;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-IZJQNDGI.js → chunk-R6HMAIKM.js}

@@ -1,6 +1,6 @@
 import {
   ContentHashIndex
-} from "./chunk-KQUSP6LB.js";
+} from "./chunk-UDKWFDV2.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -164,4 +164,4 @@ export {
   PROMOTION_CANDIDATES_MCP_TOOLS,
   backfillMemorySubjects
 };
-//# sourceMappingURL=chunk-IZJQNDGI.js.map
+//# sourceMappingURL=chunk-R6HMAIKM.js.map

package/dist/{chunk-VUROWXFL.js → chunk-RNGDKFY2.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-ZAJLJ35W.js";
 import {
   parseConfig
-} from "./chunk-T6T2RMWW.js";
+} from "./chunk-23B4HLWG.js";
 import {
   resolveObjectiveStateStoreDir,
   validateObjectiveStateSnapshot
@@ -268,4 +268,4 @@ export {
   recordResumeBundle,
   getResumeBundleStatus
 };
-//# sourceMappingURL=chunk-VUROWXFL.js.map
+//# sourceMappingURL=chunk-RNGDKFY2.js.map

package/dist/{chunk-FF6N7BXC.js → chunk-S45INSV3.js}

@@ -1,10 +1,10 @@
+import {
+  collapseWhitespace
+} from "./chunk-PJKTFXE2.js";
 import {
   coerceBool,
   coerceNumber
 } from "./chunk-PQVCH2AE.js";
-import {
-  collapseWhitespace
-} from "./chunk-PJKTFXE2.js";
 import {
   isSafeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -386,4 +386,4 @@ export {
   stripLeadingRolePrefix,
   buildFactProvenance
 };
-//# sourceMappingURL=chunk-FF6N7BXC.js.map
+//# sourceMappingURL=chunk-S45INSV3.js.map

package/dist/{chunk-2RUTN7PR.js → chunk-S7GJNA3K.js}

@@ -15,7 +15,7 @@ import {
 } from "./chunk-CTVWELNK.js";
 import {
   composeMemoryEnvelope
-} from "./chunk-JRVMCZE3.js";
+} from "./chunk-QEYTRFR3.js";
 import {
   readJsonFile,
   writeJsonFileAtomic
@@ -878,4 +878,4 @@ export {
   isValidResolutionVerb,
   executeResolution
 };
-//# sourceMappingURL=chunk-2RUTN7PR.js.map
+//# sourceMappingURL=chunk-S7GJNA3K.js.map

package/dist/{chunk-XYP5WBDO.js → chunk-SGHV6LZ7.js}

@@ -1,15 +1,15 @@
+import {
+  selectEvictedBufferKeys
+} from "./chunk-KASJJGRG.js";
 import {
   BufferSessionPersistence
-} from "./chunk-MPDLLLOG.js";
+} from "./chunk-XO23OKMK.js";
 import {
   scanSignals
 } from "./chunk-H3FZVNRN.js";
-import {
-  selectEvictedBufferKeys
-} from "./chunk-KASJJGRG.js";
 import {
   ExtractionDeadlineError
-} from "./chunk-KO3YBHOV.js";
+} from "./chunk-4IWEPQEV.js";
 import {
   bufferEntryCounts,
   bufferTurnArrayIsSuffixOfSnapshot,
@@ -24,7 +24,7 @@ import {
   scopeProfilePlanIdentity,
   selectRetainedDeferredTurns,
   subtractBufferTurns
-} from "./chunk-4KLQI3L2.js";
+} from "./chunk-WLNWFHX3.js";
 import {
   resolvePrincipal
 } from "./chunk-ESG6ITGP.js";
@@ -228,14 +228,14 @@ var SmartBuffer = class {
     this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };
     this.loaded = true;
   }
-  async saveUnlocked() {
-    const { handedOver, drainedTurns } = await this.persistence.persist(this.storage, this.state, (key) => this.peekEntry(key) ?? void 0);
+  async saveUnlocked(reconcile) {
+    const { handedOver, drainedTurns } = await this.persistence.persist(this.storage, this.state, (key) => this.peekEntry(key) ?? void 0, reconcile);
     for (const [key, drained] of drainedTurns) {
       const entry = this.peekEntry(key);
       if (!entry) continue;
-      entry.turns = subtractBufferTurns(entry.turns, drained);
+      entry.turns = subtractBufferTurns(entry.turns, drained.turns);
       if (entry.retainedTurns && entry.retainedTurns.length > 0) {
-        entry.retainedTurns = subtractBufferTurns(entry.retainedTurns, drained);
+        entry.retainedTurns = subtractBufferTurns(entry.retainedTurns, drained.retainedTurns);
         if (entry.retainedTurns.length === 0) delete entry.retainedTurns;
       }
       if (key === "default") this.state.turns = entry.turns;
@@ -259,8 +259,8 @@ var SmartBuffer = class {
   entryCounts() {
     return bufferEntryCounts(this.state);
   }
-  async save() {
-    await this.enqueueMutation(async () => this.saveUnlocked());
+  async save(reconcile) {
+    await this.enqueueMutation(async () => this.saveUnlocked(reconcile));
   }
   /**
    * Schedule a coalesced, TRUE trailing-edge buffer save (issue #1909). Only
@@ -910,4 +910,4 @@ var SmartBuffer = class {
 export {
   SmartBuffer
 };
-//# sourceMappingURL=chunk-XYP5WBDO.js.map
+//# sourceMappingURL=chunk-SGHV6LZ7.js.map

package/dist/chunk-SGHV6LZ7.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  hasPinnedCaptureScope,\n  liveTurnsFromExtractionSnapshot,\n  matchingQueuedExtractionPrefixLength,\n  probeWithTimeout,\n  selectRetainedDeferredTurns,\n  type BufferEntryCounts,\n} from \"./buffer-turn-helpers.js\";\n\nexport type TriggerDecision = \"extract_now\" | \"extract_batch\" | \"keep_buffering\";\n\nexport type { BufferSurpriseProbe } from \"./buffer-types.js\";\nimport type { BufferSurpriseProbe, SurpriseTelemetryQueueEntry } from \"./buffer-types.js\";\n\nexport interface AddTurnOutcome {\n  decision: TriggerDecision;\n  extractionTurns?: BufferTurn[];\n}\n\nexport interface RetainedTurnCleanupOptions {\n  abortSignal?: AbortSignal;\n  deadlineMs?: number;\n  /** Keep cleanup within the accepted namespace. */\n  writeNamespaceOverride?: string;\n  /** Match the original profile and project binding, not just its write namespace. */\n  scopeProfileWritePlan?: import(\"./namespaces/scope-profiles.js\").ResolvedScopeProfilePlan | null;\n  codingContext?: import(\"./types.js\").CodingContext;\n}\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;\nconst isAcceptedTurn = (t: { acceptedCapture?: boolean; writeNamespaceOverride?: string }): boolean =>\n  t.acceptedCapture === true || t.writeNamespaceOverride !== undefined;\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\ninterface AddTurnMutationResult {\n  decision: TriggerDecision;\n  signalLevel: SignalLevel;\n  priorTurns: BufferTurn[];\n  activeTurnsSnapshot: BufferTurn[];\n  retainedTurnsSnapshot: BufferTurn[];\n  turnCountInWindow: number;\n}\n\nexport class SmartBuffer {\n  private state: BufferState;\n  private loaded = false;\n  private loadPromise: Promise<void> | null = null;\n  private readonly surpriseProbe: BufferSurpriseProbe | null;\n  private mutationChain: Promise<unknown> = Promise.resolve();\n  /**\n   * Serialized write chain for `BUFFER_SURPRISE` telemetry events.\n   *\n   * The telemetry path is fire-and-forget (`addTurn` does not await the\n   * ledger append), but multiple concurrent appends would still settle\n   * out of order under variable filesystem latency. The report path\n   * assumes chronological ordering — it slices the tail of the ledger\n   * and treats the most recent entry as the current threshold in force.\n   * Chaining ensures each append only runs after the previous settles,\n   * preserving wall-clock order.\n   *\n   * We include a `.catch` on every link so a rejected append does not\n   * poison the chain (CLAUDE.md rule #40).\n   */\n  private surpriseTelemetryWriteChain: Promise<unknown> = Promise.resolve();\n\n  /**\n   * Debounced buffer-save state (issue #1909). Steady-state buffering used to\n   * serialize + rewrite the whole multi-session buffer on EVERY turn. We now\n   * coalesce those writes onto a trailing-edge timer; correctness boundaries\n   * (extraction trigger, extraction clear, shutdown) still force an immediate\n   * flush. `bufferSaveDebounceMs: 0` restores save-every-turn exactly.\n   */\n  private saveTimer: NodeJS.Timeout | null = null;\n  private pendingSave = false;\n  /** Wall-clock ms when the currently-pending save was first scheduled (issue\n   * #1909). Null when nothing is pending. Used to bound deferral under sustained\n   * activity (see BUFFER_SAVE_MAX_DEFER_MULTIPLIER). */\n  private firstPendingAtMs: number | null = null;\n\n  /** 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  private normalizeState(state: BufferState): BufferState {\n    const entries = Object.assign(\n      Object.create(null),\n      state.entries ?? {},\n    ) as NonNullable<BufferState[\"entries\"]>;\n    if (!entries.default) {\n      entries.default = {\n        turns: Array.isArray(state.turns) ? [...state.turns] : [],\n        lastExtractionAt: state.lastExtractionAt ?? null,\n        extractionCount:\n          typeof state.extractionCount === \"number\" ? state.extractionCount : 0,\n      };\n    }\n    return {\n      turns: entries.default.turns,\n      lastExtractionAt: entries.default.lastExtractionAt,\n      extractionCount: entries.default.extractionCount,\n      entries,\n    };\n  }\n\n  private entryActivityAt(entry: BufferEntryState): number {\n    const lastTurnAt = entry.turns.reduce((latest, turn) => {\n      const parsed = Date.parse(turn.timestamp);\n      return Number.isFinite(parsed) ? Math.max(latest, parsed) : latest;\n    }, -1);\n    const lastExtractionAt =\n      typeof entry.lastExtractionAt === \"string\"\n        ? Date.parse(entry.lastExtractionAt)\n        : Number.NaN;\n    return Math.max(\n      lastTurnAt,\n      Number.isFinite(lastExtractionAt) ? lastExtractionAt : -1,\n    );\n  }\n\n  /** 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, {\n      activityAt: (entry) => this.entryActivityAt(entry),\n      holdsAcceptedCapture: (entry) => this.entryHoldsAcceptedCapture(entry),\n    });\n    for (const key of evicted) delete entries[key];\n    this.persistence.markEvicted(evicted);\n    if (evicted.length > 0) {\n      // Loud degradation (extraction hot-loop hardening, Step 7): buffer\n      // pressure during a provider outage is bounded and expected, but must\n      // be observable, not silent.\n      log.warn(\n        `buffer: pruned ${evicted.length} oldest session entr${evicted.length === 1 ? \"y\" : \"ies\"} ` +\n          `past the session-entry cap (${this.maxSessionEntries}); buffered turn data for those sessions was dropped`,\n      );\n    }\n  }\n\n  private async loadUnlocked(): Promise<void> {\n    if (this.loaded) return;\n    if (!this.loadPromise) {\n      this.loadPromise = this.storage.loadBuffer()\n        .then((state) => {\n          this.state = this.normalizeState(state);\n          this.loaded = true;\n        })\n        .finally(() => {\n          this.loadPromise = null;\n        });\n    }\n    await this.loadPromise;\n  }\n\n  async load(): Promise<void> {\n    await this.enqueueMutation(async () => this.loadUnlocked());\n  }\n\n  /** 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  /** Free one slot for an accepted capture via the native eviction policy (COS-244c). */\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\" || this.entryHoldsAcceptedCapture(entries[k]));\n    if (pinned.length <= target) this.pruneEntries([], target); // evict only if it frees a slot\n  }\n\n  private entryHoldsAcceptedCapture(entry: BufferEntryState | undefined): boolean {\n    return (entry?.turns ?? []).some(isAcceptedTurn) || (entry?.retainedTurns ?? []).some(isAcceptedTurn);\n  }\n\n  async addTurnWithOutcome(\n    bufferKey: string,\n    turn: BufferTurn,\n  ): Promise<AddTurnOutcome> {\n    const mutation = await this.enqueueMutation(() => this.recordTurnUnlocked(bufferKey, turn));\n    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-RJWL3RHB.js → chunk-TFEHSPGQ.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-FEHIOYML.js";
 import {
   composeMemoryEnvelope
-} from "./chunk-JRVMCZE3.js";
+} from "./chunk-QEYTRFR3.js";
 import {
   displayErrorDetail
 } from "./chunk-RL6NEVXT.js";
@@ -1463,4 +1463,4 @@ export {
   serializeDecisionRecord,
   parseDecisionRecord
 };
-//# sourceMappingURL=chunk-RJWL3RHB.js.map
+//# sourceMappingURL=chunk-TFEHSPGQ.js.map

package/dist/{chunk-T77AX6DG.js → chunk-TQVECGUQ.js}

@@ -5,14 +5,14 @@ import {
 } from "./chunk-5KBIOI4G.js";
 import {
   composeSalvagedEnvelope
-} from "./chunk-YUTT4ZTI.js";
+} from "./chunk-45VUHDV2.js";
 import {
   resolveDefaultNamespaceRoot
-} from "./chunk-KESJ5XX3.js";
+} from "./chunk-MYCCO6AA.js";
 import {
   StorageManager,
   readRawMemoryDocument
-} from "./chunk-WAD32CZG.js";
+} from "./chunk-ELWI2R6H.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
@@ -1869,4 +1869,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-T77AX6DG.js.map
+//# sourceMappingURL=chunk-TQVECGUQ.js.map

package/dist/{chunk-OQSSQOKQ.js → chunk-TV65NR7L.js}

@@ -1,7 +1,7 @@
 import {
   SupportPassportCreateGrantRequestSchema,
   defineOperation
-} from "./chunk-6LCWKS62.js";
+} from "./chunk-HVFX2N2G.js";
 import {
   SupportPassportCardCategorySchema,
   SupportPassportMemoryIdSchema,
@@ -220,4 +220,4 @@ var supportPassportGrantAskOperation = defineOperation({
     result: await ctx.service.supportPassportAskGrant(grantId, secret, question, ctx.abortSignal)
   })
 });
-//# sourceMappingURL=chunk-OQSSQOKQ.js.map
+//# sourceMappingURL=chunk-TV65NR7L.js.map

package/dist/{chunk-KQUSP6LB.js → chunk-UDKWFDV2.js}

@@ -577,4 +577,4 @@ export {
   FactHashIndexNotAuthoritativeError,
   ContentHashIndex
 };
-//# sourceMappingURL=chunk-KQUSP6LB.js.map
+//# sourceMappingURL=chunk-UDKWFDV2.js.map