dsh-context-compression-improved 0.5.0 → 0.5.2

package/packages/selector/tests/runtime/advice-never-withholds.host.spec.ts

@@ -0,0 +1,232 @@
+/**
+ * The retired review gate's replacement, pinned at the host integration level.
+ *
+ * This spec exists to make the OLD failure impossible to reintroduce: with the
+ * exact settings that used to divert 100% of a fresh batch into the human-gated
+ * review queue (`reviewMode: true` + a `reviewHighImpactTokens` threshold far
+ * below the batch), the batch must LAND, and the benefit model must publish its
+ * opinion as a `reduction-advice` audit instead of withholding anything.
+ *
+ * "缩减不阻断自动处理": advice describes a landing, it never gates one.
+ */
+import { describe, expect, it, vi } from 'vitest'
+import { Context } from '@deepseek-ai/cordis'
+import {
+  ToolCallId as CallId,
+  createMessage,
+  createUserMessage,
+  createToolResultMessage,
+} from '@deepseek-ai/dsh-llm'
+import SessionStore, {
+  Session,
+  SessionId,
+  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 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 ReductionAdviceAuditRecord,
+} 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 adviceOf(records: readonly CompressionAuditRecord[]): ReductionAdviceAuditRecord[] {
+  return records.filter((record): record is ReductionAdviceAuditRecord => record.kind === 'reduction-advice')
+}
+
+const nsBrand = (value: string): SettingsNamespace => value as unknown as SettingsNamespace
+
+function appendToolTurn(session: Session, turn: number, text: string): void {
+  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 })
+  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: '{}' })
+  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 })
+}
+
+/**
+ * The settings that used to withhold everything: review mode ON with a
+ * high-impact threshold of 1 token. History pricing is kept production-like
+ * (64,000 protected tail tokens) so the batch is only landable through the
+ * fresh stage.
+ */
+async function gatedSettings(ctx: Context): Promise<void> {
+  await ctx.plugin(TestSettings).await()
+  await ctx.plugin(SelectorHost).await()
+  await ctx.settings.update(nsBrand(CONTEXT_COMPRESSION_SETTINGS_NAMESPACE), {
+    profile: 'tokenpilot-inspired',
+    presetOptions: { reviewMode: true, reviewHighImpactTokens: 1 },
+  })
+  await ctx.plugin(ToolResultPruner, {
+    profile: 'tokenpilot-inspired',
+    freshTriggerTokens: 200,
+    freshTargetTokens: 100,
+    aggregateTriggerTokens: 1_000_000,
+    aggregateTargetTokens: 900_000,
+    historyTriggerTokens: 400,
+    historyKeepRecentToolCalls: 0,
+    historyKeepRecentTokens: 64_000,
+    historyMinReclaimTokens: 1,
+  }).await()
+}
+
+function freshSession(ctx: Context, id: string, text: string): Session {
+  const session = Session.create(SessionId(id))
+  appendToolTurn(session, 1, text)
+  const total = measureForCompaction(ctx, session).totalTokens
+  session.append('request/context', {
+    provider: 'deepseek',
+    model: MODEL,
+    contextWindow: Math.floor(total / 0.6),
+  })
+  // Fresh landing publishes a surface replacement, which requires an open turn.
+  session.append('turn/start', { turn: 2 })
+  return session
+}
+
+/** ~36,400 characters. The shipped advice threshold is 4,000 tokens, and this
+ *  fixture is repetitive enough that the exact tokenizer packs it denser than
+ *  the conservative 4-chars-per-token estimate (an 18,200-character variant
+ *  measured under 4,000 tokens), so the volume is doubled to keep the
+ *  `high-impact` label deterministic. */
+const HIGH_IMPACT_TEXT = 'fresh reviewable evidence '.repeat(1_400)
+
+describe('advice never withholds (retired review gate)', () => {
+  it('lands the fresh batch the gate used to divert, and advises instead', async () => {
+    const ctx = await runtimeContext()
+    await gatedSettings(ctx)
+    const audit = captureAudit(ctx)
+    const session = freshSession(ctx, 'advice-lands', HIGH_IMPACT_TEXT)
+
+    const result = ctx.toolResultPruner.pruneSession(session, { stage: 'fresh', freshTurn: 1, freshStep: 1 })
+    const records = audit.records()
+
+    // 1. The reduction LANDED. Under the retired gate this was the assertion
+    //    that failed: the batch was withheld pending human approval.
+    expect(result.pruned).toHaveLength(1)
+    expect(rewrites(records).some(entry => entry.component === 'fresh')).toBe(true)
+
+    // 2. The benefit model still speaks — as advice about the landing.
+    const advice = adviceOf(records)
+    expect(advice).toHaveLength(1)
+    expect(advice[0]!.stage).toBe('fresh')
+    expect(advice[0]!.band).toBe('high-impact')
+    expect(advice[0]!.maxTokensBefore).toBeGreaterThanOrEqual(4_000)
+    expect(advice[0]!.recoveredTokens).toBeGreaterThan(0)
+    // The batch it describes is exactly the batch that landed.
+    const landedSeqs = rewrites(records).flatMap(entry => [...entry.sourceSeqs])
+    expect(advice[0]!.itemSeqs.every(seq => landedSeqs.includes(seq))).toBe(true)
+
+    // 3. Every advice record describes a landing, never a pending decision.
+    expect(advice.length).toBeLessThanOrEqual(rewrites(records).length)
+  })
+
+  it('keeps the automatic path identical when no legacy gate key is present', async () => {
+    const ctx = await runtimeContext()
+    await ctx.plugin(TestSettings).await()
+    await ctx.plugin(SelectorHost).await()
+    await ctx.settings.update(nsBrand(CONTEXT_COMPRESSION_SETTINGS_NAMESPACE), {
+      profile: 'tokenpilot-inspired',
+    })
+    await ctx.plugin(ToolResultPruner, {
+      profile: 'tokenpilot-inspired',
+      freshTriggerTokens: 200,
+      freshTargetTokens: 100,
+      aggregateTriggerTokens: 1_000_000,
+      aggregateTargetTokens: 900_000,
+      historyTriggerTokens: 400,
+      historyKeepRecentToolCalls: 0,
+      historyKeepRecentTokens: 64_000,
+      historyMinReclaimTokens: 1,
+    }).await()
+    const audit = captureAudit(ctx)
+    const session = freshSession(ctx, 'advice-default', HIGH_IMPACT_TEXT)
+
+    const result = ctx.toolResultPruner.pruneSession(session, { stage: 'fresh', freshTurn: 1, freshStep: 1 })
+    expect(result.pruned).toHaveLength(1)
+    expect(adviceOf(audit.records())).toHaveLength(1)
+  })
+})

