dsh-context-compression-improved 0.1.1 → 0.2.0

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

@@ -0,0 +1,309 @@
+import type { CallId } from '@deepseek-ai/dsh-llm'
+
+/** User-facing mixed strategy profile. */
+export const COMPRESSION_PROFILES = [
+  'off',
+  'native',
+  'balanced',
+  'cache-strict',
+  'savings',
+  'adaptive',
+  'tokenpilot-inspired',
+  'custom',
+] as const
+
+/** Public compression strategy selected for one Session. */
+export type CompressionProfile = typeof COMPRESSION_PROFILES[number]
+
+/** When historical tool results may be aged for one Session policy. */
+export type HistoryMode = 'disabled' | 'routine' | 'capacity-pressure' | 'adaptive'
+
+/** Canonical unit stored by one versioned Custom policy. */
+export type CustomCompressionUnit = 'tokens' | 'context-percent'
+
+/** Whether routine History may rewrite a previously sent Harness prefix. */
+export type CustomPrefixPolicy = 'preserve' | 'pressure-break'
+
+/** One independently selectable Custom Fresh or Aggregate stage. */
+export interface CustomCompressionBudget {
+  enabled: boolean
+  trigger: number
+  target: number
+}
+
+/** Legacy Custom History gate and turn/token working-set protection. */
+export interface LegacyCustomHistoryPolicy {
+  enabled: boolean
+  trigger: number
+  keepRecentTurns: number
+  keepRecent: number
+  minReclaim: number
+}
+
+/** Custom History gate and recent tool-call/token working-set protection. */
+export interface CustomHistoryPolicy {
+  enabled: boolean
+  trigger: number
+  keepRecentToolCalls: number
+  keepRecentTokens: number
+  minReclaim: number
+}
+
+/** Custom-only experimental TailTrim gate. */
+export interface CustomTailTrimPolicy {
+  enabled: boolean
+  trigger: number
+}
+
+/** TokenPilot-inspired preset sub-capability switches (only injected for `tokenpilot-inspired`). */
+export interface PresetOptions {
+  /** Reject replacements whose text is not smaller than the original (G1). */
+  readonly noNetSavingsGuard: boolean
+  /** Permanently exempt recovery content from further reduction (G2). */
+  readonly skipReductionRecovery: boolean
+  /** Replace byte-identical repeated tool results with first-occurrence pointers (A1). */
+  readonly dedupeToolResults: boolean
+  /** Append Exact Sources locator blocks after Auto Compact completes (A2). */
+  readonly summaryLocator: boolean
+  /** Volatile-line demotion, deterministic tool ordering, and prefix fingerprint audit (S1/S2). */
+  readonly prefixStabilizer: boolean
+  /** Fresh/superseded read-state classification with clustered omission markers (R2/R3). */
+  readonly readState: boolean
+  /** Optional estimator channel; `''` keeps every estimator consumer on rule-only fallbacks (E1/E2). */
+  readonly estimator: { readonly mode: '' | 'host' | 'direct' }
+}
+
+/** Common user-authored Custom stages shared by persisted policy versions. */
+interface CustomCompressionPolicyFields<HistoryPolicy> {
+  unit: CustomCompressionUnit
+  fresh: CustomCompressionBudget
+  aggregate: CustomCompressionBudget
+  history: HistoryPolicy
+  prefixPolicy: CustomPrefixPolicy
+}
+
+/** Legacy R4 Custom policy, accepted without migration. */
+export interface CustomCompressionPolicyV1 extends CustomCompressionPolicyFields<LegacyCustomHistoryPolicy> {
+  version: 1
+}
+
+/** R5 Custom policy with an explicit default-off TailTrim stage. */
+export interface CustomCompressionPolicyV2 extends CustomCompressionPolicyFields<LegacyCustomHistoryPolicy> {
+  version: 2
+  tailTrim: CustomTailTrimPolicy
+}
+
+/** Custom policy with tool-call working-set protection. */
+export interface CustomCompressionPolicyV3 extends CustomCompressionPolicyFields<CustomHistoryPolicy> {
+  version: 3
+  tailTrim: CustomTailTrimPolicy
+}
+
+/** Strict persisted Custom policy union. */
+export type CustomCompressionPolicy = CustomCompressionPolicyV1 | CustomCompressionPolicyV2 | CustomCompressionPolicyV3
+
+/** User-tunable Auto Compact coordination preferences. */
+export interface AutoCompactSettings {
+  /** Routed-context percentage that triggers model-driven Auto Compact. */
+  thresholdPercent: number
+}
+
+/**
+ * Orthogonal evidence-based code-skeleton reducer gate. Independent of every
+ * profile: when enabled, fresh oversized source-code results may take the
+ * `hypa-code-skeleton` reducer before the head/tail fallbacks.
+ */
+export interface CodeSkeletonSettings {
+  enabled: boolean
+}
+
+/**
+ * Persisted sub-capability overrides for the `tokenpilot-inspired` preset.
+ * Absent fields inherit the preset defaults; the section is only meaningful
+ * while the resolved profile is `tokenpilot-inspired`.
+ */
+export interface PresetOptionsSettings {
+  readonly dedupeToolResults?: boolean
+  readonly summaryLocator?: boolean
+  readonly prefixStabilizer?: boolean
+  readonly readState?: boolean
+  readonly estimatorMode?: '' | 'host' | 'direct'
+  /**
+   * Estimator endpoint fields. Persisted-settings only: they never enter the
+   * frozen CompressionPolicy, which is emitted verbatim by policy-resolved
+   * audits, so the API key cannot leak into logs.
+   */
+  readonly estimatorProvider?: string
+  readonly estimatorModel?: string
+  readonly estimatorBaseUrl?: string
+  readonly estimatorApiKey?: string
+  readonly estimatorTimeoutMs?: number
+}
+
+/** Durable global preference exposed through `ctx.settings`. */
+export interface ContextCompressionSettings {
+  /** Default strategy snapped when a Session first reaches the pruner. */
+  profile: CompressionProfile
+  /** Versioned Custom policy snapped with `profile` for a newly observed Session. */
+  custom: CustomCompressionPolicy
+  /** Auto Compact trigger preference snapped with `profile` for a newly observed Session. */
+  autoCompact: AutoCompactSettings
+  /** Code-skeleton reducer gate snapped independently of `profile`. */
+  codeSkeleton: CodeSkeletonSettings
+  /** Optional tokenpilot-inspired sub-capability overrides; absent inherits preset defaults. */
+  presetOptions?: PresetOptionsSettings
+}
+
+/** Token-gated policy with character fields limited to reducer candidate shape. */
+export interface ToolResultPruneConfig {
+  /** Composition fallback when Host settings are unavailable. Defaults to `balanced`. */
+  profile?: CompressionProfile
+  /** Native fallback leading Unicode code points. Defaults to `4096`. */
+  headChars?: number
+  /** Native fallback trailing Unicode code points. Defaults to `1024`. */
+  tailChars?: number
+  /** Native original-content token trigger. Profile default when omitted. */
+  nativeTriggerTokens?: number
+  /** Native replacement token target. Profile default when omitted. */
+  nativeTargetTokens?: number
+  /** Fresh-result exact-token trigger. Profile default when omitted. */
+  freshTriggerTokens?: number
+  /** Maximum fresh-result exact-token replacement size. Profile default when omitted. */
+  freshTargetTokens?: number
+  /** Combined completed-step token pressure that starts aggregate reduction. */
+  aggregateTriggerTokens?: number
+  /** Aggregate token target after completed-step pressure exceeds its trigger. */
+  aggregateTargetTokens?: number
+  /** Total live tool-result tokens that permit historical aging. Profile default when omitted. */
+  historyTriggerTokens?: number
+  /** Recent completed agent tool calls protected from historical aging. Profile default when omitted. */
+  historyKeepRecentToolCalls?: number
+  /** Recent tool-result token tail protected in addition to tool calls. Profile default when omitted. */
+  historyKeepRecentTokens?: number
+  /** Minimum reclaim required before historical aging is worth a cache break. Profile default when omitted. */
+  historyMinReclaimTokens?: number
+  /**
+   * Auto Compact threshold percent frozen into this deployment by the preset
+   * overlay generation (50–90 integer). When present it supersedes the live
+   * Host setting so one generation never splits Auto Compact and micro
+   * compact across two thresholds.
+   */
+  autoCompactThresholdPercent?: number
+  /** Optional tokenpilot-inspired sub-capability overrides (deploy-level). */
+  presetOptions?: PresetOptionsSettings
+}
+
+/** Resolved per-profile behavior. */
+export interface CompressionPolicy {
+  readonly profile: CompressionProfile
+  /** Whether this Session may use the selector's native-style head/middle/tail reducer. */
+  readonly nativeToolResultEnabled: boolean
+  readonly freshEnabled: boolean
+  readonly aggregateEnabled: boolean
+  readonly historyMode: HistoryMode
+  readonly nativeTriggerTokens: number
+  readonly nativeTargetTokens: number
+  readonly freshTriggerTokens: number
+  readonly freshTargetTokens: number
+  readonly aggregateTriggerTokens: number
+  readonly aggregateTargetTokens: number
+  readonly historyTriggerTokens: number
+  readonly historyKeepRecentToolCalls: number
+  readonly historyKeepRecentTokens: number
+  readonly historyMinReclaimTokens: number
+  /**
+   * Auto Compact token watermark `A = floor(C × a)` when the standard-profile
+   * History linkage resolved for this Session; absent for Custom, Off, Native,
+   * or unresolved routed capacity.
+   */
+  readonly autoCompactTokens?: number
+  /**
+   * Micro-compact last-chance watermark `D = floor(A × 0.875)`. Absent when
+   * {@link autoCompactTokens} is absent; capacity-pressure gates fall back to
+   * the fixed 0.7 routed-context ratio in that case.
+   */
+  readonly microDeadlineTokens?: number
+  /** Present for Custom v3; standard profiles and legacy Custom policies carry no TailTrim policy. */
+  readonly tailTrim?: {
+    readonly enabled: boolean
+    readonly triggerTokens: number
+  }
+  /**
+   * TokenPilot-inspired sub-capability switches. Present only for the
+   * `tokenpilot-inspired` preset; every other profile stays byte-identical.
+   */
+  readonly presetOptions?: PresetOptions
+}
+
+/** Validated, detached, deeply immutable configuration. */
+export interface ResolvedConfig {
+  readonly profile: CompressionProfile
+  readonly headChars: number
+  readonly tailChars: number
+  readonly nativeTriggerTokens?: number
+  readonly nativeTargetTokens?: number
+  readonly freshTriggerTokens?: number
+  readonly freshTargetTokens?: number
+  readonly aggregateTriggerTokens?: number
+  readonly aggregateTargetTokens?: number
+  readonly historyTriggerTokens?: number
+  readonly historyKeepRecentToolCalls?: number
+  readonly historyKeepRecentTokens?: number
+  readonly historyMinReclaimTokens?: number
+  /**
+   * Auto Compact threshold percent frozen into this deployment by the preset
+   * overlay generation (50-90 integer). Supersedes the live Host setting.
+   */
+  readonly autoCompactThresholdPercent?: number
+  /** Optional tokenpilot-inspired sub-capability overrides resolved from the deployment config. */
+  readonly presetOptions?: PresetOptionsSettings
+}
+
+/** Why a pruning pass runs. */
+export type PruneStage = 'fresh' | 'pressure'
+
+/** Optional control over one pruning pass. */
+export interface PruneSessionOptions {
+  /** `fresh` only reduces never-before-seen oversized results; `pressure` may age older results too. */
+  stage?: PruneStage
+  /** Routed model context capacity used only to resolve a context-percent Custom snapshot. */
+  contextWindowTokens?: number
+  /** Proposed turn at the pre-step boundary. Used with `freshStep` to freeze keep/reduce decisions. */
+  freshTurn?: number
+  /** The immediately preceding completed step whose tool results have not yet entered a model request. */
+  freshStep?: number
+}
+
+/** Cited source event and size accounting for one landed surface replacement. */
+export interface PrunedEntry {
+  /** Current surface event shadowed by this replacement. */
+  readonly originalSeq: number
+  /** Root full-fidelity source event used in the recovery reference. */
+  readonly sourceSeq: number
+  /** Newly appended compressed tool-result event. */
+  readonly replacementSeq: number
+  /** Tool call shared by the original and replacement. */
+  readonly callId: CallId
+  /** Reducer or aging strategy that produced the replacement. */
+  readonly reducer: string
+  /** Pass stage that landed the replacement. */
+  readonly stage: PruneStage
+  /** Original deterministic pressure cost. */
+  readonly charsBefore: number
+  /** Replacement deterministic pressure cost. */
+  readonly charsAfter: number
+  /** Authoritative exact canonical content tokens before replacement. */
+  readonly tokensBefore: number
+  /** Authoritative exact canonical content tokens after replacement. */
+  readonly tokensAfter: number
+}
+
+/** Aggregate outcome of one stable-surface pruning pass. */
+export interface PruneResult {
+  /** Replacements in landing order. */
+  readonly pruned: readonly PrunedEntry[]
+  /** Total deterministic pressure cost removed across replacements. */
+  readonly charsRemoved: number
+  /** Authoritative exact canonical content tokens removed. */
+  readonly tokensRemoved: number
+}

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

