dsh-context-compression-improved 0.1.1 → 0.2.0

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

@@ -0,0 +1,181 @@
+// @vitest-environment jsdom
+
+import { describe, expect, it } from 'vitest'
+import { apply } from '../src/client/index.ts'
+import type { CompressionSelectorInjected } from '../src/client/CompressionProfileSelector.tsx'
+import type { ContextCompressionSettings } from '../src/profiles.ts'
+
+/**
+ * `settingsScope.set(field, value)` replaces the value at that field, so the
+ * write path is asserted through the document it stores: writing the bare
+ * patch is what silently deleted `estimatorMode` (and every sibling override)
+ * whenever the user touched a second field of the TokenPilot-inspired card.
+ */
+
+type ScopeFace = {
+  getSnapshot: () => unknown
+  subscribe: (listener: () => void) => () => void
+  set: (field: string, value: unknown) => Promise<void>
+  unset: (field: string) => Promise<void>
+}
+
+function createScopeStub(initial: ContextCompressionSettings, commit = true): {
+  scope: ScopeFace
+  writes: { field: string, value: unknown }[]
+  section: () => Record<string, unknown>
+  sectionOf: (key: string) => unknown
+} {
+  let revision = 1
+  let value: Record<string, unknown> = structuredClone(initial) as unknown as Record<string, unknown>
+  const writes: { field: string, value: unknown }[] = []
+  const listeners = new Set<() => void>()
+  const scope: ScopeFace = {
+    getSnapshot: () => ({
+      status: 'ready',
+      value: value as unknown as ContextCompressionSettings,
+      base: undefined,
+      user: undefined,
+      revision,
+      writable: true,
+      mode: 'host',
+    }),
+    subscribe: (listener: () => void) => {
+      listeners.add(listener)
+      return () => { listeners.delete(listener) }
+    },
+    set: (field: string, fieldValue: unknown) => {
+      writes.push({ field, value: fieldValue })
+      // The Host applies `set` AT the path: the section value is replaced.
+      if (commit) {
+        value = { ...value, [field]: structuredClone(fieldValue) }
+        revision += 1
+        for (const listener of listeners) listener()
+      }
+      return Promise.resolve()
+    },
+    unset: (field: string) => {
+      writes.push({ field, value: undefined })
+      if (commit) {
+        delete value[field]
+        revision += 1
+        for (const listener of listeners) listener()
+      }
+      return Promise.resolve()
+    },
+  }
+  return {
+    scope,
+    writes,
+    section: () => value,
+    sectionOf: (key: string) => value[key],
+  }
+}
+
+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']
+
+function bindInjected(
+  presetOptions: ContextCompressionSettings['presetOptions'],
+  commit = true,
+): {
+  injected: CompressionSelectorInjected
+  writes: { field: string, value: unknown }[]
+  sectionOf: (key: string) => unknown
+} {
+  const settings: ContextCompressionSettings = {
+    profile: 'tokenpilot-inspired',
+    custom: structuredClone(DEFAULT_CUSTOM),
+    autoCompact: { thresholdPercent: 80 },
+    codeSkeleton: { enabled: false },
+    ...(presetOptions === undefined ? {} : { presetOptions }),
+  }
+  const stub = createScopeStub(settings, commit)
+  let options: Record<string, unknown> | undefined
+  const ctx = {
+    effect: (factory: () => unknown) => { factory(); return () => {} },
+    locale: { register: () => {}, bind: () => (key: string) => key },
+    settingsScope: { bind: () => stub.scope },
+    slots: {
+      inject: (_slot: string, factory: () => (() => void) | Generator<() => void>) => {
+        const result = factory()
+        return typeof result === 'function' ? result : () => {}
+      },
+      register: (registerOptions: Record<string, unknown>) => {
+        options = registerOptions
+        return () => {}
+      },
+    },
+  }
+  apply(ctx as never)
+  if (options === undefined) throw new Error('the settings card never registered')
+  const factory = options['inject'] as () => CompressionSelectorInjected
+  return { injected: factory(), writes: stub.writes, sectionOf: stub.sectionOf }
+}
+
+describe('presetOptions writes preserve sibling fields', () => {
+  it('keeps the estimator channel when a provider is chosen afterwards', async () => {
+    const { injected, sectionOf } = bindInjected({ estimatorMode: 'host' })
+    await injected.savePresetOptions({ estimatorProvider: 'local-35b' })
+    expect(sectionOf('presetOptions')).toEqual({ estimatorMode: 'host', estimatorProvider: 'local-35b' })
+  })
+
+  it('writes the merged document rather than the bare patch', async () => {
+    const { injected, writes } = bindInjected({ estimatorMode: 'direct', estimatorBaseUrl: 'http://192.168.100.242:8200' })
+    await injected.savePresetOptions({ estimatorModel: 'Qwen3.6-35B-A3B' })
+    expect(writes).toEqual([{
+      field: 'presetOptions',
+      value: {
+        estimatorMode: 'direct',
+        estimatorBaseUrl: 'http://192.168.100.242:8200',
+        estimatorModel: 'Qwen3.6-35B-A3B',
+      },
+    }])
+  })
+
+  it('keeps every unrelated override across successive edits', async () => {
+    const { injected, sectionOf } = bindInjected({
+      estimatorMode: 'direct',
+      dedupeToolResults: false,
+      readState: false,
+    })
+    await injected.savePresetOptions({ estimatorModel: 'Qwen3.6-35B-A3B' })
+    await injected.savePresetOptions({ estimatorProvider: 'local-35b' })
+    expect(sectionOf('presetOptions')).toEqual({
+      estimatorMode: 'direct',
+      dedupeToolResults: false,
+      readState: false,
+      estimatorModel: 'Qwen3.6-35B-A3B',
+      estimatorProvider: 'local-35b',
+    })
+  })
+
+  it('clears exactly the field a patch names with undefined', async () => {
+    const { injected, sectionOf } = bindInjected({ estimatorMode: 'direct', estimatorApiKey: 'sk-stored' })
+    await injected.savePresetOptions({ estimatorApiKey: undefined })
+    expect(sectionOf('presetOptions')).toEqual({ estimatorMode: 'direct' })
+  })
+
+  it('writes nothing when the patch already matches the stored section', async () => {
+    const { injected, writes } = bindInjected({ estimatorMode: 'host', estimatorProvider: 'local-35b' })
+    await injected.savePresetOptions({ estimatorMode: 'host' })
+    expect(writes).toEqual([])
+  })
+
+  it('reports a save the Host did not commit', async () => {
+    const { injected } = bindInjected({ estimatorMode: 'host' }, false)
+    await expect(injected.savePresetOptions({ estimatorProvider: 'local-35b' }))
+      .rejects.toThrow(/were not saved/)
+  })
+})

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

