dsh-context-compression-improved 0.1.1 → 0.2.0

package/packages/selector/tests/estimator-channel.client.spec.tsx

@@ -0,0 +1,247 @@
+// @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 {
+  ContextCompressionSettingsSection,
+  type CompressionProfileSelectorProps,
+  type ContextCompressionSettings,
+} from '../src/client/CompressionProfileSelector.tsx'
+import { en } from '../src/client/locales.ts'
+
+afterEach(() => {
+  cleanup()
+  vi.unstubAllGlobals()
+})
+
+interface SnapshotStore<T> {
+  readonly getSnapshot: () => T
+  readonly subscribe: (listener: () => void) => () => void
+}
+
+function createSnapshotStore<T>(initial: T): SnapshotStore<T> {
+  const snapshot = structuredClone(initial)
+  const listeners = new Set<() => void>()
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener)
+      return () => { listeners.delete(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
+
+const PROVIDER_LABEL = 'Provider'
+const CHANNEL_LABEL = 'Channel'
+const MODEL_LABEL = 'Model'
+const API_KEY_LABEL = 'API key (write-only, never echoed)'
+const BASE_URL_LABEL = 'Endpoint base URL (/v1)'
+
+const CATALOG = {
+  ok: true,
+  providers: [
+    {
+      id: 'local-35b',
+      name: 'local-35b',
+      models: [{ id: 'Qwen3.6-35B-A3B', name: 'Qwen3.6-35B-A3B' }, { id: 'Qwen38-27B', name: 'Qwen38-27B' }],
+    },
+    { id: 'deepseek-official', name: 'DeepSeek', models: [{ id: 'deepseek-flash', name: 'DeepSeek-V41-Flash' }] },
+  ],
+  selection: { provider: 'deepseek-official', model: 'deepseek-flash' },
+}
+
+function mountEstimator(
+  presetOptions: ContextCompressionSettings['presetOptions'],
+  options: { readonly catalog?: unknown, readonly profile?: ContextCompressionSettings['profile'] } = {},
+) {
+  const state = createSnapshotStore({
+    status: 'ready' as const,
+    value: {
+      profile: options.profile ?? ('tokenpilot-inspired' as const),
+      custom: structuredClone(DEFAULT_CUSTOM),
+      autoCompact: { thresholdPercent: 80 },
+      codeSkeleton: { enabled: false },
+      presetOptions: presetOptions ?? {},
+    },
+    base: undefined,
+    user: undefined,
+    revision: 0,
+    writable: true,
+    mode: 'host' as const,
+  })
+  const sessions = createSnapshotStore({
+    ids: ['s1'],
+    byId: { s1: { id: 's1', agentPreset: 'standard' } },
+    current: 's1',
+  })
+  const savePresetOptions = vi.fn(() => Promise.resolve())
+  if (options.catalog !== undefined) {
+    vi.stubGlobal('fetch', vi.fn(() => Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve(options.catalog),
+    })))
+  }
+  render(<ContextCompressionSettingsSection {...({
+    useCompression: bindSnapshotSelector(state),
+    useSessions: bindSnapshotSelector(sessions),
+    select: vi.fn(() => Promise.resolve()),
+    saveCustom: vi.fn(() => Promise.resolve()),
+    resetCustom: vi.fn(() => Promise.resolve()),
+    saveAutoCompact: vi.fn(() => Promise.resolve()),
+    saveCodeSkeleton: vi.fn(() => Promise.resolve()),
+    savePresetOptions,
+    t,
+  } as unknown as CompressionProfileSelectorProps)} />)
+  return { savePresetOptions }
+}
+
+describe('estimator channel card', () => {
+  it('host mode fills comboboxes from the catalog, keeps custom typing, and asks for no API key', async () => {
+    const { savePresetOptions } = mountEstimator({ estimatorMode: 'host' }, { catalog: CATALOG })
+
+    // Provider/model are always comboboxes (dsh-perm-gate receiver pattern):
+    // a catalog pick fills the field, and the same input accepts a custom id.
+    const provider = screen.getByLabelText<HTMLInputElement>(PROVIDER_LABEL)
+    const model = screen.getByLabelText<HTMLInputElement>(MODEL_LABEL)
+    await waitFor(() => {
+      const providerOptions = document.querySelectorAll('#estimator-provider-options option')
+      expect([...providerOptions].map(option => (option as HTMLOptionElement).value))
+        .toEqual(['local-35b', 'deepseek-official'])
+      expect(provider.getAttribute('list')).toBe('estimator-provider-options')
+      expect(model.getAttribute('list')).toBe('estimator-model-options')
+    })
+    expect(screen.getByText(/Effective route: deepseek-official \/ deepseek-flash/)).not.toBeNull()
+    expect(screen.getByText(/no API key is needed/)).not.toBeNull()
+
+    // No credential input and no base-URL field on this channel.
+    expect(screen.queryByLabelText(API_KEY_LABEL)).toBeNull()
+    expect(screen.queryByLabelText(BASE_URL_LABEL)).toBeNull()
+    expect(document.querySelectorAll('input[type="password"]').length).toBe(0)
+
+    // A datalist pick fires change without blur: it commits immediately.
+    fireEvent.change(provider, { target: { value: 'local-35b' } })
+    await waitFor(() => {
+      expect(savePresetOptions).toHaveBeenCalledWith({ estimatorProvider: 'local-35b' })
+    })
+    // Free typing only commits on blur, so mid-edit keystrokes never save.
+    fireEvent.change(provider, { target: { value: 'my-custom-group' } })
+    expect(savePresetOptions).not.toHaveBeenCalledWith({ estimatorProvider: 'my-custom-group' })
+    fireEvent.blur(provider)
+    await waitFor(() => {
+      expect(savePresetOptions).toHaveBeenCalledWith({ estimatorProvider: 'my-custom-group' })
+    })
+  })
+
+  it('offers the catalog models of the chosen provider and commits one', async () => {
+    const { savePresetOptions } = mountEstimator(
+      { estimatorMode: 'host', estimatorProvider: 'local-35b' },
+      { catalog: CATALOG },
+    )
+    // Query before the catalog lands: once the datalist has options, the
+    // label's textContent includes them and getByLabelText's exact match
+    // would no longer see a bare "Model".
+    const model = screen.getByLabelText<HTMLInputElement>(MODEL_LABEL)
+    expect(model.value).toBe('')
+    await waitFor(() => {
+      const modelOptions = document.querySelectorAll('#estimator-model-options option')
+      expect([...modelOptions].map(option => (option as HTMLOptionElement).value))
+        .toEqual(['Qwen3.6-35B-A3B', 'Qwen38-27B'])
+    })
+    expect(screen.getByText(/Effective route: local-35b/)).not.toBeNull()
+
+    fireEvent.change(model, { target: { value: 'Qwen38-27B' } })
+    await waitFor(() => {
+      expect(savePresetOptions).toHaveBeenCalledWith({ estimatorModel: 'Qwen38-27B' })
+    })
+  })
+
+  it('still accepts custom names — without a credential field — when no catalog is served', async () => {
+    vi.stubGlobal('fetch', vi.fn(() => Promise.reject(new Error('no route'))))
+    const { savePresetOptions } = mountEstimator({ estimatorMode: 'host' })
+
+    const provider = screen.getByLabelText<HTMLInputElement>(PROVIDER_LABEL)
+    expect(screen.getByLabelText(MODEL_LABEL).tagName).toBe('INPUT')
+    expect(document.querySelectorAll('#estimator-provider-options option').length).toBe(0)
+    expect(document.querySelectorAll('#estimator-model-options option').length).toBe(0)
+    fireEvent.change(provider, { target: { value: 'manual-group' } })
+    fireEvent.blur(provider)
+    await waitFor(() => {
+      expect(savePresetOptions).toHaveBeenCalledWith({ estimatorProvider: 'manual-group' })
+    })
+    expect(screen.queryByLabelText(API_KEY_LABEL)).toBeNull()
+    expect(screen.getByText(/no API key is needed/)).not.toBeNull()
+    expect(screen.getByText(/not determined yet/)).not.toBeNull()
+  })
+
+  it('keeps the endpoint and key fields on the direct channel alone', () => {
+    mountEstimator({ estimatorMode: 'direct' })
+
+    expect(screen.getByLabelText(BASE_URL_LABEL)).not.toBeNull()
+    expect(screen.getByLabelText(MODEL_LABEL).tagName).toBe('INPUT')
+    expect(screen.getByLabelText(API_KEY_LABEL)).not.toBeNull()
+    expect(document.querySelectorAll('input[type="password"]').length).toBe(1)
+    expect(screen.queryByLabelText(PROVIDER_LABEL)).toBeNull()
+    expect(screen.queryByText(/no API key is needed/)).toBeNull()
+  })
+
+  it('renders no channel controls while the estimator is off', () => {
+    mountEstimator({})
+    expect(screen.queryByLabelText(API_KEY_LABEL)).toBeNull()
+    expect(screen.queryByLabelText(BASE_URL_LABEL)).toBeNull()
+    expect(screen.queryByLabelText(PROVIDER_LABEL)).toBeNull()
+  })
+
+  // Regression guard for the first real-machine report: the card used to render
+  // nothing at all off tokenpilot-inspired, which reads as a missing feature.
+  it('keeps the estimator section, and names the unlocking profile, off tokenpilot-inspired', () => {
+    mountEstimator({}, { profile: 'balanced' })
+
+    // The heading and its stable anchor survive, so the panel is still findable
+    // where the reader last saw it.
+    expect(document.getElementById('context-compression-estimator-title')?.textContent)
+      .toBe('Estimator (optional)')
+    // The notice names the current profile and the profile that unlocks the card.
+    const notice = screen.getByText(/ships only with the TokenPilot-inspired profile/)
+    expect(notice.textContent).toContain('“Balanced”')
+    expect(notice.textContent).toContain('Select TokenPilot-inspired')
+    // Gating semantics are unchanged: no channel control exists here.
+    expect(screen.queryByLabelText(CHANNEL_LABEL)).toBeNull()
+    expect(screen.queryByLabelText(PROVIDER_LABEL)).toBeNull()
+    expect(screen.queryByLabelText(API_KEY_LABEL)).toBeNull()
+    expect(document.querySelectorAll('input[list]').length).toBe(0)
+  })
+
+  it('drops the inactive notice once tokenpilot-inspired owns the selector', () => {
+    mountEstimator({})
+    expect(screen.queryByText(/ships only with the TokenPilot-inspired profile/)).toBeNull()
+    expect(screen.getByLabelText(CHANNEL_LABEL)).not.toBeNull()
+  })
+})