@@ -0,0 +1,48 @@
+/** Version-neutral immutable-value and closed-union helpers for the plugin runtime. */
+
+/**
+ * Freeze an object graph in place without relying on a Harness utility export.
+ * Live AbortSignals remain mutable so request cancellation continues to work.
+ * @param value - Value to freeze recursively.
+ * @returns The same deeply frozen value.
+ */
+export function deepFreeze<T>(value: T): T {
+  const seen = new WeakSet<object>()
+  const pending: Array<{ readonly kind: 'visit', readonly node: unknown } | {
+    readonly kind: 'property'
+    readonly source: Record<string, unknown>
+    readonly key: string
+  }> = [{ kind: 'visit', node: value }]
+  while (pending.length > 0) {
+    const task = pending.pop()
+    /* v8 ignore next -- the loop condition guarantees one pending task. */
+    if (task === undefined) continue
+    if (task.kind === 'property') {
+      pending.push({ kind: 'visit', node: task.source[task.key] })
+      continue
+    }
+    const node = task.node
+    if (node === null || typeof node !== 'object' || node instanceof AbortSignal || seen.has(node)) continue
+    seen.add(node)
+    Object.freeze(node)
+    const keys = Object.keys(node)
+    for (let index = keys.length - 1; index >= 0; index--) {
+      const key = keys[index]
+      /* v8 ignore next -- the loop is bounded by the captured key count. */
+      if (key === undefined) continue
+      pending.push({ kind: 'property', source: node as Record<string, unknown>, key })
+    }
+  }
+  return value
+}
+
+/**
+ * Throw for an impossible member of a closed discriminated union.
+ * @param value - Value that escaped its closed union type.
+ * @param context - Optional switch-site label.
+ * @returns Never returns.
+ */
+export function assertNever(value: never, context?: string): never {
+  const rendered = JSON.stringify(value) ?? String(value)
+  throw new Error(`unreachable variant${context === undefined ? '' : ` in ${context}`}: ${rendered}`)
+}