@@ -0,0 +1,196 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { Context } from '@deepseek-ai/cordis'
+import Group from '@deepseek-ai/cordis-plugin-group'
+import Include from '@deepseek-ai/cordis-plugin-include'
+import Loader from '@deepseek-ai/cordis-plugin-loader'
+import AgentRegistry, { type Agent } from '@deepseek-ai/dsh-agent'
+import AgentLoop from '@deepseek-ai/dsh-agent-loop'
+import AgentPresets, { COMPOSITION_FILE } from '@deepseek-ai/dsh-agent-presets'
+import CommandRuntime from '@deepseek-ai/dsh-commands'
+import LlmRuntime from '@deepseek-ai/dsh-llm'
+import SessionStore, { SessionId } from '@deepseek-ai/dsh-session'
+import { scopeOf } from '@deepseek-ai/dsh-scope'
+import {
+  SettingsProvider,
+  settingsNamespace,
+  type SettingsNamespace,
+} from '@deepseek-ai/dsh-settings'
+import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
+import TokenMeter from '@deepseek-ai/dsh-token-meter'
+import ToolRuntime from '@deepseek-ai/dsh-tools'
+import { afterEach, describe, expect, it } from 'vitest'
+import { apply } from '../src/index.ts'
+
+const CORDIS_ORIGINAL = Symbol.for('cordis.original')
+type Traceable = { [CORDIS_ORIGINAL]?: unknown }
+
+let ctx: Context | undefined
+let root: string | 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
+
+  protected load(): Promise<Record<string, unknown>> {
+    return Promise.resolve({})
+  }
+
+  protected persist(_ns: SettingsNamespace, _section: Record<string, unknown>): Promise<void> {
+    return Promise.resolve()
+  }
+}
+
+interface CustomSettings {
+  profile: string
+  custom: {
+    history: { trigger: number }
+    tailTrim: { enabled: boolean; trigger: number }
+  }
+}
+
+async function createPresetRoot(): Promise<string> {
+  root = await mkdtemp(join(tmpdir(), 'dsh-selector-loader-e2e-'))
+  const marker = join(root, 'marker.mjs')
+  await writeFile(marker, 'export function apply() {}\n')
+  const source = `- id: source-marker\n  name: ${JSON.stringify(marker)}\n`
+  for (const id of ['standard', 'custom', 'minimal']) {
+    const directory = join(root, id)
+    await mkdir(directory)
+    await writeFile(join(directory, COMPOSITION_FILE), source)
+  }
+  return root
+}
+
+async function harness(): Promise<Context> {
+  const presets = await createPresetRoot()
+  const runtime = new Context()
+  runtime.baseUrl = `${pathToFileURL(presets).href}/`
+  await runtime.plugin(Loader)
+  runtime.loader.builtins.include = Include
+  runtime.loader.builtins.group = Group
+  await runtime.plugin(LlmRuntime)
+  await runtime.plugin(SessionStore)
+  await runtime.plugin(SystemPrompt, { persona: '' })
+  await runtime.plugin(ToolRuntime)
+  await runtime.plugin(AgentRegistry)
+  await runtime.plugin(AgentLoop, { agents: [] })
+  await runtime.plugin(CommandRuntime)
+  await runtime.plugin(TokenMeter)
+  await runtime.plugin(MemorySettings)
+  await runtime.plugin(AgentPresets, {
+    default: 'standard',
+    roots: [{ path: presets, trust: 'system' }],
+    includeUserRoot: false,
+  })
+  await runtime.plugin({
+    apply: (selectorCtx) => {
+      apply(selectorCtx, { presetOverlay: true })
+    },
+  }).await()
+  ctx = runtime
+  return runtime
+}
+
+async function agentOn(runtime: Context, sessionId: string, preset: string): Promise<Agent> {
+  const handle = await runtime.agents.create({
+    sessionId: SessionId(sessionId),
+    setup: async agentCtx => void await runtime.agentPresets.mount(agentCtx, preset),
+  })
+  return handle.agent
+}
+
+function hasCompressionRetrieve(runtime: Context, agent: Agent): boolean {
+  return runtime.tools.get('context_compression_retrieve', scopeOf(agent.ctx)) !== undefined
+}
+
+function hasCompactCommand(runtime: Context, agent: Agent): boolean {
+  return runtime.commands.list(agent).some(command => command.name === 'compact')
+}
+
+function expectCompleteCompressionStack(runtime: Context, agent: Agent): void {
+  expect(runtime.agentPresets.serviceFor(agent, 'toolResultPruner')).toBeDefined()
+  expect(runtime.agentPresets.serviceFor(agent, 'compaction')).toBeDefined()
+  expect(hasCompressionRetrieve(runtime, agent)).toBe(true)
+  expect(hasCompactCommand(runtime, agent)).toBe(true)
+}
+
+function expectNoCompressionStack(runtime: Context, agent: Agent): void {
+  expect(runtime.agentPresets.serviceFor(agent, 'toolResultPruner')).toBeUndefined()
+  expect(runtime.agentPresets.serviceFor(agent, 'compaction')).toBeUndefined()
+  expect(hasCompressionRetrieve(runtime, agent)).toBe(false)
+  expect(hasCompactCommand(runtime, agent)).toBe(false)
+}
+
+describe('standalone selector Bundle through the real preset Loader', () => {
+  it('mounts the complete stack without changing source preset authoring', async () => {
+    const runtime = await harness()
+    const source = await runtime.agentPresets.resolve('standard')
+    const sourceText = await runtime.agentPresets.read('standard')
+
+    const agent = await agentOn(runtime, 'selector-loader-standard', 'standard')
+
+    expectCompleteCompressionStack(runtime, agent)
+    expect((await runtime.agentPresets.resolve('standard')).path).toBe(source.path)
+    expect(await runtime.agentPresets.read('standard')).toBe(sourceText)
+    expect(sourceText).not.toContain('tool-result-pruner')
+  })
+
+  it('keeps compression across preset changes and excludes only exact Minimal', async () => {
+    const runtime = await harness()
+    const agent = await agentOn(runtime, 'selector-loader-switch', 'standard')
+    expectCompleteCompressionStack(runtime, agent)
+
+    await runtime.agentPresets.recompose(agent.ctx, 'minimal')
+    expectNoCompressionStack(runtime, agent)
+
+    // `custom` deliberately contains the same source rows as Minimal. Its id,
+    // not its copied contents, decides the one documented exception.
+    await runtime.agentPresets.recompose(agent.ctx, 'custom')
+    expectCompleteCompressionStack(runtime, agent)
+  })
+
+  it('gives a child the parent\'s exact compression service instances', async () => {
+    const runtime = await harness()
+    const parent = await agentOn(runtime, 'selector-loader-parent', 'standard')
+    const childHandle = await runtime.agents.create({
+      sessionId: SessionId('selector-loader-child'),
+      setup: childCtx => void runtime.agentPresets.composeFrom(childCtx, parent.ctx),
+    })
+    const child = childHandle.agent
+
+    const parentPruner = runtime.agentPresets.serviceFor(parent, 'toolResultPruner')
+    const childPruner = runtime.agentPresets.serviceFor(child, 'toolResultPruner')
+    const parentCompaction = runtime.agentPresets.serviceFor(parent, 'compaction')
+    const childCompaction = runtime.agentPresets.serviceFor(child, 'compaction')
+    expect(parentPruner).toBeDefined()
+    expect(parentCompaction).toBeDefined()
+    expect(Object.is(
+      (childPruner as Traceable)[CORDIS_ORIGINAL],
+      (parentPruner as Traceable)[CORDIS_ORIGINAL],
+    )).toBe(true)
+    expect(Object.is(
+      (childCompaction as Traceable)[CORDIS_ORIGINAL],
+      (parentCompaction as Traceable)[CORDIS_ORIGINAL],
+    )).toBe(true)
+    expect(hasCompressionRetrieve(runtime, child)).toBe(true)
+    expect(hasCompactCommand(runtime, child)).toBe(true)
+  })
+
+  it('publishes the daily Custom defaults from the plugin-owned settings row', async () => {
+    const runtime = await harness()
+    const namespace = settingsNamespace('context-compression')
+    const settings = runtime.settings.get(namespace) as CustomSettings
+
+    expect(settings.custom.history.trigger).toBe(500_000)
+    expect(settings.custom.tailTrim).toEqual({ enabled: false, trigger: 700_000 })
+  })
+})

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

