dsh-context-compression-improved 0.3.0 → 0.4.0-beta.1

package/packages/selector/tests/runtime/tokenpilot/proposal.spec.ts

@@ -0,0 +1,199 @@
+import { describe, expect, it } from 'vitest'
+import {
+  classifyCandidates,
+  computeBenefit,
+  proposalId,
+} from '../../../src/runtime/tokenpilot/proposal.ts'
+
+/** Reference values follow the spec formulas exactly:
+ *  R = Σ(before − after); penalty = (1−α)·tail; payback = penalty / (α·R);
+ *  expectedSaving = α·R·max(0, Ŝ − payback). */
+
+describe('computeBenefit', () => {
+  it('returns zero recovery and no payback for an empty batch', () => {
+    const result = computeBenefit([], { alpha: 0.1, tailTokens: 4000 })
+    expect(result.recoveredTokens).toBe(0)
+    expect(result.penaltyTokens).toBe(3600)
+    expect(result.paybackTurns).toBeUndefined()
+    expect(result.expectedSaving).toBeUndefined()
+  })
+
+  it('computes the single-candidate benefit with a known remaining-turn estimate', () => {
+    // R = 4000 − 400 = 3600; penalty = 0.9·4000 = 3600; per-turn = 0.1·3600 = 360
+    const result = computeBenefit(
+      [{ sourceSeq: 7, tokensBefore: 4000, tokensAfter: 400 }],
+      { alpha: 0.1, tailTokens: 4000, remainingTurns: 12 },
+    )
+    expect(result.recoveredTokens).toBe(3600)
+    expect(result.penaltyTokens).toBeCloseTo(3600)
+    expect(result.paybackTurns).toBeCloseTo(10)
+    // α·R·max(0, 12 − 10) = 360·2
+    expect(result.expectedSaving).toBeCloseTo(720)
+  })
+
+  it('omits expectedSaving while Ŝ is unknown', () => {
+    const result = computeBenefit(
+      [{ sourceSeq: 7, tokensBefore: 4000, tokensAfter: 400 }],
+      { alpha: 0.1, tailTokens: 4000 },
+    )
+    expect(result.paybackTurns).toBeCloseTo(10)
+    expect(result.expectedSaving).toBeUndefined()
+  })
+
+  it('merges candidates into one batch so the penalty is paid once', () => {
+    const result = computeBenefit(
+      [
+        { sourceSeq: 1, tokensBefore: 2000, tokensAfter: 500 },
+        { sourceSeq: 2, tokensBefore: 3000, tokensAfter: 1000 },
+      ],
+      { alpha: 0.1, tailTokens: 4000, remainingTurns: 20 },
+    )
+    expect(result.recoveredTokens).toBe(3500)
+    expect(result.penaltyTokens).toBeCloseTo(3600)
+    expect(result.paybackTurns).toBeCloseTo(3600 / 350)
+    expect(result.expectedSaving).toBeCloseTo(350 * (20 - 3600 / 350))
+  })
+
+  it('clamps a growing candidate to zero recovery instead of negative batch credit', () => {
+    const result = computeBenefit(
+      [{ sourceSeq: 3, tokensBefore: 100, tokensAfter: 400 }],
+      { alpha: 0.1, tailTokens: 4000 },
+    )
+    expect(result.recoveredTokens).toBe(0)
+    expect(result.paybackTurns).toBeUndefined()
+  })
+
+  it('stays finite as α → 0: no division, payback undefined, expectedSaving negative', () => {
+    const result = computeBenefit(
+      [{ sourceSeq: 4, tokensBefore: 4000, tokensAfter: 400 }],
+      { alpha: 0, tailTokens: 4000, remainingTurns: 12 },
+    )
+    expect(result.recoveredTokens).toBe(3600)
+    expect(result.paybackTurns).toBeUndefined()
+    // With zero per-turn saving the batch can only lose the refill penalty.
+    expect(result.expectedSaving).toBeCloseTo(-4000)
+  })
+
+  it('never reports a positive expectedSaving once Ŝ is inside the payback window', () => {
+    // payback = 10 turns; Ŝ = 5 → max(0, Ŝ − payback) = 0
+    const result = computeBenefit(
+      [{ sourceSeq: 7, tokensBefore: 4000, tokensAfter: 400 }],
+      { alpha: 0.1, tailTokens: 4000, remainingTurns: 5 },
+    )
+    expect(result.expectedSaving).toBeCloseTo(0)
+  })
+})
+
+describe('proposalId', () => {
+  it('is stable for the same digest list and length-sensitive', () => {
+    const digests = ['aa'.repeat(32), 'bb'.repeat(32)]
+    expect(proposalId(digests)).toBe(proposalId([...digests]))
+    expect(proposalId(digests)).toHaveLength(12)
+    expect(proposalId(digests)).not.toBe(proposalId([digests[0]!, digests[1]!, digests[0]!]))
+  })
+
+  it('distinguishes an empty batch from a single digest', () => {
+    expect(proposalId([])).not.toBe(proposalId(['cc'.repeat(32)]))
+  })
+})
+
+/** Triage fixtures: α=0.5 keeps the arithmetic obvious —
+ *  payback = 0.5·tail / (0.5·R) = tail / R. */
+const TRIAGE = { alpha: 0.5, tailTokens: 1000, reviewHighImpactTokens: 4000 }
+
+function candidate(overrides: {
+  sourceSeq?: number
+  tokensBefore?: number
+  tokensAfter?: number
+  reducer?: string
+  component?: string
+}): Parameters<typeof classifyCandidates>[0][number] {
+  return {
+    sourceSeq: overrides.sourceSeq ?? 1,
+    tokensBefore: overrides.tokensBefore ?? 1000,
+    tokensAfter: overrides.tokensAfter ?? 500,
+    reducer: overrides.reducer ?? 'native-whole-result',
+    component: overrides.component ?? 'native-tool-result',
+    content: [{ type: 'text', text: 'opaque result body' }],
+  }
+}
+
+describe('classifyCandidates', () => {
+  it('auto-applies the clearly profitable band and drops negative recovery', () => {
+    // tail/R = 1000/1000 = 1 → payback = 1 → auto; R = 0 → drop.
+    const result = classifyCandidates(
+      [candidate({ sourceSeq: 1, tokensBefore: 2000, tokensAfter: 1000 }), candidate({ sourceSeq: 2, tokensBefore: 500, tokensAfter: 500 })],
+      TRIAGE,
+    )
+    expect(result.auto.map(entry => entry.sourceSeq)).toEqual([1])
+    expect(result.drop.map(entry => entry.sourceSeq)).toEqual([2])
+    expect(result.review).toEqual([])
+  })
+
+  it('sends high-impact candidates to review even inside the auto band', () => {
+    // payback = 1000/5000 = 0.2 ≤ 1, but tokensBefore ≥ 4000 → review ("直接送审").
+    const result = classifyCandidates(
+      [candidate({ tokensBefore: 5000, tokensAfter: 4000 })],
+      TRIAGE,
+    )
+    expect(result.auto).toEqual([])
+    expect(result.review).toHaveLength(1)
+    expect(result.review[0]!.items[0]!.tokensBefore).toBe(5000)
+  })
+
+  it('keeps the Ŝ-gated edge band in review and closes it while Ŝ is unknown', () => {
+    // payback = 1000/200 = 5: with Ŝ = 40 → 5 ≤ 0.25·40 = 10 → auto.
+    const known = classifyCandidates(
+      [candidate({ tokensBefore: 1200, tokensAfter: 1000 })],
+      { ...TRIAGE, remainingTurns: 40 },
+    )
+    expect(known.auto).toHaveLength(1)
+    // payback = 1000/50 = 20: with Ŝ = 40, 20 > 0.25·40 and > 3 → drop.
+    const slow = classifyCandidates(
+      [candidate({ tokensBefore: 1050, tokensAfter: 1000 })],
+      { ...TRIAGE, remainingTurns: 40 },
+    )
+    expect(slow.drop).toHaveLength(1)
+    // Same slow candidate with Ŝ unknown → no edge band, no auto → drop.
+    const unknown = classifyCandidates(
+      [candidate({ tokensBefore: 1050, tokensAfter: 1000 })],
+      TRIAGE,
+    )
+    expect(unknown.drop).toHaveLength(1)
+    // payback = 1000/400 = 2.5: Ŝ = 8 → 2.5 > 0.25·8 = 2 and ≤ 3 → review.
+    const edge = classifyCandidates(
+      [candidate({ tokensBefore: 1400, tokensAfter: 1000 })],
+      { ...TRIAGE, remainingTurns: 8 },
+    )
+    expect(edge.review).toHaveLength(1)
+    // Same edge candidate with Ŝ unknown → drop.
+    const edgeUnknown = classifyCandidates(
+      [candidate({ tokensBefore: 1400, tokensAfter: 1000 })],
+      TRIAGE,
+    )
+    expect(edgeUnknown.drop).toHaveLength(1)
+  })
+
+  it('freezes digest, kind, and benefit into the review skeleton', () => {
+    const result = classifyCandidates(
+      [candidate({ sourceSeq: 9, reducer: 'dedupe-pointer', component: 'fresh' })],
+      // payback = 1000/500 = 2: Ŝ = 6 → 2 > 0.25·6 = 1.5 and ≤ 3 → review.
+      { ...TRIAGE, remainingTurns: 6 },
+    )
+    const skeleton = result.review[0]!
+    expect(skeleton.kind).toBe('dedup')
+    expect(skeleton.items[0]!.seq).toBe(9)
+    expect(skeleton.items[0]!.digest).toMatch(/^[0-9a-f]{64}$/)
+    expect(skeleton.items[0]!.kind).toBe('dedup')
+    expect(skeleton.benefit.recoveredTokens).toBe(500)
+    expect(skeleton.id).toEqual(proposalId([skeleton.items[0]!.digest]))
+  })
+
+  it('labels estimator-channel seqs without changing the triage math', () => {
+    const result = classifyCandidates(
+      [candidate({ sourceSeq: 11, reducer: 'superseded-read-whole-result', component: 'history' })],
+      { ...TRIAGE, remainingTurns: 6, estimatorSeqs: new Set([11]) },
+    )
+    expect(result.review[0]!.kind).toBe('estimator')
+  })
+})