package/packages/selector/tests/auto-compact.client.spec.tsx

@@ -0,0 +1,226 @@
+// @vitest-environment jsdom
+
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { useSyncExternalStore } from 'react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+  CompressionProfileSelector,
+  ContextCompressionSettingsSection,
+  type CompressionProfileSelectorProps,
+  type ContextCompressionSettings,
+} from '../src/client/CompressionProfileSelector.tsx'
+import { en } from '../src/client/locales.ts'
+
+afterEach(cleanup)
+
+interface SettingsScopeSnapshot<T> {
+  status: 'loading' | 'ready' | 'unavailable'
+  value: T | undefined
+  base: T | undefined
+  user: T | undefined
+  revision: number | undefined
+  writable: boolean
+  mode: 'host' | 'memory'
+}
+
+interface SnapshotStore<T> {
+  readonly getSnapshot: () => T
+  readonly subscribe: (listener: () => void) => () => void
+  readonly update: (recipe: (draft: T) => void) => void
+}
+
+function createSnapshotStore<T>(initial: T): SnapshotStore<T> {
+  let snapshot = structuredClone(initial)
+  const listeners = new Set<() => void>()
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener)
+      return () => { listeners.delete(listener) }
+    },
+    update(recipe) {
+      const draft = structuredClone(snapshot)
+      recipe(draft)
+      snapshot = draft
+      for (const listener of listeners) listener()
+    },
+  }
+}
+
+function bindSnapshotSelector<T>(store: SnapshotStore<T>) {
+  return function useSnapshotSelector<U>(selector: (snapshot: T) => U): U {
+    return useSyncExternalStore(
+      store.subscribe,
+      () => selector(store.getSnapshot()),
+      () => selector(store.getSnapshot()),
+    )
+  }
+}
+
+const DEFAULT_CUSTOM = {
+  version: 1,
+  unit: 'tokens',
+  fresh: { enabled: true, trigger: 4_096, target: 2_048 },
+  aggregate: { enabled: true, trigger: 16_384, target: 8_192 },
+  history: {
+    enabled: true,
+    trigger: 32_768,
+    keepRecentTurns: 2,
+    keepRecent: 16_384,
+    minReclaim: 8_192,
+  },
+  prefixPolicy: 'pressure-break',
+} as const satisfies ContextCompressionSettings['custom']
+
+const t = (key: string) => en[key as keyof typeof en] ?? key
+
+interface MountOptions {
+  readonly value?: ContextCompressionSettings
+  readonly saveAutoCompact?: (thresholdPercent: number) => Promise<void>
+  readonly settingsSection?: boolean
+  readonly writable?: boolean
+  readonly status?: 'loading' | 'ready'
+}
+
+function mountAutoCompact(options: MountOptions = {}) {
+  const state = createSnapshotStore<SettingsScopeSnapshot<ContextCompressionSettings>>({
+    status: options.status ?? 'ready',
+    value: options.value ?? {
+      profile: 'balanced',
+      custom: structuredClone(DEFAULT_CUSTOM),
+      autoCompact: { thresholdPercent: 80 },
+      codeSkeleton: { enabled: false },
+    },
+    base: undefined,
+    user: undefined,
+    revision: 0,
+    writable: options.writable ?? true,
+    mode: 'host',
+  })
+  const sessions = createSnapshotStore({
+    ids: ['s1'],
+    byId: { s1: { id: 's1', displayTitle: 's1', running: false, blank: true, updatedAt: 0, agentPreset: 'standard' } },
+    current: 's1',
+    phase: 'ready',
+    subagentsByParent: {},
+    jobsBySession: {},
+    currentAddress: undefined,
+  })
+  const saveAutoCompact = options.saveAutoCompact ?? vi.fn(() => Promise.resolve())
+  const Component = options.settingsSection === false ? CompressionProfileSelector : ContextCompressionSettingsSection
+  render(<Component {...({
+    useCompression: bindSnapshotSelector(state),
+    useSessions: bindSnapshotSelector(sessions),
+    select: vi.fn(() => Promise.resolve()),
+    saveCustom: vi.fn(() => Promise.resolve()),
+    resetCustom: vi.fn(() => Promise.resolve()),
+    saveAutoCompact,
+    saveCodeSkeleton: vi.fn(() => Promise.resolve()),
+    savePresetOptions: vi.fn(() => Promise.resolve()),
+    t,
+  } as unknown as CompressionProfileSelectorProps)} />)
+  return { state, saveAutoCompact }
+}
+
+const INPUT_LABEL = 'Auto Compact threshold (%)'
+
+describe('Auto Compact threshold controls', () => {
+  it('renders the editor only inside the context-compression settings section', () => {
+    mountAutoCompact({ settingsSection: true })
+    expect(screen.getByLabelText(INPUT_LABEL)).not.toBeNull()
+    expect(screen.queryByRole('slider')).toBeNull()
+    for (const quick of ['70%', '80%', '85%']) expect(screen.queryByRole('button', { name: quick })).toBeNull()
+
+    // The compact workspace selector shows a summary, never a second editor.
+    cleanup()
+    mountAutoCompact({ settingsSection: false })
+    expect(screen.queryByLabelText(INPUT_LABEL)).toBeNull()
+    expect(screen.queryByRole('slider')).toBeNull()
+    expect(screen.getByText(/Auto Compact threshold: 80%/)).not.toBeNull()
+  })
+
+  // Regression guard: the settings surface must keep BOTH section-level gates.
+  // A refactor once dropped CodeSkeletonControls from the settings section while
+  // leaving the injected save path intact, so the code-skeleton save contract
+  // stayed green with the control missing from the UI.
+  it('keeps the code-skeleton gate alongside the Auto Compact editor in the settings section', () => {
+    mountAutoCompact({ settingsSection: true })
+    expect(screen.getByRole('heading', { name: en['codeSkeleton.title'] })).not.toBeNull()
+    expect(screen.getByLabelText(en['codeSkeleton.enabled'])).not.toBeNull()
+    expect(screen.getByRole('heading', { name: en['autoCompact.title'] })).not.toBeNull()
+  })
+
+  it('saves a non-quick value like 73 and reads the same value back after remount', async () => {
+    const saving = vi.fn((thresholdPercent: number): Promise<void> => {
+      mounted.state.update(draft => {
+        if (draft.value !== undefined) draft.value.autoCompact = { thresholdPercent }
+      })
+      return Promise.resolve()
+    })
+    const mounted = mountAutoCompact({ settingsSection: true, saveAutoCompact: saving })
+    fireEvent.change(screen.getByLabelText(INPUT_LABEL), { target: { value: '73' } })
+    fireEvent.click(screen.getByRole('button', { name: 'Save Auto Compact threshold' }))
+    await waitFor(() => { expect(mounted.state.getSnapshot().value?.autoCompact).toEqual({ thresholdPercent: 73 }) })
+
+    // A fresh mount reads the same persisted settings.
+    cleanup()
+    mountAutoCompact({
+      settingsSection: true,
+      value: { profile: 'balanced', custom: structuredClone(DEFAULT_CUSTOM), autoCompact: { thresholdPercent: 73 }, codeSkeleton: { enabled: false } },
+    })
+    expect(screen.getByLabelText<HTMLInputElement>(INPUT_LABEL).value).toBe('73')
+  })
+
+  it.each(['49', '91', '72.5', 'abc', ''])('blocks saving the invalid draft %s', (draft) => {
+    const { saveAutoCompact } = mountAutoCompact({ settingsSection: true })
+    fireEvent.change(screen.getByLabelText(INPUT_LABEL), { target: { value: draft } })
+    expect(screen.getByRole<HTMLButtonElement>('button', { name: 'Save Auto Compact threshold' }).disabled).toBe(true)
+    expect(screen.getByText(/must be an integer between 50 and 90/)).not.toBeNull()
+    expect(saveAutoCompact).not.toHaveBeenCalled()
+  })
+
+  it('uses the typed number input as the only threshold editor', () => {
+    mountAutoCompact({ settingsSection: true })
+    const input = screen.getByLabelText<HTMLInputElement>(INPUT_LABEL)
+    fireEvent.change(input, { target: { value: '73' } })
+    expect(input.value).toBe('73')
+    expect(screen.queryByRole('slider')).toBeNull()
+    for (const quick of ['70%', '80%', '85%']) expect(screen.queryByRole('button', { name: quick })).toBeNull()
+  })
+
+  it('explains the risk outside the recommended 70–85 band but keeps saving available', () => {
+    mountAutoCompact({ settingsSection: true })
+    fireEvent.change(screen.getByLabelText(INPUT_LABEL), { target: { value: '65' } })
+    expect(screen.getByText(/summarization calls and prefix rebuilds/)).not.toBeNull()
+    expect(screen.getByRole<HTMLButtonElement>('button', { name: 'Save Auto Compact threshold' }).disabled).toBe(false)
+
+    fireEvent.change(screen.getByLabelText(INPUT_LABEL), { target: { value: '90' } })
+    expect(screen.getByText(/shared by requests and output/)).not.toBeNull()
+    expect(screen.getByRole<HTMLButtonElement>('button', { name: 'Save Auto Compact threshold' }).disabled).toBe(false)
+
+    fireEvent.change(screen.getByLabelText(INPUT_LABEL), { target: { value: '80' } })
+    expect(screen.queryByText(/summarization calls and prefix rebuilds/)).toBeNull()
+    expect(screen.queryByText(/shared by requests and output/)).toBeNull()
+  })
+
+  it('disables every control while saving or when the scope is not writable', () => {
+    const { saveAutoCompact } = mountAutoCompact({ settingsSection: true, status: 'loading' })
+    expect(screen.getByLabelText<HTMLInputElement>(INPUT_LABEL).disabled).toBe(true)
+    expect(screen.getByRole<HTMLButtonElement>('button', { name: 'Save Auto Compact threshold' }).disabled).toBe(true)
+    expect(saveAutoCompact).not.toHaveBeenCalled()
+
+    cleanup()
+    mountAutoCompact({ settingsSection: true, writable: false })
+    expect(screen.getByLabelText<HTMLInputElement>(INPUT_LABEL).disabled).toBe(true)
+    expect(screen.getByRole<HTMLButtonElement>('button', { name: 'Save Auto Compact threshold' }).disabled).toBe(true)
+  })
+
+  it('shows a failed threshold save inline', async () => {
+    const rejected = Promise.reject(new Error('threshold write failed'))
+    void rejected.catch(() => {})
+    mountAutoCompact({ settingsSection: true, saveAutoCompact: () => rejected })
+    fireEvent.change(screen.getByLabelText(INPUT_LABEL), { target: { value: '73' } })
+    fireEvent.click(screen.getByRole('button', { name: 'Save Auto Compact threshold' }))
+    await waitFor(() => { expect(screen.getByRole('alert').textContent).toContain('threshold write failed') })
+  })
+})

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