@@ -0,0 +1,243 @@
+import { access, mkdir, mkdtemp, readFile, readdir, rm, stat, utimes, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import { load } from 'js-yaml'
+import type { AgentPreset } from '@deepseek-ai/dsh-agent-presets'
+import {
+  decorateAgentPresets,
+  type CompressionModulePaths,
+  type OverlayableAgentPresets,
+  type PresetOverlayMetadataIo,
+} from '../src/preset-overlay.ts'
+
+const MODULES: CompressionModulePaths = {
+  compactionBasic: '/opt/context-selector/compaction-basic.js',
+  commandCompact: '/opt/context-selector/command-compact.js',
+  toolResultPruner: '/opt/context-selector/tool-result-pruner.js',
+}
+
+const roots: string[] = []
+
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map(root => rm(root, { recursive: true, force: true })))
+})
+
+async function fixture(): Promise<{
+  root: string
+  standard: AgentPreset
+  minimal: AgentPreset
+}> {
+  const root = await mkdtemp(join(tmpdir(), 'dsh-selector-overlay-test-'))
+  roots.push(root)
+  const standardPath = join(root, 'standard', 'agent.cordis.yml')
+  const minimalPath = join(root, 'minimal', 'agent.cordis.yml')
+  await mkdir(dirname(standardPath), { recursive: true })
+  await mkdir(dirname(minimalPath), { recursive: true })
+  await writeFile(standardPath, [
+    '- id: persona',
+    "  name: '/opt/preset/persona.js'",
+    '- id: tool-context-retrieve',
+    "  name: '@deepseek-ai/dsh-tool-context-retrieve'",
+    '- id: compaction',
+    '  name: cordis:group',
+    '  group: true',
+    '  isolate:',
+    '    compaction: true',
+    '    toolResultPruner: true',
+    '  config:',
+    '    - id: compaction-basic',
+    "      name: '@deepseek-ai/dsh-compaction-basic'",
+    '    - id: command-compact',
+    "      name: '@deepseek-ai/dsh-command-compact'",
+    '    - id: tool-result-pruner',
+    "      name: '@deepseek-ai/dsh-compaction-tool-result-pruner'",
+    '',
+  ].join('\n'))
+  await writeFile(minimalPath, "- id: persona\n  name: '/opt/preset/minimal.js'\n")
+  return {
+    root,
+    standard: { id: 'standard', trust: 'system', path: standardPath },
+    minimal: { id: 'minimal', trust: 'system', path: minimalPath },
+  }
+}
+
+class FakeAgentPresets implements OverlayableAgentPresets {
+  constructor(private readonly presets: ReadonlyMap<string, AgentPreset>) {}
+
+  async resolve(id = 'standard'): Promise<AgentPreset> {
+    const preset = this.presets.get(id)
+    if (preset === undefined) throw new Error(`unknown preset: ${id}`)
+    return preset
+  }
+
+  async mount(_agentCtx: unknown, id?: string): Promise<AgentPreset> {
+    return await this.resolve(id)
+  }
+
+  async recompose(_agentCtx: unknown, id: string): Promise<AgentPreset> {
+    return await this.resolve(id)
+  }
+
+  async standingKeyFor(id?: string): Promise<string> {
+    return (await this.resolve(id)).path
+  }
+
+  async read(id: string): Promise<string> {
+    return await readFile((await this.resolve(id)).path, 'utf8')
+  }
+}
+
+function rowsAt(text: string): Array<Record<string, unknown>> {
+  const rows = load(text)
+  if (!Array.isArray(rows)) throw new TypeError('expected entry list')
+  return rows as Array<Record<string, unknown>>
+}
+
+function flatten(rows: Array<Record<string, unknown>>): Array<Record<string, unknown>> {
+  return rows.flatMap((row) => {
+    const nested = row.group === true && Array.isArray(row.config)
+      ? flatten(row.config as Array<Record<string, unknown>>)
+      : []
+    return [row, ...nested]
+  })
+}
+
+describe('plugin-owned preset overlay decorator', () => {
+  it('enhances only composition operations while authoring sees the source preset', async () => {
+    const { root, standard, minimal } = await fixture()
+    const presets = new FakeAgentPresets(new Map([
+      ['standard', standard],
+      ['minimal', minimal],
+    ]))
+    const installation = decorateAgentPresets(presets, {
+      modules: MODULES,
+      excludedPresetIds: ['minimal'],
+      tempParent: root,
+    })
+
+    expect((await presets.resolve('standard')).path).toBe(standard.path)
+    expect(await presets.read('standard')).toBe(await readFile(standard.path, 'utf8'))
+
+    const mounted = await presets.mount({}, 'standard')
+    expect(mounted.path).not.toBe(standard.path)
+    expect((await presets.recompose({}, 'standard')).path).toBe(mounted.path)
+    expect(await presets.standingKeyFor('standard')).toBe(mounted.path)
+    expect((await presets.mount({}, 'minimal')).path).toBe(minimal.path)
+    expect((await presets.resolve('standard')).path).toBe(standard.path)
+
+    const all = flatten(rowsAt(await readFile(mounted.path, 'utf8')))
+    expect(all.filter(row => row.id === 'tool-context-retrieve')).toHaveLength(1)
+    expect(all.filter(row => row.id === 'compaction')).toHaveLength(1)
+    expect(all.filter(row => row.id === 'compaction-basic')).toHaveLength(1)
+    expect(all.filter(row => row.id === 'command-compact')).toHaveLength(1)
+    expect(all.filter(row => row.id === 'tool-result-pruner')).toHaveLength(1)
+    expect(all.find(row => row.id === 'tool-context-retrieve')?.name)
+      .toBe('@deepseek-ai/dsh-tool-context-retrieve')
+    expect(all.find(row => row.id === 'tool-result-pruner')?.name).toBe(MODULES.toolResultPruner)
+
+    await installation.dispose()
+    expect((await presets.mount({}, 'standard')).path).toBe(standard.path)
+    await expect(access(dirname(mounted.path))).rejects.toThrow()
+  })
+
+  it('keeps direct concurrent resolve outside the operation-local overlay', async () => {
+    const { root, standard } = await fixture()
+    const presets = new FakeAgentPresets(new Map([['standard', standard]]))
+    const installation = decorateAgentPresets(presets, { modules: MODULES, tempParent: root })
+
+    const [mounted, resolved] = await Promise.all([
+      presets.mount({}, 'standard'),
+      presets.resolve('standard'),
+    ])
+
+    expect(mounted.path).not.toBe(standard.path)
+    expect(resolved.path).toBe(standard.path)
+    await installation.dispose()
+  })
+
+  it('uses owner-only files and starts a new generation after source content changes', async () => {
+    const { root, standard } = await fixture()
+    const presets = new FakeAgentPresets(new Map([['standard', standard]]))
+    const installation = decorateAgentPresets(presets, { modules: MODULES, tempParent: root })
+
+    const first = await presets.mount({}, 'standard')
+    const same = await presets.mount({}, 'standard')
+    expect(same.path).toBe(first.path)
+    expect((await stat(dirname(first.path))).mode & 0o777).toBe(0o700)
+    expect((await stat(first.path)).mode & 0o777).toBe(0o600)
+
+    await writeFile(standard.path, `${await readFile(standard.path, 'utf8')}\n- id: later\n  name: '/opt/preset/later.js'\n`)
+    const changed = await presets.mount({}, 'standard')
+    expect(changed.path).not.toBe(first.path)
+    expect(await readFile(changed.path, 'utf8')).toContain('id: later')
+
+    await installation.dispose()
+  })
+
+  it('shares one decoration across duplicate Bundle and built-in loads', async () => {
+    const { root, standard } = await fixture()
+    const presets = new FakeAgentPresets(new Map([['standard', standard]]))
+    const first = decorateAgentPresets(presets, { modules: MODULES, tempParent: root })
+    const second = decorateAgentPresets(presets, { modules: MODULES, tempParent: root })
+
+    const mounted = await presets.mount({}, 'standard')
+    const all = flatten(rowsAt(await readFile(mounted.path, 'utf8')))
+    expect(all.filter(row => row.id === 'compaction')).toHaveLength(1)
+    expect(all.filter(row => row.id === 'tool-result-pruner')).toHaveLength(1)
+
+    await first.dispose()
+    expect((await presets.mount({}, 'standard')).path).toBe(mounted.path)
+
+    await second.dispose()
+    expect((await presets.mount({}, 'standard')).path).toBe(standard.path)
+  })
+
+  it('does not share one decoration across different metadata policies', async () => {
+    const { root, standard } = await fixture()
+    const presets = new FakeAgentPresets(new Map([['standard', standard]]))
+    const metadataIo = (): PresetOverlayMetadataIo => ({
+      async setTimes(path, stamp) {
+        await utimes(path, stamp, stamp)
+      },
+      async read(path) {
+        const observed = await stat(path)
+        return { mtimeMs: observed.mtimeMs, size: observed.size }
+      },
+    })
+    const first = decorateAgentPresets(presets, {
+      modules: MODULES,
+      tempParent: root,
+      metadataIo: metadataIo(),
+    })
+
+    expect(() => decorateAgentPresets(presets, {
+      modules: MODULES,
+      tempParent: root,
+      metadataIo: metadataIo(),
+    })).toThrow(/different compression overlay/u)
+
+    await first.dispose()
+  })
+
+  it('removes staging files when metadata preparation fails before publish', async () => {
+    const { root, standard } = await fixture()
+    const presets = new FakeAgentPresets(new Map([['standard', standard]]))
+    const installation = decorateAgentPresets(presets, {
+      modules: MODULES,
+      tempParent: root,
+      metadataIo: {
+        setTimes: () => Promise.reject(new Error('synthetic metadata failure')),
+        read: () => Promise.reject(new Error('metadata read must not run')),
+      },
+    })
+
+    await expect(presets.mount({}, 'standard')).rejects.toThrow(/synthetic metadata failure/u)
+    const generatedDirectories = (await readdir(root, { withFileTypes: true }))
+      .filter(entry => entry.isDirectory() && entry.name.startsWith('dsh-context-compression-presets-'))
+    expect(generatedDirectories).toHaveLength(1)
+    expect(await readdir(join(root, generatedDirectories[0]!.name))).toEqual([])
+
+    await installation.dispose()
+  })
+})