dsh-context-compression-improved 0.5.0 → 0.5.2

package/packages/selector/src/client/review-scope.ts

@@ -1,16 +0,0 @@
-/**
- * The minimal face of the bound settings scope the review overlay consumes —
- * structural, so tests can stub it without the settings transport.
- */
-
-export interface SettingsScopeLike {
-  getSnapshot(): {
-    status: string
-    value?: {
-      presetOptions?: {
-        reviewMode?: boolean | undefined
-      } | undefined
-    } | undefined
-  }
-  subscribe(listener: () => void): () => void
-}

package/packages/selector/src/runtime/tokenpilot/proposal.ts

@@ -1,267 +0,0 @@
-/**
- * TokenPilot-inspired R4: benefit model for the human-gated review pipeline.
- *
- * Pure functions only: the classifier needs no I/O, no session state, and no
- * host services, so every decision is unit-testable and audit-replayable.
- *
- * The cost model follows the TokenPilot paper's cache-accounting view: one
- * merged mutation pays a one-time tail KV-cache refill penalty of
- * `(1−α)·tailTokens`, and every later turn recovers the reclaimed tokens at
- * the cache-hit discount `α`:
- *
- * ```
- * R              = Σ(tokensBefore − tokensAfter)   // net reclaimed tokens
- * paybackTurns   = (1−α)·tailTokens / (α·R)        // one-time refill / per-turn saving
- * expectedSaving = α·R·max(0, Ŝ − paybackTurns)    // Ŝ = estimated remaining turns
- * ```
- *
- * The refill penalty only models mutations of already-cached context. A
- * fresh-stage batch (shaped before its first request) is exempt via
- * `refillPenaltyExempt`: payback is 0 and every reclaimed token saves from
- * the very first turn.
- *
- * `expectedSaving` is only produced when Ŝ is known (the estimator answered
- * with `expectedRemainingTurns`); it is never fabricated from a guess.
- */
-import { createHash } from 'node:crypto'
-import type { ContentBlock } from '@deepseek-ai/dsh-llm'
-import { dedupeHash, flattenPlainText } from './dedup.ts'
-
-/** The minimal per-candidate face the benefit model consumes. */
-export interface BenefitCandidate {
-  readonly sourceSeq: number
-  readonly tokensBefore: number
-  readonly tokensAfter: number
-}
-
-export interface BenefitInput {
-  /** Cache-hit discount rate α ∈ (0,1); validated upstream by config parsing. */
-  readonly alpha: number
-  /** Token mass of the protected tail that must be refilled after a mutation. */
-  readonly tailTokens: number
-  /** Estimated remaining turns Ŝ; `undefined` keeps expectedSaving out of the result. */
-  readonly remainingTurns?: number | undefined
-  /** True for fresh-stage batches: their content was never served, so it is
-   *  not in the KV cache and shaping it causes no cache break — no refill
-   *  penalty applies and the whole discounted recovery is pure gain. */
-  readonly refillPenaltyExempt?: boolean | undefined
-}
-
-export interface BenefitEstimate {
-  /** Net reclaimed tokens across the batch; may be ≤ 0 when a batch is not worth it. */
-  readonly recoveredTokens: number
-  /** The one-time cache-refill penalty the merged mutation pays: (1−α)·tailTokens. */
-  readonly penaltyTokens: number
-  /** Turns of discounted recovery needed to recoup the penalty; `undefined` when α·R ≤ 0. */
-  readonly paybackTurns?: number
-  /** Discounted net benefit over the remaining session; omitted when Ŝ is unknown. */
-  readonly expectedSaving?: number
-}
-
-/**
- * Aggregate the batch-level benefit of a set of reduction candidates.
- *
- * Individual candidates whose replacement would grow the context contribute
- * zero recovery (they never make a batch look better than dropping them).
- */
-export function computeBenefit(candidates: readonly BenefitCandidate[], input: BenefitInput): BenefitEstimate {
-  const { alpha, tailTokens, remainingTurns } = input
-  let recoveredTokens = 0
-  for (const candidate of candidates) {
-    recoveredTokens += Math.max(0, candidate.tokensBefore - candidate.tokensAfter)
-  }
-  const penaltyTokens = input.refillPenaltyExempt === true ? 0 : (1 - alpha) * tailTokens
-  const perTurnSaving = alpha * recoveredTokens
-  if (perTurnSaving <= 0) {
-    return remainingTurns === undefined
-      ? { recoveredTokens, penaltyTokens }
-      : { recoveredTokens, penaltyTokens, expectedSaving: -penaltyTokens }
-  }
-  const paybackTurns = penaltyTokens / perTurnSaving
-  if (remainingTurns === undefined) {
-    return { recoveredTokens, penaltyTokens, paybackTurns }
-  }
-  return {
-    recoveredTokens,
-    penaltyTokens,
-    paybackTurns,
-    expectedSaving: perTurnSaving * Math.max(0, remainingTurns - paybackTurns),
-  }
-}
-
-/**
- * Stable proposal identity: the sha-256 of the serialized item digests, cut to
- * 12 hex chars. Stable across re-enqueues of the same content so a repeated
- * classification cannot duplicate a pending proposal.
- */
-export function proposalId(itemDigests: readonly string[]): string {
-  const hash = createHash('sha256')
-  for (const digest of itemDigests) hash.update(digest)
-  hash.update(String(itemDigests.length))
-  return hash.digest('hex').slice(0, 12)
-}
-
-/** Human-facing reduction kind carried by every review proposal. */
-export type ProposalKind = 'estimator' | 'dedup' | 'read-state'
-
-/** The minimal candidate face the triage classifier consumes. */
-export interface ClassifiableCandidate {
-  readonly sourceSeq: number
-  readonly tokensBefore: number
-  readonly tokensAfter: number
-  /** Compression primitive that planned this replacement. */
-  readonly component: string
-  /** Reducer id (`dedupe-pointer`, `superseded-read-whole-result`, …). */
-  readonly reducer: string
-  /** Content to freeze into the proposal digest. */
-  readonly content: readonly ContentBlock[]
-}
-
-export interface TriageInput {
-  /** Cache-hit discount rate α ∈ (0,1); validated upstream by config parsing. */
-  readonly alpha: number
-  /** Token mass of the protected tail that must be refilled after a mutation. */
-  readonly tailTokens: number
-  /** Candidates at or above this token impact skip triage and always enter review. */
-  readonly reviewHighImpactTokens: number
-  /** Estimated remaining turns Ŝ; `undefined` keeps the edge band closed. */
-  readonly remainingTurns?: number | undefined
-  /** Seqs whose reduction came from the estimator channel; overrides the kind. */
-  readonly estimatorSeqs?: ReadonlySet<number> | undefined
-  /** Landing stage of the batch: `'fresh'` batches are priced without the
-   *  tail-refill penalty (first-exposure shaping causes no cache break);
-   *  `'history'` batches — already-served content — pay it in full. */
-  readonly stage?: 'fresh' | 'history' | undefined
-}
-
-/** One frozen item inside a review proposal: metadata and digest, never content. */
-export interface ProposalItem {
-  readonly seq: number
-  readonly component: string
-  readonly kind: ProposalKind
-  readonly tokensBefore: number
-  readonly tokensAfter: number
-  /** Content sha-256 frozen at enqueue time and re-checked at the apply point. */
-  readonly digest: string
-}
-
-/** Proposal fields derivable at classification time; queue fields attach at enqueue. */
-export interface ProposalSkeleton {
-  readonly id: string
-  readonly kind: ProposalKind
-  readonly items: readonly ProposalItem[]
-  readonly benefit: BenefitEstimate
-}
-
-export interface ClassificationResult {
-  /** Clearly profitable candidates that keep the existing automatic path. */
-  readonly auto: readonly ClassifiableCandidate[]
-  /** Edge-band or high-impact candidates folded into review proposal skeletons. */
-  readonly review: readonly ProposalSkeleton[]
-  /** Negative-benefit candidates the pipeline keeps discarding. */
-  readonly drop: readonly ClassifiableCandidate[]
-}
-
-/**
- * Canonical content digest reused from the dedup hash: plain-text results hash
- * through the dedupe canonicalization; rich blocks fall back to canonical JSON
- * so every candidate is freezable.
- */
-export function contentDigest(content: readonly ContentBlock[]): string {
-  const text = flattenPlainText(content)
-  return dedupeHash(text ?? JSON.stringify(content), 'trim-eol')
-}
-
-function proposalKindFor(candidate: ClassifiableCandidate, estimatorSeqs: ReadonlySet<number> | undefined): ProposalKind {
-  if (estimatorSeqs?.has(candidate.sourceSeq) === true) return 'estimator'
-  if (candidate.reducer === 'dedupe-pointer') return 'dedup'
-  return 'read-state'
-}
-
-/**
- * Triage planned replacements into the three review-mode buckets, pricing the
- * pass as ONE merged mutation (R1): the tail KV-cache refill penalty is a
- * property of the landing event, not of any single candidate, so it must be
- * paid exactly once per batch. Pricing per candidate overstates the payback
- * N-fold and starves every real batch out of the auto path.
- *
- * Pipeline: zero/negative-recovery candidates are priced out first (they never
- * make a batch look better), the surviving batch is priced once through
- * `computeBenefit`, the verdict is a batch decision, and any high-impact
- * candidate (`tokensBefore ≥ reviewHighImpactTokens`) covers the whole batch
- * into review — splitting the batch would pay a second cache break that the
- * accounting does not model. Review skeletons are grouped one proposal per
- * kind; a proposal id covers every item digest.
- *
- * Batch verdict bands (identical thresholds to the per-candidate model):
- * - any high-impact candidate, or α too small to price a payback → review;
- * - `paybackTurns ≤ 1`, or Ŝ known and `paybackTurns ≤ 0.25·Ŝ` → auto;
- * - Ŝ known and `paybackTurns ∈ (1, 3]` → review;
- * - everything else (Ŝ unknown with a slow payback) → drop.
- *
- * Stage asymmetry: a `'fresh'` batch is exempt from the tail-refill penalty
- * (`refillPenaltyExempt`) — its content was never served, so compressing it
- * breaks no cache and payback is 0 — while a `'history'` batch mutates
- * already-cached context and pays `(1−α)·tailTokens` in full. Without this
- * exemption every realistic fresh batch prices into the drop band and the
- * auto bucket stays structurally unreachable.
- */
-export function classifyCandidates(
-  candidates: readonly ClassifiableCandidate[],
-  input: TriageInput,
-): ClassificationResult {
-  const drop: ClassifiableCandidate[] = []
-  const usable: ClassifiableCandidate[] = []
-  for (const candidate of candidates) {
-    if (Math.max(0, candidate.tokensBefore - candidate.tokensAfter) <= 0) {
-      drop.push(candidate)
-      continue
-    }
-    usable.push(candidate)
-  }
-  if (usable.length === 0) return { auto: [], review: [], drop }
-
-  const benefit = computeBenefit(usable, {
-    alpha: input.alpha,
-    tailTokens: input.tailTokens,
-    ...input.remainingTurns !== undefined ? { remainingTurns: input.remainingTurns } : {},
-    refillPenaltyExempt: input.stage === 'fresh',
-  })
-  const payback = benefit.paybackTurns
-  const highImpact = usable.some(candidate => candidate.tokensBefore >= input.reviewHighImpactTokens)
-  let verdict: 'auto' | 'review' | 'drop'
-  if (highImpact || payback === undefined) {
-    // High impact covers the whole batch; α too small to price a payback has
-    // no discounted recovery to argue from, so a human decides.
-    verdict = 'review'
-  } else if (payback <= 1
-    || (input.remainingTurns !== undefined && payback <= 0.25 * input.remainingTurns)) {
-    verdict = 'auto'
-  } else if (input.remainingTurns !== undefined && payback <= 3) {
-    verdict = 'review'
-  } else {
-    verdict = 'drop'
-  }
-  if (verdict === 'auto') return { auto: usable, review: [], drop }
-  if (verdict === 'drop') return { auto: [], review: [], drop: [...drop, ...usable] }
-
-  const itemsByKind = new Map<ProposalKind, ProposalItem[]>()
-  for (const candidate of usable) {
-    const item: ProposalItem = {
-      seq: candidate.sourceSeq,
-      component: candidate.component,
-      kind: proposalKindFor(candidate, input.estimatorSeqs),
-      tokensBefore: candidate.tokensBefore,
-      tokensAfter: candidate.tokensAfter,
-      digest: contentDigest(candidate.content),
-    }
-    const bucket = itemsByKind.get(item.kind) ?? []
-    bucket.push(item)
-    itemsByKind.set(item.kind, bucket)
-  }
-  const review: ProposalSkeleton[] = []
-  for (const [kind, items] of itemsByKind) {
-    review.push({ id: proposalId(items.map(item => item.digest)), kind, items, benefit })
-  }
-  return { auto: [], review, drop }
-}