@@ -0,0 +1,51 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import * as React from 'react'
+import * as jsxRuntime from 'react/jsx-runtime'
+import { describe, expect, it } from 'vitest'
+
+const artifact = resolve(import.meta.dirname, '../../lib/client.js')
+
+describe('built Harness client artifact', () => {
+  it('registers a self-contained lazy-CJS factory and injects its CSS', () => {
+    const code = readFileSync(artifact, 'utf8')
+    let registration: { id: string, factory: (require: (id: string) => unknown) => unknown } | undefined
+    const moduleLoader = {
+      load(value: typeof registration) {
+        registration = value
+      },
+    }
+    Object.defineProperty(window, '__ModuleLoader__', { configurable: true, value: moduleLoader })
+
+    expect(() => Function(code)()).not.toThrow()
+    expect(registration?.id).toBe('dsh-context-compression-improved')
+
+    const modules = new Map<string, unknown>([
+      ['react', React],
+      ['react/jsx-runtime', jsxRuntime],
+      // The current selector only keeps this official package as a side-effect
+      // external. A minimal public-module stub proves the artifact asks the
+      // Harness loader for it without importing the package's raw CSS in Node.
+      ['@deepseek-ai/dsh-client-ui-primitives', {}],
+    ])
+    const exported = registration?.factory((id) => {
+      if (!modules.has(id)) throw new Error(`unexpected client dependency: ${id}`)
+      return modules.get(id)
+    }) as { apply?: unknown, inject?: unknown }
+
+    expect(exported.apply).toBeTypeOf('function')
+    expect(exported.inject).toEqual(['slots', 'locale', 'settingsScope'])
+    const style = document.querySelector<HTMLStyleElement>(
+      'style[data-plugin-css="dsh-context-compression-improved/CompressionProfileSelector.module.css"]',
+    )
+    expect(style?.dataset.plugin).toBe('dsh-context-compression-improved')
+    expect(style?.textContent).toContain('profileGrid')
+    expect(document.querySelectorAll('style[data-plugin-css]').length).toBe(1)
+
+    registration?.factory((id) => modules.get(id))
+    expect(document.querySelectorAll('style[data-plugin-css]').length).toBe(1)
+    expect(code).not.toMatch(/^\s*(?:import|export)\s/mu)
+    expect(code).not.toMatch(/(?:\/home\/|[A-Za-z]:\\Users\\)/u)
+    expect(code).not.toContain('sourceMappingURL')
+  })
+})