package/packages/selector/tests/runtime/tokenpilot/pruner-review.spec.ts

@@ -0,0 +1,313 @@
+/**
+ * TokenPilot-inspired R4 integration coverage: the human-gated review pipeline
+ * on published Harness APIs. Mirrors the public-runtime harness (real
+ * Session/log, exact tokenizer, host settings) and pins the four acceptance
+ * behaviors from the phase-1 spec: approved proposals execute as one merged
+ * batch at the turn boundary with evidence-built receipts; tampered content
+ * voids instead of deleting; expired proposals never execute; review-off
+ * behavior stays byte-identical to the automatic path.
+ */
+import { describe, expect, it, vi } from 'vitest'
+import { Context } from '@deepseek-ai/cordis'
+import {
+  ToolCallId as CallId,
+  createMessage,
+  createUserMessage,
+  createToolResultMessage,
+  freezeMessage,
+} from '@deepseek-ai/dsh-llm'
+import SessionStore, {
+  Session,
+  SessionId,
+  SessionSeq,
+  canonicalHeader,
+} from '@deepseek-ai/dsh-session'
+import {
+  SettingsProvider,
+  type SettingsNamespace,
+} from '@deepseek-ai/dsh-settings'
+import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
+import SessionProjectionRegistry from '@deepseek-ai/dsh-session-projection'
+import TokenMeter from '@deepseek-ai/dsh-token-meter'
+import ToolRuntime from '@deepseek-ai/dsh-tools'
+import * as SelectorHost from '../../../src/index.ts'
+import { sessionEvents } from '../../../src/runtime/session-events.ts'
+import ToolResultPruner, {
+  CONTEXT_COMPRESSION_SETTINGS_NAMESPACE,
+} from '../../../src/pruner.ts'
+import { measureForCompaction } from '../../../src/runtime/measurement.ts'
+import {
+  COMPRESSION_AUDIT_PREFIX,
+  type CompressionAuditRecord,
+  type CompressionRewriteAuditRecord,
+  type ReviewOutcomeAuditRecord,
+} from '../../../src/runtime/audit.ts'
+
+const MODEL = 'deepseek-v4-flash'
+
+class TestSettings extends SettingsProvider {
+  readonly writable = true
+  private readonly stored: Record<string, unknown> = {}
+
+  protected override load(): Promise<Record<string, unknown>> {
+    return Promise.resolve(structuredClone(this.stored))
+  }
+
+  protected override persist(namespace: SettingsNamespace, section: Record<string, unknown>): Promise<void> {
+    this.stored[namespace] = structuredClone(section)
+    return Promise.resolve()
+  }
+}
+
+async function runtimeContext(): Promise<Context> {
+  const ctx = new Context()
+  await ctx.plugin(SessionStore).await()
+  await ctx.plugin(SystemPrompt).await()
+  await ctx.plugin(ToolRuntime).await()
+  await ctx.plugin(SessionProjectionRegistry).await()
+  await ctx.plugin(TokenMeter).await()
+  return ctx
+}
+
+function captureAudit(ctx: Context): { records(): CompressionAuditRecord[] } {
+  const info = vi.spyOn(ctx.logger, 'info').mockImplementation(() => ctx.logger)
+  return {
+    records: () => info.mock.calls.flatMap((call) => {
+      const line = String(call[0])
+      return line.startsWith(COMPRESSION_AUDIT_PREFIX)
+        ? [JSON.parse(line.slice(COMPRESSION_AUDIT_PREFIX.length)) as CompressionAuditRecord]
+        : []
+    }),
+  }
+}
+
+function rewrites(records: readonly CompressionAuditRecord[]): CompressionRewriteAuditRecord[] {
+  return records.filter((record): record is CompressionRewriteAuditRecord => record.kind === 'rewrite')
+}
+
+function reviewEvents(records: readonly CompressionAuditRecord[]): ReviewOutcomeAuditRecord[] {
+  return records.filter((record): record is ReviewOutcomeAuditRecord => record.kind === 'review-outcome')
+}
+
+const nsBrand = (value: string): SettingsNamespace => value as unknown as SettingsNamespace
+
+function appendToolTurn(
+  session: Session,
+  turn: number,
+  text: string,
+  closeTurn: boolean,
+): { readonly assistantSeq: number; readonly resultSeq: number } {
+  const callId = CallId(`call-${String(turn)}`)
+  session.append('turn/start', { turn })
+  if (session.requestHeader() === undefined) {
+    session.append('request/header', {
+      reason: 'initial',
+      header: canonicalHeader({ config: { provider: 'deepseek', model: MODEL } }),
+    })
+  }
+  session.append('user/message', createUserMessage({
+    content: [{ type: 'text', text: `user turn ${String(turn)}` }],
+    source: { kind: 'user' },
+  }), { surfaceOp: 'append' })
+  session.append('step/start', { turn, step: 1 })
+  const assistant = session.append('assistant/message', {
+    stream: [],
+    turn,
+    step: 1,
+    message: createMessage({
+      role: 'assistant',
+      content: [{ type: 'tool-call', id: callId, name: 'bash', arguments: '{}' }],
+      source: { kind: 'model', provider: 'deepseek', model: MODEL },
+    }),
+  }, { surfaceOp: 'append' })
+  session.append('tool/call', { turn, step: 1, callId, name: 'bash', arguments: '{}' })
+  const result = session.append('tool/result', {
+    turn,
+    step: 1,
+    message: createToolResultMessage({
+      callId,
+      content: [{ type: 'text', text }],
+      isError: false,
+    }),
+  }, { surfaceOp: 'append' })
+  session.append('step/end', { turn, step: 1 })
+  if (closeTurn) session.append('turn/end', { turn, reason: { kind: 'completed' } })
+  return { assistantSeq: assistant.seq, resultSeq: result.seq }
+}
+
+/** Rewrite one surface tool result in place, the way land() publishes a replacement. */
+function tamperResult(session: Session, seq: number, text: string): void {
+  const event = sessionEvents(session).find(entry => entry.seq === seq)
+  if (event?.type !== 'tool/result') throw new Error(`seq ${String(seq)} is not a tool result`)
+  const message = event.data.message
+  // The session accepts a surface replacement only when every non-content
+  // field stays identical, so freeze the original message and swap the blocks.
+  session.append('tool/result', {
+    ...event.data,
+    message: freezeMessage({
+      ...message,
+      content: [{ ...message.content[0], content: [{ type: 'text', text }] }],
+    }),
+  }, {
+    surfaceOp: { op: 'replace', startSeq: SessionSeq(seq), endSeq: SessionSeq(seq) },
+    sourceEventSeqs: [SessionSeq(seq)],
+  })
+}
+
+async function reviewSetup(ctx: Context, reviewMode: boolean): Promise<void> {
+  await ctx.plugin(TestSettings).await()
+  await ctx.plugin(SelectorHost).await()
+  await ctx.settings.update(nsBrand(CONTEXT_COMPRESSION_SETTINGS_NAMESPACE), {
+    profile: 'tokenpilot-inspired',
+    ...(reviewMode
+      ? { presetOptions: { reviewMode: true, reviewHighImpactTokens: 1 } }
+      : {}),
+  })
+  await ctx.plugin(ToolResultPruner, {
+    profile: 'tokenpilot-inspired',
+    freshTriggerTokens: 100_000,
+    freshTargetTokens: 90_000,
+    aggregateTriggerTokens: 100_000,
+    aggregateTargetTokens: 90_000,
+    historyTriggerTokens: 400,
+    historyKeepRecentToolCalls: 0,
+    historyKeepRecentTokens: 1,
+    historyMinReclaimTokens: 1,
+  }).await()
+}
+
+/** One aged old result plus one protected recent result, with an open turn. */
+function reviewSession(ctx: Context, id: string, oldText: string): {
+  session: Session
+  oldResultSeq: number
+} {
+  const pruner = ctx.toolResultPruner
+  const session = Session.create(SessionId(id))
+  const old = appendToolTurn(session, 1, oldText, true)
+  appendToolTurn(session, 2, 'newest protected result', true)
+  const total = measureForCompaction(ctx, session).totalTokens
+  session.append('request/context', {
+    provider: 'deepseek',
+    model: MODEL,
+    contextWindow: Math.floor(total / 0.6),
+  })
+  session.append('turn/start', { turn: 3 })
+  return { session, oldResultSeq: old.resultSeq }
+}
+
+describe('tokenpilot review pipeline (host integration)', () => {
+  it('withholds high-impact candidates from landing and queues them for review', async () => {
+    const ctx = await runtimeContext()
+    await reviewSetup(ctx, true)
+    const audit = captureAudit(ctx)
+    const { session, oldResultSeq } = reviewSession(ctx, 'review-queue-withhold', 'old reviewable evidence '.repeat(600))
+
+    const result = ctx.toolResultPruner.pruneSession(session, { stage: 'pressure' })
+
+    // The old candidate was planned but withheld: nothing landed.
+    expect(result.pruned).toHaveLength(0)
+    const pending = ctx.toolResultPruner.listReviewProposals(session)
+    expect(pending).toHaveLength(1)
+    expect(pending[0]!.status).toBe('pending')
+    expect(pending[0]!.items[0]!.seq).toBe(oldResultSeq)
+    expect(reviewEvents(audit.records()).filter(entry => entry.event === 'enqueue')).toHaveLength(1)
+    // And the original content is still on the surface.
+    expect(rewrites(audit.records())).toHaveLength(0)
+  })
+
+  it('executes an approved proposal at the turn boundary with an evidence-built receipt', async () => {
+    const ctx = await runtimeContext()
+    await reviewSetup(ctx, true)
+    const audit = captureAudit(ctx)
+    const { session } = reviewSession(ctx, 'review-apply-e2e', 'old reviewable evidence '.repeat(600))
+    ctx.toolResultPruner.pruneSession(session, { stage: 'pressure' })
+    const pending = ctx.toolResultPruner.listReviewProposals(session)
+    const proposalId = pending[0]!.id
+
+    expect(ctx.toolResultPruner.decideReviewProposal(session, proposalId, 'approved')).toEqual({ ok: true })
+    expect(reviewEvents(audit.records()).some(entry => entry.event === 'decide' && entry.decision === 'approved')).toBe(true)
+
+    ctx.toolResultPruner.applyApprovedProposals(session)
+
+    const applied = rewrites(audit.records()).filter(entry => entry.reducer === 'review-approved-whole-result')
+    expect(applied).toHaveLength(1)
+    expect(applied[0]!.tokensBefore).toBeGreaterThan(applied[0]!.tokensAfter)
+    const receipts = reviewEvents(audit.records()).filter(entry => entry.event === 'apply-receipt')
+    expect(receipts).toHaveLength(1)
+    expect(receipts[0]!.proposalId).toBe(proposalId)
+    expect(receipts[0]!.receiptStatus).toBe('applied')
+    // The receipt numbers come from the executed mutation, not the estimate.
+    expect(receipts[0]!.tokensBefore).toBe(applied[0]!.tokensBefore)
+    expect(receipts[0]!.tokensAfter).toBe(applied[0]!.tokensAfter)
+    // Retired from the queue: a second apply must not re-execute.
+    expect(ctx.toolResultPruner.listReviewProposals(session)).toHaveLength(0)
+    const before = sessionEvents(session).length
+    ctx.toolResultPruner.applyApprovedProposals(session)
+    expect(sessionEvents(session)).toHaveLength(before)
+  })
+
+  it('voids a proposal whose content changed between approval and the apply point', async () => {
+    const ctx = await runtimeContext()
+    await reviewSetup(ctx, true)
+    const audit = captureAudit(ctx)
+    const { session, oldResultSeq } = reviewSession(ctx, 'review-void-tamper', 'old reviewable evidence '.repeat(600))
+    ctx.toolResultPruner.pruneSession(session, { stage: 'pressure' })
+    const proposalId = ctx.toolResultPruner.listReviewProposals(session)[0]!.id
+    // The user approved; a later step then rewrote the same surface content.
+    tamperResult(session, oldResultSeq, 'tampered by a later step')
+    expect(ctx.toolResultPruner.decideReviewProposal(session, proposalId, 'approved')).toEqual({ ok: true })
+
+    ctx.toolResultPruner.applyApprovedProposals(session)
+
+    // No deletion: the digest mismatch voided the whole proposal.
+    expect(rewrites(audit.records()).some(entry => entry.reducer === 'review-approved-whole-result')).toBe(false)
+    const voids = reviewEvents(audit.records()).filter(entry => entry.event === 'apply-void')
+    expect(voids).toHaveLength(1)
+    expect(voids[0]!.proposalId).toBe(proposalId)
+    expect(voids[0]!.reasonCode).toBe('review_receipt_digest_invalid')
+    // The tampered content is untouched on the surface.
+    const surface = sessionEvents(session).filter(entry => entry.type === 'tool/result')
+    const last = surface.at(-1)
+    if (last?.type !== 'tool/result') throw new Error('missing surface tool result')
+    expect(last.data.message.content[0].content[0]).toMatchObject({ text: 'tampered by a later step' })
+  })
+
+  it('expires stale pending proposals and never executes them afterwards', async () => {
+    const ctx = await runtimeContext()
+    await reviewSetup(ctx, true)
+    const audit = captureAudit(ctx)
+    const { session } = reviewSession(ctx, 'review-expiry', 'old reviewable evidence '.repeat(600))
+    ctx.toolResultPruner.pruneSession(session, { stage: 'pressure' })
+    const proposalId = ctx.toolResultPruner.listReviewProposals(session)[0]!.id
+
+    // Within the patience window the proposal survives.
+    expect(ctx.toolResultPruner.expireReviewProposals(session, 5)).toHaveLength(0)
+    expect(ctx.toolResultPruner.listReviewProposals(session)).toHaveLength(1)
+    // Past reviewTimeoutTurns (6) the pending proposal expires at the boundary.
+    const expired = ctx.toolResultPruner.expireReviewProposals(session, 8)
+    expect(expired.map(entry => entry.id)).toEqual([proposalId])
+    expect(reviewEvents(audit.records()).some(entry => entry.event === 'expire')).toBe(true)
+    expect(ctx.toolResultPruner.listReviewProposals(session)).toHaveLength(0)
+
+    // An expired proposal cannot be approved and never executes.
+    expect(ctx.toolResultPruner.decideReviewProposal(session, proposalId, 'approved'))
+      .toEqual({ ok: false, reason: 'unknown-proposal' })
+    ctx.toolResultPruner.applyApprovedProposals(session)
+    expect(rewrites(audit.records()).some(entry => entry.reducer === 'review-approved-whole-result')).toBe(false)
+  })
+
+  it('keeps the automatic path byte-identical when review mode is off', async () => {
+    const ctx = await runtimeContext()
+    await reviewSetup(ctx, false)
+    const audit = captureAudit(ctx)
+    const { session } = reviewSession(ctx, 'review-off-identity', 'old reviewable evidence '.repeat(600))
+
+    const result = ctx.toolResultPruner.pruneSession(session, { stage: 'pressure' })
+
+    // History aged exactly as before the review pipeline existed.
+    expect(result.pruned).toHaveLength(1)
+    expect(rewrites(audit.records()).some(entry => entry.component === 'history')).toBe(true)
+    expect(reviewEvents(audit.records())).toHaveLength(0)
+    expect(ctx.toolResultPruner.listReviewProposals(session)).toHaveLength(0)
+  })
+})