package/packages/selector/src/runtime/tokenpilot/review-queue.ts

@@ -1,231 +0,0 @@
-/**
- * TokenPilot-inspired R4: the human-gated review queue.
- *
- * One durable session record per session holds every live proposal (pending or
- * approved). Records carry metadata only — ids, seqs, digests, token counts,
- * statuses, and reason codes — never message content, mirroring the upstream
- * Cleaner persistence rule. The store face is a minimal KV pair so the queue
- * is host-agnostic: the runtime wiring attempts the `storageDomain` seam and
- * degrades to an in-memory Map (restart-lossy, acceptable for a short-lived
- * pending queue) whenever the seam is absent or fails.
- *
- * The human-side status set is `pending / approved / rejected / ignored /
- * expired`, orthogonal to the execution-side receipt states
- * (`applied / deferred`) recorded when an approved batch actually lands.
- */
-import type { ProposalKind, ProposalSkeleton } from './proposal.ts'
-
-/** Human-side proposal status. */
-export type ReviewProposalStatus = 'pending' | 'approved' | 'rejected' | 'ignored' | 'expired'
-
-/** Execution-side receipt built only from real mutation evidence (never estimated). */
-export interface ReviewReceipt {
-  readonly status: 'applied' | 'deferred'
-  /** Reason code for deferred receipts, aligned with the upstream naming. */
-  readonly reasonCode?: string
-  /** Predicted recovery from the benefit model at enqueue time. */
-  readonly estimatedTokens: number
-  /** Measured recovery of the landed mutation; present only on applied. */
-  readonly appliedTokens?: number
-  /** Canonical ISO timestamp of the execution evidence. */
-  readonly updatedAt: string
-}
-
-/** One queued proposal: persisted metadata, never content. */
-export interface ReviewProposalRecord {
-  readonly id: string
-  readonly sessionId: string
-  readonly kind: ProposalKind
-  readonly items: readonly {
-    readonly seq: number
-    readonly component: string
-    readonly kind: ProposalKind
-    readonly tokensBefore: number
-    readonly tokensAfter: number
-    readonly digest: string
-  }[]
-  readonly benefit: {
-    readonly recoveredTokens: number
-    readonly penaltyTokens: number
-    readonly paybackTurns?: number
-    readonly expectedSaving?: number
-  }
-  status: ReviewProposalStatus
-  readonly enqueuedTurn: number
-  lastTurnIndex: number
-}
-
-/** Whole-session record: one durable KV value per session. */
-export interface ReviewSessionRecord {
-  readonly version: 1
-  readonly proposals: readonly ReviewProposalRecord[]
-}
-
-/** A settled proposal: the live record plus its execution receipt. */
-export interface ReviewReceiptRecord extends ReviewProposalRecord {
-  readonly receipt: ReviewReceipt
-}
-
-/** Minimal KV face the queue persists through. */
-export interface ReviewQueueStore {
-  load(sessionId: string): ReviewSessionRecord | undefined
-  save(sessionId: string, record: ReviewSessionRecord): void
-  /** Session ids with live records; optional (aggregate reads degrade to none). */
-  ids?(): readonly string[]
-}
-
-/** In-memory store: the fail-open fallback when no durable seam is available. */
-export class MemoryReviewStore implements ReviewQueueStore {
-  private readonly sessions = new Map<string, ReviewSessionRecord>()
-
-  load(sessionId: string): ReviewSessionRecord | undefined {
-    return this.sessions.get(sessionId)
-  }
-
-  save(sessionId: string, record: ReviewSessionRecord): void {
-    this.sessions.set(sessionId, record)
-  }
-
-  ids(): readonly string[] {
-    return [...this.sessions.keys()]
-  }
-}
-
-export interface ReviewQueueOptions {
-  /** Pending proposals older than this many turns (since lastTurnIndex) expire. */
-  readonly timeoutTurns: number
-}
-
-/** Decision outcomes for one decide call. */
-export type DecideOutcome =
-  | { readonly ok: true }
-  | { readonly ok: false, readonly reason: 'unknown-proposal' | 'not-pending' }
-
-export class ReviewQueue {
-  constructor(
-    private readonly store: ReviewQueueStore,
-    private readonly options: ReviewQueueOptions,
-  ) {}
-
-  /**
-   * Fail-open store access: a throwing seam must never break the compression
-   * pipeline. Reads degrade to "no stored record"; writes degrade to losing
-   * durability for that call (the store itself is expected to warn).
-   */
-  private safeLoad(sessionId: string): ReviewSessionRecord | undefined {
-    try {
-      return this.store.load(sessionId)
-    } catch {
-      return undefined
-    }
-  }
-
-  private safeSave(sessionId: string, record: ReviewSessionRecord): void {
-    try {
-      this.store.save(sessionId, record)
-    } catch {
-      // Durability lost for this write; the queue stays functional in memory.
-    }
-  }
-
-  private sessionRecord(sessionId: string): ReviewSessionRecord {
-    return this.safeLoad(sessionId) ?? { version: 1, proposals: [] }
-  }
-
-  /**
-   * Queue one classified proposal. A repeated classification of the same
-   * content re-does nothing but refresh the patience clock, so re-enqueue
-   * cannot duplicate a live proposal.
-   * @returns `false` when an identical live proposal already exists.
-   */
-  enqueue(sessionId: string, skeleton: ProposalSkeleton, turnIndex: number): boolean {
-    const record = this.sessionRecord(sessionId)
-    const existing = record.proposals.find(entry => entry.id === skeleton.id)
-    if (existing !== undefined && existing.status !== 'expired') {
-      existing.lastTurnIndex = turnIndex
-      this.safeSave(sessionId, record)
-      return false
-    }
-    const proposal: ReviewProposalRecord = {
-      id: skeleton.id,
-      sessionId,
-      kind: skeleton.kind,
-      items: skeleton.items.map(item => ({ ...item })),
-      benefit: { ...skeleton.benefit },
-      status: 'pending',
-      enqueuedTurn: turnIndex,
-      lastTurnIndex: turnIndex,
-    }
-    this.safeSave(sessionId, {
-      version: 1,
-      // Expired duplicates are dropped: the fresh skeleton re-enters as pending.
-      proposals: [...record.proposals.filter(entry => entry.id !== skeleton.id), proposal],
-    })
-    return true
-  }
-
-  /** Live pending proposals of one session, oldest enqueue first. */
-  listPending(sessionId: string): readonly ReviewProposalRecord[] {
-    return this.sessionRecord(sessionId).proposals
-      .filter(entry => entry.status === 'pending')
-      .sort((left, right) => left.enqueuedTurn - right.enqueuedTurn)
-  }
-
-  /** Approved proposals waiting for the next turn-boundary batch. */
-  listApproved(sessionId: string): readonly ReviewProposalRecord[] {
-    return this.sessionRecord(sessionId).proposals
-      .filter(entry => entry.status === 'approved')
-      .sort((left, right) => left.enqueuedTurn - right.enqueuedTurn)
-  }
-
-  /**
-   * Transition one pending proposal. Idempotent: deciding an unknown id or a
-   * non-pending proposal changes nothing and reports the miss.
-   */
-  decide(sessionId: string, id: string, decision: 'approved' | 'rejected' | 'ignored'): DecideOutcome {
-    const record = this.sessionRecord(sessionId)
-    const proposal = record.proposals.find(entry => entry.id === id)
-    if (proposal === undefined) return { ok: false, reason: 'unknown-proposal' }
-    if (proposal.status !== 'pending') return { ok: false, reason: 'not-pending' }
-    proposal.status = decision
-    this.safeSave(sessionId, record)
-    return { ok: true }
-  }
-
-  /**
-   * Expire every pending proposal whose patience has run out at this turn
-   * boundary. Expired proposals are removed from the store (the summary view
-   * aggregates them from the audit log instead).
-   * @returns the expired proposals, for the caller's audit emission.
-   */
-  expireTurn(sessionId: string, turnIndex: number): readonly ReviewProposalRecord[] {
-    const record = this.sessionRecord(sessionId)
-    const keep: ReviewProposalRecord[] = []
-    const expired: ReviewProposalRecord[] = []
-    for (const proposal of record.proposals) {
-      if (proposal.status === 'pending' && turnIndex - proposal.lastTurnIndex > this.options.timeoutTurns) {
-        expired.push({ ...proposal, status: 'expired' })
-        continue
-      }
-      keep.push(proposal)
-    }
-    if (expired.length > 0) this.safeSave(sessionId, { version: 1, proposals: keep })
-    return expired
-  }
-
-  /**
-   * Settle an approved proposal with its execution receipt and retire it from
-   * the live store. The caller is responsible for auditing the receipt; the
-   * queue only records which proposal left and why.
-   */
-  recordReceipt(sessionId: string, id: string, receipt: ReviewReceipt): ReviewReceiptRecord | undefined {
-    const record = this.sessionRecord(sessionId)
-    const proposal = record.proposals.find(entry => entry.id === id)
-    if (proposal === undefined || proposal.status !== 'approved') return undefined
-    this.safeSave(sessionId, {
-      version: 1,
-      proposals: record.proposals.filter(entry => entry.id !== id),
-    })
-    return { ...proposal, receipt }
-  }
-}

