dsh-context-compression-improved 0.5.0 → 0.5.2

package/packages/selector/src/runtime/audit.ts

@@ -1,5 +1,6 @@
 /** Structured, content-free runtime audit records for context compression. */
 
+import type { AdviceBand } from './tokenpilot/benefit.ts'
 import type {
   CompressionPolicy,
   CompressionProfile,
@@ -204,29 +205,34 @@ export interface AdvisorOutcomeAuditRecord extends CompressionAuditBase {
   readonly latencyMs: number
 }
 
-/** Lifecycle of one human-gated review proposal. Only numeric and enum fields — never content. */
-export interface ReviewOutcomeAuditRecord extends CompressionAuditBase {
-  readonly kind: 'review-outcome'
-  /** Stable proposal id (sha-256 digest cut, 12 hex chars). */
-  readonly proposalId: string
-  /** Reduction kind the proposal came from. */
-  readonly proposalKind: 'estimator' | 'dedup' | 'read-state'
-  readonly event:
-    | 'enqueue'
-    | 'expire'
-    | 'decide'
-    | 'apply-void'
-    | 'apply-receipt'
-  /** Human decision (decide events only). */
-  readonly decision?: 'approved' | 'rejected' | 'ignored'
-  /** Execution receipt state (apply-receipt only). */
-  readonly receiptStatus?: 'applied' | 'deferred'
-  /** Aligned reason code (deferred receipts and void applications only). */
-  readonly reasonCode?: string
+/**
+ * One advisory benefit-model label for a batch that LANDED. The retired review
+ * gate used these bands to withhold a batch; a reduction must never block
+ * automatic processing, so the band is published as advice instead. Numeric and
+ * enum fields only — never content.
+ */
+export interface ReductionAdviceAuditRecord extends CompressionAuditBase {
+  readonly kind: 'reduction-advice'
+  /** Profile the advised pass ran under. */
+  readonly profile: CompressionProfile
+  /** Band the benefit model labelled the landed batch with. */
+  readonly band: AdviceBand
+  /** Landing stage the batch was priced at. */
+  readonly stage: 'fresh' | 'history'
   readonly itemSeqs: readonly number[]
+  /** Candidates that carried a positive recovery and were priced. */
+  readonly pricedCandidates: number
+  /** Largest single-candidate token mass in the batch. */
+  readonly maxTokensBefore: number
   readonly tokensBefore: number
   readonly tokensAfter: number
-  /** Turn index the event happened at. */
+  readonly recoveredTokens: number
+  readonly penaltyTokens: number
+  /** Turns of discounted recovery needed to recoup the refill penalty. */
+  readonly paybackTurns?: number
+  /** Discounted net benefit over the remaining session; omitted when Ŝ is unknown. */
+  readonly expectedSaving?: number
+  /** Turn index the batch landed at. */
   readonly turnIndex?: number
 }
 
@@ -241,7 +247,7 @@ export type CompressionAuditRecord =
   | SummaryLocatorAuditRecord
   | EstimatorOutcomeAuditRecord
   | AdvisorOutcomeAuditRecord
-  | ReviewOutcomeAuditRecord
+  | ReductionAdviceAuditRecord
 
 /** Minimal logger method consumed by the audit publisher. */
 export interface CompressionAuditLogger {

package/packages/selector/src/runtime/config.ts

@@ -127,6 +127,11 @@ export function parsePresetOptionsSettings(value: unknown): PresetOptionsSetting
   const allowed = new Set([
     'dedupeToolResults', 'summaryLocator', 'prefixStabilizer', 'readState', 'estimatorMode',
     'estimatorProvider', 'estimatorModel', 'estimatorBaseUrl', 'estimatorApiKey', 'estimatorTimeoutMs',
+    // Legacy keys of the retired human-gated review pipeline. They stay in the
+    // ACCEPTED set on purpose: the keys are persisted in existing settings
+    // documents, and rejecting them would make this plugin fail to load on an
+    // upgrade. They are read by nothing — the gate they configured no longer
+    // exists, and a reduction never blocks automatic processing.
     'reviewMode', 'reviewTimeoutTurns', 'cacheHitDiscountAlpha', 'reviewHighImpactTokens',
     'advisorMode', 'advisorTimeoutMs', 'advisorRefreshTurns', 'advisorScoreThreshold', 'advisorSampleLimit',
     'advisorMinTokens',
@@ -135,7 +140,7 @@ export function parsePresetOptionsSettings(value: unknown): PresetOptionsSetting
   if (unknown !== undefined) {
     throw new TypeError(`Context-compression presetOptions: unknown key "${unknown}"`)
   }
-  const booleans = ['dedupeToolResults', 'summaryLocator', 'prefixStabilizer', 'readState', 'reviewMode'] as const
+  const booleans = ['dedupeToolResults', 'summaryLocator', 'prefixStabilizer', 'readState'] as const
   for (const key of booleans) {
     const entry = value[key]
     if (entry !== undefined && typeof entry !== 'boolean') {
@@ -185,23 +190,6 @@ export function parsePresetOptionsSettings(value: unknown): PresetOptionsSetting
       || estimatorTimeoutMs < 100 || estimatorTimeoutMs > 60_000)) {
     throw new TypeError('Context-compression presetOptions.estimatorTimeoutMs must be an integer between 100 and 60000')
   }
-  const reviewTimeoutTurns = value.reviewTimeoutTurns
-  if (reviewTimeoutTurns !== undefined
-    && (typeof reviewTimeoutTurns !== 'number' || !Number.isSafeInteger(reviewTimeoutTurns) || reviewTimeoutTurns < 1)) {
-    throw new TypeError('Context-compression presetOptions.reviewTimeoutTurns must be an integer of at least 1')
-  }
-  const cacheHitDiscountAlpha = value.cacheHitDiscountAlpha
-  if (cacheHitDiscountAlpha !== undefined
-    && (typeof cacheHitDiscountAlpha !== 'number' || !Number.isFinite(cacheHitDiscountAlpha)
-      || cacheHitDiscountAlpha <= 0 || cacheHitDiscountAlpha >= 1)) {
-    throw new TypeError('Context-compression presetOptions.cacheHitDiscountAlpha must be a number strictly between 0 and 1')
-  }
-  const reviewHighImpactTokens = value.reviewHighImpactTokens
-  if (reviewHighImpactTokens !== undefined
-    && (typeof reviewHighImpactTokens !== 'number' || !Number.isSafeInteger(reviewHighImpactTokens)
-      || reviewHighImpactTokens < 0)) {
-    throw new TypeError('Context-compression presetOptions.reviewHighImpactTokens must be a non-negative integer')
-  }
   for (const key of ['estimatorProvider', 'estimatorModel', 'estimatorBaseUrl', 'estimatorApiKey'] as const) {
     const entry = value[key]
     if (entry !== undefined && typeof entry !== 'string') {
@@ -221,10 +209,6 @@ export function parsePresetOptionsSettings(value: unknown): PresetOptionsSetting
   if (value.estimatorBaseUrl !== undefined) result.estimatorBaseUrl = value.estimatorBaseUrl as string
   if (value.estimatorApiKey !== undefined) result.estimatorApiKey = value.estimatorApiKey as string
   if (estimatorTimeoutMs !== undefined) result.estimatorTimeoutMs = estimatorTimeoutMs as number
-  if (value.reviewMode !== undefined) result.reviewMode = value.reviewMode as boolean
-  if (reviewTimeoutTurns !== undefined) result.reviewTimeoutTurns = reviewTimeoutTurns as number
-  if (cacheHitDiscountAlpha !== undefined) result.cacheHitDiscountAlpha = cacheHitDiscountAlpha as number
-  if (reviewHighImpactTokens !== undefined) result.reviewHighImpactTokens = reviewHighImpactTokens as number
   if (advisorMode !== undefined) result.advisorMode = advisorMode as '' | 'host' | 'direct'
   if (advisorTimeoutMs !== undefined) result.advisorTimeoutMs = advisorTimeoutMs as number
   if (advisorRefreshTurns !== undefined) result.advisorRefreshTurns = advisorRefreshTurns as number
@@ -498,12 +482,6 @@ const PRESET_OPTION_DEFAULTS: PresetOptions = deepFreeze({
   prefixStabilizer: true,
   readState: true,
   estimator: { mode: '' },
-  // Review pipeline (beta) ships off: pending proposals never block the
-  // automatic path until the user opts in.
-  reviewMode: false,
-  reviewTimeoutTurns: 6,
-  cacheHitDiscountAlpha: 0.1,
-  reviewHighImpactTokens: 4000,
   // Advisory advisor ships off: statistics and suggestions only, never a gate.
   advisor: {
     mode: '',
@@ -530,10 +508,6 @@ function mergePresetOptions(overrides: PresetOptionsSettings | undefined): Prese
     prefixStabilizer: overrides.prefixStabilizer ?? PRESET_OPTION_DEFAULTS.prefixStabilizer,
     readState: overrides.readState ?? PRESET_OPTION_DEFAULTS.readState,
     estimator: { mode: overrides.estimatorMode ?? PRESET_OPTION_DEFAULTS.estimator.mode },
-    reviewMode: overrides.reviewMode ?? PRESET_OPTION_DEFAULTS.reviewMode,
-    reviewTimeoutTurns: overrides.reviewTimeoutTurns ?? PRESET_OPTION_DEFAULTS.reviewTimeoutTurns,
-    cacheHitDiscountAlpha: overrides.cacheHitDiscountAlpha ?? PRESET_OPTION_DEFAULTS.cacheHitDiscountAlpha,
-    reviewHighImpactTokens: overrides.reviewHighImpactTokens ?? PRESET_OPTION_DEFAULTS.reviewHighImpactTokens,
     advisor: {
       mode: overrides.advisorMode ?? PRESET_OPTION_DEFAULTS.advisor.mode,
       timeoutMs: overrides.advisorTimeoutMs ?? PRESET_OPTION_DEFAULTS.advisor.timeoutMs,

package/packages/selector/src/runtime/tokenpilot/advisor-state.ts

@@ -13,6 +13,19 @@
  * plain import rather than constructor injection.
  */
 import type { Session } from '@deepseek-ai/dsh-session'
+import type { AdviceBand } from './benefit.ts'
+
+/** The most recent benefit-model label of a landed batch. Observational only:
+ *  no decision path reads it — the report route serves it verbatim. */
+export interface AdvisorAdviceSnapshot {
+  readonly band: AdviceBand
+  /** Turn index the advised batch landed at. */
+  readonly turn: number
+  readonly itemSeqs: readonly number[]
+  readonly recoveredTokens: number
+  readonly penaltyTokens: number
+  readonly paybackTurns?: number
+}
 
 /** One relevance score for one surface seq, with the turn it was scored at. */
 export interface AdvisorScoreEntry {
@@ -59,6 +72,8 @@ export interface AdvisorState {
   inFlight: boolean
   /** Most recent decay computation, shared verbatim by audits and the report route. */
   lastDecay: { readonly decay: number, readonly weightedChars: number, readonly turn: number } | undefined
+  /** Most recent benefit-model advice; replaced by every advised batch. */
+  lastAdvice: AdvisorAdviceSnapshot | undefined
 }
 
 /** Upper bound of the per-session scores LRU. */
@@ -85,6 +100,7 @@ export function getAdvisorState(session: Session): AdvisorState {
       failures: undefined,
       inFlight: false,
       lastDecay: undefined,
+      lastAdvice: undefined,
     }
     advisorStates.set(session, state)
   }

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

@@ -0,0 +1,200 @@
+/**
+ * TokenPilot-inspired benefit model — **advisory only**.
+ *
+ * This module prices one pass's planned replacements as ONE merged mutation and
+ * labels the batch with the band the model would have chosen. The label is
+ * ADVICE: nothing here suppresses, delays, or rewrites a reduction. The former
+ * human-gated review pipeline consumed these bands to withhold the batch from
+ * landing; that gate was retired because a reduction must never block automatic
+ * processing. The bands now feed the `reduction-advice` audit and the advisor
+ * report, and every planned replacement that the rule engine produced lands.
+ *
+ * Cache accounting (TokenPilot paper): 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. Without that exemption every realistic fresh batch
+ * prices into the `not-worth-it` band, which makes the advice useless exactly
+ * where it is most often consulted.
+ *
+ * `expectedSaving` is only produced when Ŝ is known (the estimator answered
+ * with `expectedRemainingTurns`); it is never fabricated from a guess.
+ *
+ * Pure functions only: the classifier needs no I/O, no session state, and no
+ * host services, so every label is unit-testable and audit-replayable.
+ */
+
+/** 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
+}
+
+/**
+ * The band one priced batch falls into. Advisory vocabulary only — every band
+ * lands; the label says what the model thought of the landing, not whether it
+ * was allowed to happen.
+ */
+export type AdviceBand =
+  /** Payback ≤ 1 turn, or ≤ a quarter of the estimated remaining turns. */
+  | 'profitable'
+  /** At least one candidate reaches the high-impact threshold: the batch is
+   *  large enough that a human would want to know it moved. */
+  | 'high-impact'
+  /** Ŝ known and payback ∈ (1, 3]: it does pay back, but slowly. */
+  | 'slow-payback'
+  /** α·R ≤ 0: the accounting has no discounted recovery to argue from. */
+  | 'unpriceable'
+  /** Ŝ known and payback > 3 turns: the model would not have spent the cache break. */
+  | 'not-worth-it'
+
+export interface AdviceInput {
+  /** 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 are labelled `high-impact`. */
+  readonly highImpactTokens: number
+  /** Estimated remaining turns Ŝ; `undefined` closes the slow-payback band. */
+  readonly remainingTurns?: 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
+}
+
+export interface AdviceResult {
+  readonly band: AdviceBand
+  /** The full benefit estimate the band was derived from. */
+  readonly benefit: BenefitEstimate
+  /** Number of candidates that carried a positive recovery and were priced. */
+  readonly priced: number
+  /** Largest single-candidate token mass in the batch (the high-impact evidence). */
+  readonly maxTokensBefore: number
+}
+
+/**
+ * Shipped defaults of the advisory model. They are constants rather than
+ * settings keys because the machine no longer acts on them: after the review
+ * gate was retired these numbers only shape a label, so exposing them as
+ * tunable configuration would advertise a control that changes no behavior.
+ */
+export const DEFAULT_ADVICE_ALPHA = 0.1
+export const DEFAULT_ADVICE_HIGH_IMPACT_TOKENS = 4_000
+
+/**
+ * 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),
+  }
+}
+
+/**
+ * Label one batch of planned replacements.
+ *
+ * Pipeline: zero/negative-recovery candidates are priced out first (they never
+ * make a batch look better), the surviving batch is priced once through
+ * `computeBenefit`, and the band is a batch decision — the refill penalty is a
+ * property of the landing event, not of any single candidate, so pricing per
+ * candidate would overstate payback N-fold.
+ *
+ * Band precedence (identical thresholds to the retired triage model):
+ * - α too small to price a payback → `unpriceable`;
+ * - any candidate at `highImpactTokens` → `high-impact`;
+ * - `paybackTurns ≤ 1`, or Ŝ known and `paybackTurns ≤ 0.25·Ŝ` → `profitable`;
+ * - Ŝ known and `paybackTurns ∈ (1, 3]` → `slow-payback`;
+ * - everything else → `not-worth-it`.
+ *
+ * @param candidates - planned replacements of one pass, in any order.
+ * @param input - pricing inputs and the stage of the batch.
+ * @returns the advice, or `undefined` when nothing carried a positive recovery.
+ */
+export function adviseCandidates(
+  candidates: readonly BenefitCandidate[],
+  input: AdviceInput,
+): AdviceResult | undefined {
+  const usable: BenefitCandidate[] = []
+  for (const candidate of candidates) {
+    if (Math.max(0, candidate.tokensBefore - candidate.tokensAfter) <= 0) continue
+    usable.push(candidate)
+  }
+  if (usable.length === 0) return undefined
+
+  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 maxTokensBefore = usable.reduce((max, candidate) => Math.max(max, candidate.tokensBefore), 0)
+  const band: AdviceBand = payback === undefined
+    ? 'unpriceable'
+    : maxTokensBefore >= input.highImpactTokens
+      ? 'high-impact'
+      : payback <= 1
+        || (input.remainingTurns !== undefined && payback <= 0.25 * input.remainingTurns)
+        ? 'profitable'
+        : input.remainingTurns !== undefined && payback <= 3
+          ? 'slow-payback'
+          : 'not-worth-it'
+  return { band, benefit, priced: usable.length, maxTokensBefore }
+}

package/packages/selector/src/runtime/types.ts

@@ -85,18 +85,6 @@ export interface PresetOptions {
     readonly sampleLimit: number
     readonly minTokens: number
   }
-  /**
-   * Human-gated review pipeline (beta): edge/high-impact candidates queue for
-   * manual approval and execute in one merged batch at the next turn boundary
-   * instead of the automatic path (R4).
-   */
-  readonly reviewMode: boolean
-  /** Turn-boundary patience: pending review proposals older than this many turns auto-expire (R4). */
-  readonly reviewTimeoutTurns: number
-  /** Cache-hit discount rate α in the benefit model; expectedSaving = α·R·Ŝ − (1−α)·tail. */
-  readonly cacheHitDiscountAlpha: number
-  /** Candidates whose tokenBefore reaches this threshold bypass payback triage and always enter review (R4). */
-  readonly reviewHighImpactTokens: number
 }
 
 /** Common user-authored Custom stages shared by persisted policy versions. */
@@ -154,11 +142,6 @@ export interface PresetOptionsSettings {
   readonly prefixStabilizer?: boolean
   readonly readState?: boolean
   readonly estimatorMode?: '' | 'host' | 'direct'
-  /** Review-mode overrides (beta); see PresetOptions.reviewMode. */
-  readonly reviewMode?: boolean
-  readonly reviewTimeoutTurns?: number
-  readonly cacheHitDiscountAlpha?: number
-  readonly reviewHighImpactTokens?: number
   /**
    * Estimator endpoint fields. Persisted-settings only: they never enter the
    * frozen CompressionPolicy, which is emitted verbatim by policy-resolved

package/packages/selector/tests/built/client-artifact.spec.ts

@@ -34,11 +34,15 @@ describe('built Harness client artifact', () => {
     }) as { apply?: unknown, inject?: unknown }
 
     expect(exported.apply).toBeTypeOf('function')
-    // 0.1.5 declares only the always-present `slots` service: `locale` and
-    // `settingsScope` are resolved lazily inside apply, because a declarative
-    // inject of an absent or late service suspends apply forever and the whole
-    // UI disappears without a trace.
-    expect(exported.inject).toEqual(['slots'])
+    // Declare every consumed service: cordis holds apply until each one is
+    // provided, which is the official client-plugin pattern on this 0.1.5 host
+    // line (dsh-thinking-levels does the same). The earlier lazy alternative —
+    // resolving `locale` / `settingsScope` through ctx.get() inside apply —
+    // raced the settings client's activation; on a loss the apply
+    // early-returned and EVERY settings entry (the standalone section, the
+    // plugins-tab card, the item card) silently vanished. See the rationale
+    // recorded in src/client/index.ts.
+    expect(exported.inject).toEqual(['slots', 'locale', 'settingsScope'])
     const style = document.querySelector<HTMLStyleElement>(
       'style[data-plugin-css="dsh-context-compression-improved/CompressionProfileSelector.module.css"]',
     )

package/packages/selector/tests/preset-options-write.client.spec.ts

@@ -148,35 +148,19 @@ describe('presetOptions writes are path-addressed', () => {
     expect(writes).toEqual([[{ op: 'set', path: ['presetOptions', 'estimatorProvider'], value: 'local-35b' }]])
   })
 
-  it('writes and clears the review-mode fields without touching estimator siblings', async () => {
+  it('treats a retired review-gate patch as a no-op instead of a write', async () => {
     const { injected, writes, snapshot } = bindInjected({ estimatorMode: 'host' })
+    // The patch surface no longer carries these keys, and the decoders accept
+    // them only so a legacy document keeps loading. Cast past the removed type
+    // so the test pins the RUNTIME behaviour: nothing is written.
     await injected.savePresetOptions({
       reviewMode: true,
       reviewTimeoutTurns: 8,
       cacheHitDiscountAlpha: 0.2,
       reviewHighImpactTokens: 6000,
-    })
-    expect(snapshot()['presetOptions']).toEqual({
-      estimatorMode: 'host',
-      reviewMode: true,
-      reviewTimeoutTurns: 8,
-      cacheHitDiscountAlpha: 0.2,
-      reviewHighImpactTokens: 6000,
-    })
-    await injected.savePresetOptions({ reviewMode: undefined })
-    expect(snapshot()['presetOptions']).toEqual({
-      estimatorMode: 'host',
-      reviewTimeoutTurns: 8,
-      cacheHitDiscountAlpha: 0.2,
-      reviewHighImpactTokens: 6000,
-    })
-    for (const batch of writes) {
-      for (const op of batch) {
-        expect(op.path).toEqual(['presetOptions', op.path[1] ?? ''])
-        expect(['reviewMode', 'reviewTimeoutTurns', 'cacheHitDiscountAlpha', 'reviewHighImpactTokens'])
-          .toContain(op.path[1])
-      }
-    }
+    } as unknown as Parameters<typeof injected.savePresetOptions>[0])
+    expect(writes).toEqual([])
+    expect(snapshot()['presetOptions']).toEqual({ estimatorMode: 'host' })
   })
 
   it('never replaces the whole section, so sibling overrides survive', async () => {