package/packages/selector/tests/runtime/tokenpilot/review-queue.spec.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it } from 'vitest'
+import {
+  MemoryReviewStore,
+  ReviewQueue,
+  type ReviewQueueStore,
+} from '../../../src/runtime/tokenpilot/review-queue.ts'
+import type { ProposalSkeleton } from '../../../src/runtime/tokenpilot/proposal.ts'
+
+const ITEM = {
+  seq: 7,
+  component: 'history',
+  kind: 'read-state',
+  tokensBefore: 1400,
+  tokensAfter: 1000,
+  digest: 'ab'.repeat(32),
+} as const
+
+function skeleton(overrides: Partial<ProposalSkeleton> = {}): ProposalSkeleton {
+  return {
+    id: overrides.id ?? 'proposal00001',
+    kind: overrides.kind ?? 'read-state',
+    items: overrides.items ?? [ITEM],
+    benefit: overrides.benefit ?? {
+      recoveredTokens: 400,
+      penaltyTokens: 900,
+      paybackTurns: 2.25,
+    },
+  }
+}
+
+/** Failing store: every seam failure degrades to memory, never throws. */
+
+function makeQueue(timeoutTurns = 6, store: ReviewQueueStore = new MemoryReviewStore()): ReviewQueue {
+  return new ReviewQueue(store, { timeoutTurns })
+}
+
+describe('review queue', () => {
+  it('moves a proposal through enqueue → pending → approved', () => {
+    const queue = makeQueue()
+    expect(queue.enqueue('s1', skeleton(), 3)).toBe(true)
+    expect(queue.listPending('s1')).toHaveLength(1)
+    expect(queue.listPending('s1')[0]!.items[0]!.digest).toBe(ITEM.digest)
+    expect(queue.decide('s1', 'proposal00001', 'approved')).toEqual({ ok: true })
+    expect(queue.listPending('s1')).toHaveLength(0)
+    expect(queue.listApproved('s1')).toHaveLength(1)
+  })
+
+  it('supports every decision and keeps sessions isolated', () => {
+    const queue = makeQueue()
+    queue.enqueue('s1', skeleton({ id: 'p-rejected000' }), 1)
+    queue.enqueue('s2', skeleton({ id: 'p-ignored0000' }), 1)
+    expect(queue.decide('s1', 'p-rejected000', 'rejected')).toEqual({ ok: true })
+    expect(queue.decide('s2', 'p-ignored0000', 'ignored')).toEqual({ ok: true })
+    expect(queue.listPending('s1')).toHaveLength(0)
+    expect(queue.listPending('s2')).toHaveLength(0)
+    expect(queue.listApproved('s1')).toHaveLength(0)
+  })
+
+  it('re-enqueue of identical content refreshes patience without duplicating', () => {
+    const queue = makeQueue()
+    expect(queue.enqueue('s1', skeleton(), 2)).toBe(true)
+    expect(queue.enqueue('s1', skeleton(), 5)).toBe(false)
+    const pending = queue.listPending('s1')
+    expect(pending).toHaveLength(1)
+    // Patience clock restarted at the re-enqueue turn.
+    expect(pending[0]!.lastTurnIndex).toBe(5)
+    expect(pending[0]!.enqueuedTurn).toBe(2)
+  })
+
+  it('decide is idempotent and reports unknown or already-decided ids', () => {
+    const queue = makeQueue()
+    queue.enqueue('s1', skeleton(), 1)
+    expect(queue.decide('s1', 'proposal00001', 'approved')).toEqual({ ok: true })
+    expect(queue.decide('s1', 'proposal00001', 'approved')).toEqual({ ok: false, reason: 'not-pending' })
+    expect(queue.decide('s1', 'missing-proposal', 'rejected')).toEqual({ ok: false, reason: 'unknown-proposal' })
+    expect(queue.listApproved('s1')).toHaveLength(1)
+  })
+
+  it('expires only pending proposals past the timeout window at the turn boundary', () => {
+    const queue = makeQueue(6)
+    queue.enqueue('s1', skeleton({ id: 'p-pending-old0' }), 1)
+    queue.enqueue('s1', skeleton({ id: 'p-pending-new0' }), 9)
+    queue.enqueue('s1', skeleton({ id: 'p-approved-00' }), 1)
+    queue.decide('s1', 'p-approved-00', 'approved')
+    // Turn 8: the turn-1 pending proposal is 7 turns stale (> 6) → expired;
+    // the approved one never expires and the turn-9 one is still fresh.
+    const expired = queue.expireTurn('s1', 8)
+    expect(expired.map(entry => entry.id)).toEqual(['p-pending-old0'])
+    expect(expired[0]!.status).toBe('expired')
+    expect(queue.listPending('s1').map(entry => entry.id)).toEqual(['p-pending-new0'])
+    expect(queue.listApproved('s1').map(entry => entry.id)).toEqual(['p-approved-00'])
+  })
+
+  it('keeps proposals exactly at the timeout boundary', () => {
+    const queue = makeQueue(6)
+    queue.enqueue('s1', skeleton(), 1)
+    // 6 - 1 = 5 ≤ 6 → still pending.
+    expect(queue.expireTurn('s1', 6)).toHaveLength(0)
+    expect(queue.listPending('s1')).toHaveLength(1)
+    // 7 - 1 = 6 ≤ 6 → still pending.
+    expect(queue.expireTurn('s1', 7)).toHaveLength(0)
+    // 8 - 1 = 7 > 6 → expired.
+    expect(queue.expireTurn('s1', 8)).toHaveLength(1)
+  })
+
+  it('retires approved proposals with their receipt exactly once', () => {
+    const queue = makeQueue()
+    queue.enqueue('s1', skeleton({ id: 'p-apply-me000' }), 1)
+    queue.decide('s1', 'p-apply-me000', 'approved')
+    const settled = queue.recordReceipt('s1', 'p-apply-me000', {
+      status: 'applied',
+      estimatedTokens: 400,
+      appliedTokens: 380,
+      updatedAt: '2026-09-18T00:00:00.000Z',
+    })
+    expect(settled).toBeDefined()
+    expect(settled!.receipt.appliedTokens).toBe(380)
+    expect(settled!.items).toHaveLength(1)
+    // Retired: a second receipt for the same id misses.
+    expect(queue.recordReceipt('s1', 'p-apply-me000', {
+      status: 'applied',
+      estimatedTokens: 400,
+      updatedAt: '2026-09-18T00:00:01.000Z',
+    })).toBeUndefined()
+    expect(queue.listApproved('s1')).toHaveLength(0)
+  })
+
+  it('refuses a receipt for a proposal that is not approved', () => {
+    const queue = makeQueue()
+    queue.enqueue('s1', skeleton(), 1)
+    expect(queue.recordReceipt('s1', 'proposal00001', {
+      status: 'applied',
+      estimatedTokens: 400,
+      updatedAt: '2026-09-18T00:00:00.000Z',
+    })).toBeUndefined()
+  })
+
+  it('never throws when the store seam fails (fail-open degrade)', () => {
+    // When the storageDomain seam is unavailable the wiring layer may hand the
+    // queue a store whose calls throw; the queue must degrade to no-durability
+    // behavior without ever breaking the compression pipeline.
+    const throwing: ReviewQueueStore = {
+      load: () => { throw new Error('seam unavailable') },
+      save: () => { throw new Error('seam unavailable') },
+    }
+    const queue = new ReviewQueue(throwing, { timeoutTurns: 6 })
+    expect(queue.enqueue('s1', skeleton(), 1)).toBe(true)
+    expect(queue.listPending('s1')).toEqual([])
+    expect(queue.expireTurn('s1', 3)).toEqual([])
+    expect(queue.decide('s1', 'proposal00001', 'approved')).toEqual({ ok: false, reason: 'unknown-proposal' })
+    expect(queue.recordReceipt('s1', 'proposal00001', {
+      status: 'deferred',
+      reasonCode: 'review_receipt_digest_invalid',
+      estimatedTokens: 400,
+      updatedAt: '2026-09-18T00:00:00.000Z',
+    })).toBeUndefined()
+  })
+
+  it('persists across calls through the store (memory store roundtrip)', () => {
+    const shared = new MemoryReviewStore()
+    const writer = makeQueue(6, shared)
+    const reader = makeQueue(6, shared)
+    writer.enqueue('s1', skeleton(), 1)
+    expect(reader.listPending('s1')).toHaveLength(1)
+    reader.decide('s1', 'proposal00001', 'approved')
+    expect(writer.listApproved('s1')).toHaveLength(1)
+  })
+})