package/packages/selector/tests/runtime/audit.spec.ts

@@ -170,18 +170,22 @@ describe('context-compression audit records', () => {
     }).not.toThrow()
   })
 
-  it('keeps review-outcome records free of proposal content', () => {
+  it('keeps reduction-advice records free of content, digests, and keys', () => {
     const record: CompressionAuditRecord = {
       schemaVersion: 1,
-      kind: 'review-outcome',
-      sessionId: 'review-session',
-      proposalId: 'a1b2c3d4e5f6',
-      proposalKind: 'read-state',
-      event: 'apply-receipt',
-      receiptStatus: 'applied',
+      kind: 'reduction-advice',
+      sessionId: 'advice-session',
+      profile: 'tokenpilot-inspired',
+      band: 'high-impact',
+      stage: 'fresh',
       itemSeqs: [7, 9],
-      tokensBefore: 1400,
-      tokensAfter: 1000,
+      pricedCandidates: 2,
+      maxTokensBefore: 9_200,
+      tokensBefore: 12_400,
+      tokensAfter: 3_100,
+      recoveredTokens: 9_300,
+      penaltyTokens: 0,
+      paybackTurns: 0,
       turnIndex: 12,
     }
 
@@ -195,23 +199,33 @@ describe('context-compression audit records', () => {
     expect(line).not.toContain('apiKey')
   })
 
-  it('carries reason codes on void and deferred review events', () => {
+  it('describes an advised batch without any gate vocabulary', () => {
+    // The band can be the model's worst opinion — `not-worth-it` — and the
+    // record still only DESCRIBES a batch that landed: the retired review
+    // gate's decision vocabulary cannot be expressed any more.
     const record: CompressionAuditRecord = {
       schemaVersion: 1,
-      kind: 'review-outcome',
-      sessionId: 'review-session',
-      proposalId: 'b2c3d4e5f6a1',
-      proposalKind: 'dedup',
-      event: 'apply-void',
-      reasonCode: 'review_receipt_digest_invalid',
+      kind: 'reduction-advice',
+      sessionId: 'advice-session',
+      profile: 'tokenpilot-inspired',
+      band: 'not-worth-it',
+      stage: 'history',
       itemSeqs: [3],
-      tokensBefore: 5000,
-      tokensAfter: 4000,
+      pricedCandidates: 1,
+      maxTokensBefore: 5_000,
+      tokensBefore: 5_000,
+      tokensAfter: 4_000,
+      recoveredTokens: 1_000,
+      penaltyTokens: 3_600,
+      paybackTurns: 36,
+      expectedSaving: 0,
     }
-    const parsed = JSON.parse(
-      formatCompressionAudit(record).slice(COMPRESSION_AUDIT_PREFIX.length),
-    ) as CompressionAuditRecord
+    const line = formatCompressionAudit(record)
+    const parsed = JSON.parse(line.slice(COMPRESSION_AUDIT_PREFIX.length)) as CompressionAuditRecord
     expect(parsed).toEqual(record)
+    for (const gone of ['proposalId', 'proposalKind', 'decision', 'receipt', '"event"', 'reasonCode']) {
+      expect(line).not.toContain(gone)
+    }
   })
 
   it('keeps advisor-outcome records free of prompts, keys, and content', () => {

package/packages/selector/tests/runtime/deprecated-preset-options.spec.ts

@@ -0,0 +1,96 @@
+/**
+ * Upgrade safety for the retired review gate's settings keys.
+ *
+ * The gate is gone, but its keys are PERSISTED: a live settings document still
+ * carries `reviewMode: false`, and both the runtime parser and the browser
+ * decoder reject unknown keys. Removing the keys from the accepted set would
+ * therefore make the plugin fail to load (runtime) or report the whole settings
+ * card as unreadable (client). This spec pins the accept-and-ignore contract in
+ * both directions, and pins that the keys never reach the resolved policy.
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  parsePresetOptionsSettings,
+  resolveConfig,
+  resolvePolicy,
+} from '../../src/runtime/config.ts'
+import { decodePresetOptionsSettings } from '../../src/profiles.ts'
+
+/** The exact legacy section a pre-0.5.2 install has on disk. */
+const LEGACY_SECTION = {
+  estimatorMode: 'host',
+  estimatorProvider: 'local-35b',
+  estimatorModel: 'Qwen3.6-35B-A3B',
+  estimatorBaseUrl: 'http://192.168.100.242:8200/v1',
+  reviewMode: false,
+}
+
+describe('retired review-gate keys are accepted and ignored (runtime)', () => {
+  it('parses the legacy section without throwing and keeps the live keys', () => {
+    const parsed = parsePresetOptionsSettings(LEGACY_SECTION)
+    expect(parsed).toEqual({
+      estimatorMode: 'host',
+      estimatorProvider: 'local-35b',
+      estimatorModel: 'Qwen3.6-35B-A3B',
+      estimatorBaseUrl: 'http://192.168.100.242:8200/v1',
+    })
+  })
+
+  it('drops every retired key, even with values the old schema rejected', () => {
+    // The retired keys are not validated any more — a stale invalid value in an
+    // existing document must not be able to break the load.
+    const parsed = parsePresetOptionsSettings({
+      reviewMode: 'yes',
+      reviewTimeoutTurns: -1,
+      cacheHitDiscountAlpha: 'wide',
+      reviewHighImpactTokens: null,
+    })
+    expect(parsed).toEqual({})
+  })
+
+  it('still rejects a genuinely unknown key', () => {
+    expect(() => parsePresetOptionsSettings({ reviewModes: true })).toThrow(/unknown key/)
+  })
+
+  it('never lets a retired key reach the resolved policy matrix', () => {
+    // The section arrives as `unknown` from the settings document, so the cast
+    // mirrors the production path rather than widening the config surface.
+    const policy = resolvePolicy(
+      resolveConfig({
+        presetOptions: { reviewMode: true, reviewHighImpactTokens: 1 },
+      } as unknown as Parameters<typeof resolveConfig>[0]),
+      'tokenpilot-inspired',
+    )
+    const matrix = policy.presetOptions
+    expect(matrix).toBeDefined()
+    for (const gone of ['reviewMode', 'reviewTimeoutTurns', 'cacheHitDiscountAlpha', 'reviewHighImpactTokens']) {
+      expect(Object.hasOwn(matrix as object, gone)).toBe(false)
+    }
+    // The surviving matrix is exactly the live capability set.
+    expect(Object.keys(matrix as object).sort()).toEqual([
+      'advisor', 'dedupeToolResults', 'estimator', 'noNetSavingsGuard',
+      'prefixStabilizer', 'readState', 'skipReductionRecovery', 'summaryLocator',
+    ])
+  })
+})
+
+describe('retired review-gate keys are accepted and ignored (client mirror)', () => {
+  it('decodes a legacy section instead of reporting the card unreadable', () => {
+    const decoded = decodePresetOptionsSettings(LEGACY_SECTION)
+    // `undefined` here would blank the settings card's presetOptions section.
+    expect(decoded).toEqual({
+      estimatorMode: 'host',
+      estimatorProvider: 'local-35b',
+      estimatorModel: 'Qwen3.6-35B-A3B',
+      estimatorBaseUrl: 'http://192.168.100.242:8200/v1',
+    })
+  })
+
+  it('tolerates legacy values the old decoder rejected', () => {
+    expect(decodePresetOptionsSettings({ reviewMode: 'yes', reviewHighImpactTokens: -5 })).toEqual({})
+  })
+
+  it('still refuses an unknown key', () => {
+    expect(decodePresetOptionsSettings({ reviewModes: true })).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,217 @@
+import { describe, expect, it } from 'vitest'
+import {
+  adviseCandidates,
+  computeBenefit,
+  DEFAULT_ADVICE_ALPHA,
+  DEFAULT_ADVICE_HIGH_IMPACT_TOKENS,
+} from '../../../src/runtime/tokenpilot/benefit.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)
+  })
+
+  it('waives the refill penalty for a refill-exempt batch: payback 0, saving α·R·Ŝ', () => {
+    // Fresh-stage shaping: the content never entered the KV cache, so no
+    // refill penalty applies — the whole discounted recovery is pure gain.
+    const result = computeBenefit(
+      [{ sourceSeq: 7, tokensBefore: 4000, tokensAfter: 400 }],
+      { alpha: 0.1, tailTokens: 4000, remainingTurns: 12, refillPenaltyExempt: true },
+    )
+    expect(result.recoveredTokens).toBe(3600)
+    expect(result.penaltyTokens).toBe(0)
+    expect(result.paybackTurns).toBe(0)
+    // α·R·max(0, Ŝ − 0) = 360·12
+    expect(result.expectedSaving).toBeCloseTo(4320)
+  })
+
+  it('keeps the refill penalty when the exemption flag is absent', () => {
+    const result = computeBenefit(
+      [{ sourceSeq: 7, tokensBefore: 4000, tokensAfter: 400 }],
+      { alpha: 0.1, tailTokens: 4000 },
+    )
+    expect(result.penaltyTokens).toBeCloseTo(3600)
+  })
+})
+
+/** The shipped advice defaults are part of the contract: the audit and the
+ *  report quote them, so a silent drift would change what the label means. */
+describe('advice defaults', () => {
+  it('pins the shipped α and high-impact threshold', () => {
+    expect(DEFAULT_ADVICE_ALPHA).toBe(0.1)
+    expect(DEFAULT_ADVICE_HIGH_IMPACT_TOKENS).toBe(4_000)
+  })
+})
+
+describe('adviseCandidates', () => {
+  // The shipped threshold is exercised by its own case; every other case lifts
+  // it out of the way so one band can be asserted at a time.
+  const base = {
+    alpha: 0.1,
+    tailTokens: 4000,
+    highImpactTokens: 1_000_000,
+  }
+
+  it('returns undefined when no candidate carries a positive recovery', () => {
+    expect(adviseCandidates([], base)).toBeUndefined()
+    expect(adviseCandidates([{ sourceSeq: 1, tokensBefore: 100, tokensAfter: 400 }], base)).toBeUndefined()
+  })
+
+  it('labels a fast-payback batch profitable', () => {
+    // R = 3600, penalty = 3600, α·R = 360 → payback 10 ≤ 0.25·Ŝ requires Ŝ ≥ 40.
+    const advice = adviseCandidates(
+      [{ sourceSeq: 7, tokensBefore: 4_000, tokensAfter: 400 }],
+      { ...base, remainingTurns: 60 },
+    )
+    expect(advice?.band).toBe('profitable')
+    expect(advice?.priced).toBe(1)
+    expect(advice?.maxTokensBefore).toBe(4_000)
+  })
+
+  it('labels an unpriceable batch when α prices no recovery', () => {
+    const advice = adviseCandidates(
+      [{ sourceSeq: 7, tokensBefore: 4_000, tokensAfter: 400 }],
+      { ...base, alpha: 0, remainingTurns: 12 },
+    )
+    expect(advice?.band).toBe('unpriceable')
+    expect(advice?.benefit.expectedSaving).toBeCloseTo(-4000)
+  })
+
+  it('lets one high-impact candidate label the whole batch, ahead of a good payback', () => {
+    // The 8k candidate alone reaches the shipped threshold; the small sibling
+    // would be profitable on its own. One label per batch, high impact wins.
+    const advice = adviseCandidates(
+      [
+        { sourceSeq: 1, tokensBefore: 200, tokensAfter: 100 },
+        { sourceSeq: 2, tokensBefore: 8_192, tokensAfter: 1_000 },
+      ],
+      { ...base, highImpactTokens: DEFAULT_ADVICE_HIGH_IMPACT_TOKENS, alpha: 1, remainingTurns: 60 },
+    )
+    expect(advice?.band).toBe('high-impact')
+    expect(advice?.maxTokensBefore).toBe(8_192)
+  })
+
+  it('labels a slowly paying batch slow-payback when Ŝ is known', () => {
+    // R = 12000 → penalty 3600, α·R = 1200 → payback 3. Ŝ = 11 keeps
+    // 0.25·Ŝ = 2.75 strictly below the payback, so the batch is not profitable.
+    const advice = adviseCandidates(
+      [{ sourceSeq: 7, tokensBefore: 12_000, tokensAfter: 0 }],
+      { ...base, remainingTurns: 11 },
+    )
+    expect(advice?.band).toBe('slow-payback')
+  })
+
+  it('labels a batch that never pays back not-worth-it, and still returns its benefit', () => {
+    const advice = adviseCandidates(
+      [{ sourceSeq: 7, tokensBefore: 4_000, tokensAfter: 400 }],
+      { ...base, remainingTurns: 2 },
+    )
+    expect(advice?.band).toBe('not-worth-it')
+    expect(advice?.benefit.recoveredTokens).toBe(3600)
+  })
+
+  it('never closes a band on Ŝ: an unknown remaining-turn count keeps the batch priceable', () => {
+    const advice = adviseCandidates(
+      [{ sourceSeq: 7, tokensBefore: 4_000, tokensAfter: 400 }],
+      base,
+    )
+    // payback 10 > 1 and Ŝ is unknown → the profit bands cannot be argued, so
+    // the batch is labelled as not worth the cache break rather than fabricated.
+    expect(advice?.band).toBe('not-worth-it')
+    expect(advice?.benefit.expectedSaving).toBeUndefined()
+  })
+
+  it('prices a fresh-stage batch without the refill penalty', () => {
+    const advice = adviseCandidates(
+      [{ sourceSeq: 7, tokensBefore: 4_000, tokensAfter: 400 }],
+      { ...base, highImpactTokens: 1_000_000, stage: 'fresh', remainingTurns: 12 },
+    )
+    expect(advice?.benefit.penaltyTokens).toBe(0)
+    expect(advice?.band).toBe('profitable')
+  })
+
+  it('counts only the positively-recovering candidates it priced', () => {
+    const advice = adviseCandidates(
+      [
+        { sourceSeq: 1, tokensBefore: 100, tokensAfter: 400 },
+        { sourceSeq: 2, tokensBefore: 4_000, tokensAfter: 400 },
+      ],
+      { ...base, remainingTurns: 60 },
+    )
+    expect(advice?.priced).toBe(1)
+    expect(advice?.maxTokensBefore).toBe(4_000)
+  })
+})

package/packages/selector/tests/runtime/tokenpilot/profile-baseline.spec.ts

@@ -61,15 +61,14 @@ describe('tokenpilot-inspired preset', () => {
       prefixStabilizer: true,
       readState: true,
       estimator: { mode: '' },
-      // Review pipeline (beta) ships off with its documented defaults.
-      reviewMode: false,
-      reviewTimeoutTurns: 6,
-      cacheHitDiscountAlpha: 0.1,
-      reviewHighImpactTokens: 4000,
       // Advisory advisor ships off with its documented defaults. The
       // resolved matrix intentionally gains this group so it follows the
       // estimator's resolved-consumption pattern; see
       // .agents/plans/ctx-relevance-advisor/spec.md decision record.
+      //
+      // The retired review gate's four keys are intentionally absent here:
+      // they are still ACCEPTED by the parser for upgrade safety but never
+      // reach the resolved policy (a reduction must not be gated).
       advisor: {
         mode: '',
         timeoutMs: 8000,