package/packages/selector/src/runtime/tokenpilot/review-registry.ts

@@ -1,117 +0,0 @@
-/**
- * Scope-independent handle on the live review pipeline.
- *
- * The R4 HTTP routes are registered on the plugin's TOP-LEVEL fiber
- * (`cordis.patch.yml` → `context-compression-improved-estimator-catalog`),
- * but every `ToolResultPruner` is mounted inside an agent preset's isolated
- * group — `canonicalCompressionRows()` declares
- * `isolate: { compaction: true, toolResultPruner: true }` — so
- * `ctx.get('toolResultPruner')` at the top level is always `undefined` and the
- * queue route could only ever answer 503 "review pipeline unavailable".
- *
- * Ownership, not transport, was in the wrong place: the queue records are
- * already keyed by session id, so the store belongs to the plugin rather than
- * to one pruner instance. Every instance shares one store and publishes itself
- * here, which lets a top-level reader reach whichever instance currently holds
- * a session's proposals.
- *
- * The durable seam already behaves this way — `REVIEW_STORAGE_DOMAIN` /
- * `REVIEW_STORAGE_TABLE` are constants, so every instance opens the same table.
- * Only the in-memory fallback was per-instance, and that is what this module
- * makes shared.
- *
- * @module dsh-context-compression-improved/review-registry
- */
-
-import { MemoryReviewStore, type ReviewQueueStore } from './review-queue.ts'
-
-/**
- * The review faces the HTTP routes consume — structural, so the concrete
- * `ToolResultPruner` (a Cordis service with a far wider surface) satisfies it
- * without this module depending on the runtime class.
- */
-export interface ReviewPrunerFace {
-  listReviewProposals(session: unknown): readonly {
-    readonly id: string
-    readonly kind: string
-    readonly items: readonly {
-      readonly seq: number
-      readonly kind: string
-      readonly component: string
-      readonly tokensBefore: number
-      readonly tokensAfter: number
-    }[]
-    readonly benefit: {
-      readonly recoveredTokens: number
-      readonly penaltyTokens: number
-      readonly paybackTurns?: number
-      readonly expectedSaving?: number
-    }
-    readonly enqueuedTurn: number
-    readonly lastTurnIndex: number
-  }[]
-  decideReviewProposal(
-    session: unknown,
-    proposalId: string,
-    decision: 'approved' | 'rejected' | 'ignored',
-  ): { ok: true } | { ok: false, reason: string } | undefined
-  /** Aggregate pending read; absent on older builds (routes then degrade to 503). */
-  listAllReviewProposals?(): readonly {
-    readonly sessionId: string
-    readonly proposals: readonly {
-      readonly id: string
-      readonly kind: string
-      readonly items: readonly { readonly seq: number; readonly kind: string; readonly component: string; readonly tokensBefore: number; readonly tokensAfter: number }[]
-      readonly benefit: { readonly recoveredTokens: number; readonly penaltyTokens: number; readonly paybackTurns?: number; readonly expectedSaving?: number }
-      readonly enqueuedTurn: number
-      readonly lastTurnIndex: number
-    }[]
-  }[]
-  reviewSummary?(session: unknown): {
-    readonly autoApplied: number
-    readonly reviewApplied: number
-    readonly expired: number
-    readonly voided: number
-  }
-}
-
-/**
- * The one in-memory fallback every pruner instance starts from. Session ids are
- * globally unique and `ReviewSessionRecord` is keyed by them, so a single store
- * is semantically identical to one store per instance — except that a reader
- * reaching any instance now observes every session.
- */
-const sharedStore: ReviewQueueStore = new MemoryReviewStore()
-
-const live = new Set<ReviewPrunerFace>()
-
-/** The process-wide review queue store shared by every pruner instance. */
-export function sharedReviewStore(): ReviewQueueStore {
-  return sharedStore
-}
-
-/**
- * Publish one pruner instance for scope-independent readers.
- * @param pruner - the instance to publish.
- * @returns the disposer removing it, for `ctx.effect`.
- */
-export function registerReviewPruner(pruner: ReviewPrunerFace): () => void {
-  live.add(pruner)
-  return () => {
-    live.delete(pruner)
-  }
-}
-
-/**
- * Resolve a live pruner instance for the top-level routes.
- *
- * Any instance can serve an aggregate read because the store is shared, and a
- * session-scoped read is answered from that same store. Instances that have
- * upgraded to the durable seam read the same table, so the answer does not
- * depend on which instance this happens to return.
- *
- * @returns a live instance, or `undefined` when no preset has been composed yet.
- */
-export function resolveReviewPruner(): ReviewPrunerFace | undefined {
-  return live.values().next().value
-}