dsh-context-compression-improved 0.5.1 → 0.5.3

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,

package/packages/selector/tests/settings-seat.client.spec.ts

@@ -3,12 +3,14 @@
  *
  * This spec locks WHERE the compression settings panel mounts: exactly ONE
  * seat — the standalone `settings.section` entry (设置 → 上下文压缩) — and
- * explicitly NOT the Plugins-section surfaces. History this pins against: the
- * 0.1.5 line first lost every entry (a lazy `ctx.get` of locale/settingsScope
- * raced the settings client and apply bailed), then showed the panel twice
- * (item card + tab on top of the standalone section). Both were fixed by the
- * declarative-inject + single-section shape below. When a future DSH line
- * moves the seat again, migrate src/client/index.ts AND this file together.
+ * explicitly NOT the Plugins-section surfaces, and NOT a `shell.overlay` float
+ * (the retired review panel's seat was removed with the gate). History this
+ * pins against: the 0.1.5 line first lost every entry (a lazy `ctx.get` of
+ * locale/settingsScope raced the settings client and apply bailed), then showed
+ * the panel twice (item card + tab on top of the standalone section). Both were
+ * fixed by the declarative-inject + single-section shape below. When a future
+ * DSH line moves the seat again, migrate src/client/index.ts AND this file
+ * together.
  */
 import { describe, expect, it, vi } from 'vitest'
 import type { Context as ClientContext } from '@deepseek-ai/cordis'
@@ -26,8 +28,15 @@ interface CapturedRegistration {
   readonly component: unknown
 }
 
-/** Drive apply against a stub host and capture every slot registration. */
-function collectRegistrations(): { declared: string[]; registrations: CapturedRegistration[] } {
+/**
+ * Drive apply against a stub host and capture every slot registration.
+ * @param options - `registerThrows` models an older host that does not declare
+ * the seat: the slot boundary rejects the registration, exactly the shape the
+ * 0.1.2-era hosts had.
+ */
+function collectRegistrations(
+  options: { readonly registerThrows?: boolean } = {},
+): { declared: string[]; registrations: CapturedRegistration[] } {
   const declared: string[] = []
   const registrations: CapturedRegistration[] = []
   const ctx = {
@@ -43,8 +52,9 @@ function collectRegistrations(): { declared: string[]; registrations: CapturedRe
         for (const step of steps) { void step }
         return () => {}
       },
-      register: (options: Record<string, unknown>, component: unknown) => {
-        registrations.push({ slot: String(options['name']), options, component })
+      register: (record: Record<string, unknown>, component: unknown) => {
+        if (options.registerThrows === true) throw new Error(`unknown slot ${String(record['name'])}`)
+        registrations.push({ slot: String(record['name']), options: record, component })
         return () => {}
       },
     },
@@ -58,12 +68,16 @@ describe('settings-seat contract (standalone settings.section only)', () => {
     expect(inject).toEqual(['slots', 'locale', 'settingsScope'])
   })
 
-  it('injects exactly the settings.section seat plus the shell.overlay float', () => {
+  it('injects exactly the settings.section seat and nothing else', () => {
     const { declared, registrations } = collectRegistrations()
-    expect(declared).toEqual(['settings.section', 'shell.overlay'])
-    expect(registrations).toHaveLength(2)
+    expect(declared).toEqual(['settings.section'])
+    expect(registrations).toHaveLength(1)
     expect(registrations[0]!.slot).toBe('settings.section')
-    expect(registrations[1]!.slot).toBe('shell.overlay')
+  })
+
+  it('no longer claims a shell.overlay float (the review panel it served is gone)', () => {
+    const { declared } = collectRegistrations()
+    expect(declared).not.toContain('shell.overlay')
   })
 
   it('pins the section identity (id/order/label/locale) and the panel component', () => {
@@ -84,4 +98,21 @@ describe('settings-seat contract (standalone settings.section only)', () => {
     expect(declared).not.toContain('settings.plugins.tab')
     expect(declared).not.toContain('settings.plugin.item')
   })
+
+  it('survives an older host that does not declare the seat, warning instead of crashing', () => {
+    // Cross-version tolerance: a host without this seat rejects the
+    // registration at the slot boundary. apply() must swallow that and warn —
+    // the historical failure mode was apply() bailing out, which silently took
+    // EVERY settings entry down with it.
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const { declared } = collectRegistrations({ registerThrows: true })
+      // It tried the seat (so the degradation is "loud", not a silent no-op)…
+      expect(declared).toEqual(['settings.section'])
+      // …and the rejection never escaped apply().
+      expect(warn).toHaveBeenCalled()
+    } finally {
+      warn.mockRestore()
+    }
+  })
 })