package/packages/selector/tests/estimator-route-registration.host.spec.ts

@@ -0,0 +1,176 @@
+/**
+ * Host-side guard for the estimator catalog route.
+ *
+ * The defect this pins is a registration that never happens: the injection gate
+ * asked for more services than the handler needs, and an unsatisfied
+ * `ctx.inject` callback fails silently, so the plugin simply had no HTTP API
+ * and every request fell through to the host 404. These cases assert the two
+ * properties that failure violated — the route appears whenever `webServer` is
+ * usable, in either arrival order, and its absence is never silent.
+ */
+
+import { Context } from '@deepseek-ai/cordis'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { apply } from '../src/index.ts'
+
+const CATALOG_ROUTE = '/api/dsh-context-compression-improved/estimator-catalog'
+const LEGACY_ROUTE = '/endpoint/dsh-context-compression-improved/estimator-catalog'
+
+interface RegisteredRoute {
+  kind: string
+  path: string
+  handler: (req: unknown, res: unknown) => void
+}
+
+interface FakeResponse {
+  status?: number
+  body?: string
+}
+
+/** The state `register` reads off its own `this`, mirroring the host service. */
+interface WebServerStub {
+  tables: { exact: Map<string, RegisteredRoute> }
+}
+
+let ctx: Context | undefined
+
+afterEach(async () => {
+  await ctx?.fiber.dispose()
+  ctx = undefined
+})
+
+/** Settle one macrotask so a deferred activation callback can run. */
+const settle = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 20))
+
+/**
+ * Mount a host web server stand-in that records routes and reproduces the real
+ * host's duplicate-`(kind, path)` contract, so a double registration is a
+ * failure rather than a silent overwrite.
+ */
+async function mountWebServer(runtime: Context, routes: RegisteredRoute[]): Promise<void> {
+  await runtime.plugin({
+    name: 'fake-webserver',
+    apply(webCtx) {
+      webCtx.provide('webServer', {
+        // Mirrors dsh-host-webserver: `register` reads its route table off
+        // `this`. A caller that detaches the method and invokes it standalone
+        // makes `this` the wrapper and fails here, exactly as the host does --
+        // which is the defect this spec exists to catch.
+        tables: { exact: new Map<string, RegisteredRoute>() },
+        register(this: WebServerStub, route: RegisteredRoute) {
+          const table = this.tables.exact
+          if (table.has(route.path)) {
+            throw new Error(`webserver: duplicate ${route.kind} route "${route.path}"`)
+          }
+          table.set(route.path, route)
+          routes.push(route)
+          return () => {}
+        },
+      })
+    },
+  })
+}
+
+/** Mount the estimator-side services the handler only enriches its payload with. */
+async function mountEstimatorServices(runtime: Context): Promise<void> {
+  await runtime.plugin({
+    name: 'fake-estimator-services',
+    apply(estimatorCtx) {
+      estimatorCtx.provide('llm', { listProviders: () => [] })
+      estimatorCtx.provide('agentDefaultModel', { currentSelection: () => undefined })
+    },
+  })
+}
+
+/** Drive one registered route through a stand-in response. */
+async function invoke(route: RegisteredRoute): Promise<FakeResponse> {
+  const captured: FakeResponse = {}
+  const res = {
+    writeHead(code: number) { captured.status = code },
+    end(body?: string) { if (body !== undefined) captured.body = body },
+  }
+  route.handler({ method: 'GET' }, res)
+  await settle()
+  return captured
+}
+
+describe('estimator catalog route registration', () => {
+  it('registers both route prefixes with only webServer present', async () => {
+    const routes: RegisteredRoute[] = []
+    const runtime = new Context()
+    ctx = runtime
+    await mountWebServer(runtime, routes)
+
+    apply(runtime, { estimatorCatalogRoute: true })
+    await settle()
+
+    expect(routes.map(route => route.path)).toEqual([LEGACY_ROUTE, CATALOG_ROUTE])
+    expect(routes.every(route => route.kind === 'exact')).toBe(true)
+  })
+
+  it('registers the route when webServer activates after the plugin applied', async () => {
+    const routes: RegisteredRoute[] = []
+    const runtime = new Context()
+    ctx = runtime
+
+    apply(runtime, { estimatorCatalogRoute: true })
+    await settle()
+    expect(routes).toHaveLength(0)
+
+    await mountWebServer(runtime, routes)
+    await settle()
+
+    expect(routes.map(route => route.path)).toEqual([LEGACY_ROUTE, CATALOG_ROUTE])
+  })
+
+  it('registers nothing twice when the estimator services arrive later', async () => {
+    const routes: RegisteredRoute[] = []
+    const runtime = new Context()
+    ctx = runtime
+    await mountWebServer(runtime, routes)
+
+    apply(runtime, { estimatorCatalogRoute: true })
+    await settle()
+    const afterRegistration = routes.length
+
+    await mountEstimatorServices(runtime)
+    await settle()
+
+    expect(routes).toHaveLength(afterRegistration)
+  })
+
+  it('keeps the rest of the plugin alive and warns when webServer never arrives', async () => {
+    const runtime = new Context()
+    ctx = runtime
+    // The diagnostic goes to `console`: the host's cordis logger surfaces no
+    // plugin output at all, so a lifecycle line published there is invisible.
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    try {
+      expect(() => apply(runtime, { estimatorCatalogRoute: true })).not.toThrow()
+      await settle()
+
+      const messages = warn.mock.calls.map(([message]) => String(message))
+      expect(messages.some(message => message.includes('estimator catalog route pending'))).toBe(true)
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  it('answers 200 without the estimator services, which only enrich the payload', async () => {
+    const routes: RegisteredRoute[] = []
+    const runtime = new Context()
+    ctx = runtime
+    await mountWebServer(runtime, routes)
+
+    apply(runtime, { estimatorCatalogRoute: true })
+    await settle()
+
+    const route = routes.find(candidate => candidate.path === CATALOG_ROUTE)
+    expect(route).toBeDefined()
+    const response = await invoke(route as RegisteredRoute)
+
+    expect(response.status).toBe(200)
+    expect(JSON.parse(String(response.body))).toMatchObject({ ok: true, providers: [] })
+  })
+})

package/packages/selector/tests/host-preset-overlay.host.spec.ts

@@ -0,0 +1,204 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { Context, Service } from '@deepseek-ai/cordis'
+import type { AgentPreset } from '@deepseek-ai/dsh-agent-presets'
+import {
+  SettingsProvider,
+  settingsNamespace,
+  type SettingsNamespace,
+} from '@deepseek-ai/dsh-settings'
+import { afterEach, describe, expect, it } from 'vitest'
+import { apply } from '../src/index.ts'
+import type { OverlayableAgentPresets } from '../src/preset-overlay.ts'
+
+let root: string | undefined
+let ctx: Context | undefined
+
+afterEach(async () => {
+  await ctx?.fiber.dispose()
+  ctx = undefined
+  if (root !== undefined) await rm(root, { recursive: true, force: true })
+  root = undefined
+})
+
+class MemorySettings extends SettingsProvider {
+  readonly writable = true
+  private readonly stored: Record<string, unknown> = {}
+
+  protected load(): Promise<Record<string, unknown>> {
+    return Promise.resolve(structuredClone(this.stored))
+  }
+
+  protected persist(ns: SettingsNamespace, section: Record<string, unknown>): Promise<void> {
+    this.stored[ns] = structuredClone(section)
+    return Promise.resolve()
+  }
+}
+
+class FakeAgentPresets extends Service implements OverlayableAgentPresets {
+  constructor(ctx: Context, readonly preset: AgentPreset) {
+    super(ctx, 'agentPresets')
+  }
+
+  async resolve(): Promise<AgentPreset> {
+    return this.preset
+  }
+
+  async mount(_agentCtx: unknown): Promise<AgentPreset> {
+    return await this.resolve()
+  }
+
+  async recompose(_agentCtx: unknown, _id: string): Promise<AgentPreset> {
+    return await this.resolve()
+  }
+
+  async standingKeyFor(): Promise<string> {
+    return (await this.resolve()).path
+  }
+}
+
+async function sourcePreset(): Promise<AgentPreset> {
+  root = await mkdtemp(join(tmpdir(), 'dsh-selector-host-overlay-'))
+  const path = join(root, 'standard', 'agent.cordis.yml')
+  await mkdir(dirname(path), { recursive: true })
+  await writeFile(path, "- id: persona\n  name: '/opt/preset/persona.js'\n")
+  return { id: 'standard', trust: 'system', path }
+}
+
+describe('context compression selector Host preset integration', () => {
+  it('decorates native composition only for the lifetime of the selector fiber', async () => {
+    const preset = await sourcePreset()
+    ctx = new Context()
+    await ctx.plugin(MemorySettings).await()
+    await ctx.plugin(FakeAgentPresets, preset).await()
+
+    const selector = ctx.plugin({ apply: (child) => {
+      apply(child, { presetOverlay: true })
+    } })
+    await selector.await()
+
+    const service = ctx.agentPresets as unknown as OverlayableAgentPresets
+    const mounted = await service.mount({})
+    expect(mounted.path).not.toBe(preset.path)
+    expect(await readFile(mounted.path, 'utf8')).toContain('id: tool-result-pruner')
+    expect((await service.resolve()).path).toBe(preset.path)
+
+    await selector.dispose()
+    expect((await service.mount({})).path).toBe(preset.path)
+  })
+
+  it('keeps settings and overlay alive across duplicate Host row disposal', async () => {
+    const preset = await sourcePreset()
+    ctx = new Context()
+    await ctx.plugin(MemorySettings).await()
+    await ctx.plugin(FakeAgentPresets, preset).await()
+
+    const builtIn = ctx.plugin({ apply })
+    await builtIn.await()
+
+    const namespace = settingsNamespace('context-compression')
+    const service = ctx.agentPresets as unknown as OverlayableAgentPresets
+    expect((await service.mount({})).path).toBe(preset.path)
+    expect(ctx.settings.describe().filter(row => row.ns === namespace)).toHaveLength(1)
+
+    await ctx.settings.update(namespace, { profile: 'cache-strict' })
+    const selectedSettings = structuredClone(ctx.settings.get(namespace))
+    expect(selectedSettings).toMatchObject({ profile: 'cache-strict' })
+
+    const bundle = ctx.plugin({ apply: (child) => {
+      apply(child, { presetOverlay: true })
+    } })
+    await bundle.await()
+
+    const mounted = await service.mount({})
+    expect(mounted.path).not.toBe(preset.path)
+    expect((await service.recompose({}, 'standard')).path).toBe(mounted.path)
+    expect(ctx.settings.get(namespace)).toEqual(selectedSettings)
+    expect(ctx.settings.describe().filter(row => row.ns === namespace)).toHaveLength(1)
+
+    await builtIn.dispose()
+    expect((await service.mount({})).path).toBe(mounted.path)
+    expect(ctx.settings.describe().filter(row => row.ns === namespace)).toHaveLength(1)
+
+    await bundle.dispose()
+    expect((await service.mount({})).path).toBe(preset.path)
+    expect(ctx.settings.describe().filter(row => row.ns === namespace)).toHaveLength(0)
+  })
+
+  it('writes the saved Auto Compact threshold into the generated compaction-basic composition', async () => {
+    const preset = await sourcePreset()
+    ctx = new Context()
+    await ctx.plugin(MemorySettings).await()
+    await ctx.plugin(FakeAgentPresets, preset).await()
+    // A settings-owning row must register the namespace before the update.
+    await ctx.plugin({ apply }).await()
+    const namespace = settingsNamespace('context-compression')
+    await ctx.settings.update(namespace, { autoCompact: { thresholdPercent: 73 } })
+
+    const bundle = ctx.plugin({ apply: (child) => {
+      apply(child, { presetOverlay: true })
+    } })
+    await bundle.await()
+
+    const service = ctx.agentPresets as unknown as OverlayableAgentPresets
+    const mounted = await service.mount({})
+    const rendered = await readFile(mounted.path, 'utf8')
+    expect(rendered).toContain('id: compaction-basic')
+    expect(rendered).toContain('thresholdRatio: 0.73')
+    // First-release retention stays pinned at 0.16 next to the threshold.
+    expect(rendered).toContain('retainRatio: 0.16')
+    // The SAME read feeds the runtime deployment config, so one generation
+    // cannot split Auto Compact and micro compact across two thresholds.
+    expect(rendered).toContain('id: tool-result-pruner')
+    expect(rendered).toContain('autoCompactThresholdPercent: 73')
+    await bundle.dispose()
+  })
+
+  it('defaults the generated threshold to 0.8 and keeps it absent from settings until saved', async () => {
+    const preset = await sourcePreset()
+    ctx = new Context()
+    await ctx.plugin(MemorySettings).await()
+    await ctx.plugin(FakeAgentPresets, preset).await()
+
+    const bundle = ctx.plugin({ apply: (child) => {
+      apply(child, { presetOverlay: true })
+    } })
+    await bundle.await()
+
+    const service = ctx.agentPresets as unknown as OverlayableAgentPresets
+    const rendered = await readFile((await service.mount({})).path, 'utf8')
+    expect(rendered).toContain('thresholdRatio: 0.8')
+    await bundle.dispose()
+  })
+
+  it('moves the standing composition generation when an equal-length threshold changes', async () => {
+    const preset = await sourcePreset()
+    ctx = new Context()
+    await ctx.plugin(MemorySettings).await()
+    await ctx.plugin(FakeAgentPresets, preset).await()
+    // A settings-owning row must register the namespace before the update.
+    await ctx.plugin({ apply }).await()
+    const namespace = settingsNamespace('context-compression')
+    await ctx.settings.update(namespace, { autoCompact: { thresholdPercent: 70 } })
+
+    const bundle = ctx.plugin({ apply: (child) => {
+      apply(child, { presetOverlay: true })
+    } })
+    await bundle.await()
+
+    const service = ctx.agentPresets as unknown as OverlayableAgentPresets
+    const first = await service.mount({})
+    expect(await readFile(first.path, 'utf8')).toContain('thresholdRatio: 0.7')
+    expect(await service.standingKeyFor()).toBe(first.path)
+
+    // Same character length, different content: the generated identity and
+    // standing composition generation must both move to the new threshold.
+    await ctx.settings.update(namespace, { autoCompact: { thresholdPercent: 80 } })
+    const second = await service.mount({})
+    expect(second.path).not.toBe(first.path)
+    expect(await readFile(second.path, 'utf8')).toContain('thresholdRatio: 0.8')
+    expect(await service.standingKeyFor()).toBe(second.path)
+    await bundle.dispose()
+  })
+})