dsh-context-compression-improved 0.2.1 → 0.3.0

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

@@ -6,69 +6,82 @@ import type { CompressionSelectorInjected } from '../src/client/CompressionProfi
 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.
+ * The settings transport applies a `set` op AT its path, so the write path is
+ * asserted through the ops it submits: a whole-section write 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>
+type PathOp = { op: 'set', path: string[], value: unknown } | { op: 'unset', path: string[] }
+
+interface ScopeStub {
+  readonly writes: PathOp[][]
+  readonly snapshot: () => Record<string, unknown>
 }
 
-function createScopeStub(initial: ContextCompressionSettings, commit = true): {
-  scope: ScopeFace
-  writes: { field: string, value: unknown }[]
-  section: () => Record<string, unknown>
-  sectionOf: (key: string) => unknown
-} {
+/** Emulate the Host settings service: apply ops at their path, then bump the revision. */
+function createScopeStub(initial: ContextCompressionSettings, commit = true): ScopeStub {
   let revision = 1
   let value: Record<string, unknown> = structuredClone(initial) as unknown as Record<string, unknown>
-  const writes: { field: string, value: unknown }[] = []
+  const writes: PathOp[][] = []
   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()
+  const applyOps = (ops: readonly PathOp[]): void => {
+    for (const op of ops) {
+      const [head, ...rest] = op.path
+      if (head === undefined) continue
+      if (rest.length === 0) {
+        if (op.op === 'set') value = { ...value, [head]: op.value }
+        else delete value[head]
+        continue
       }
-      return Promise.resolve()
-    },
+      const child = { ...(value[head] as Record<string, unknown> | undefined) }
+      const leaf = rest[rest.length - 1] as string
+      if (op.op === 'set') child[leaf] = op.value
+      else delete child[leaf]
+      value = { ...value, [head]: child }
+    }
+    revision += 1
+    for (const listener of listeners) listener()
   }
   return {
-    scope,
     writes,
-    section: () => value,
-    sectionOf: (key: string) => value[key],
-  }
+    snapshot: () => value,
+    // The scope face the injection factory binds.
+    scope: {
+      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) => {
+        const ops: PathOp[] = [{ op: 'set', path: [field], value: fieldValue }]
+        writes.push(ops)
+        applyOps(ops)
+        return Promise.resolve()
+      },
+      unset: (field: string) => {
+        const ops: PathOp[] = [{ op: 'unset', path: [field] }]
+        writes.push(ops)
+        applyOps(ops)
+        return Promise.resolve()
+      },
+      mutate: (ops: readonly PathOp[]) => {
+        writes.push([...ops])
+        // A refused or lost write changes no document, so the revision the
+        // confirmation read fences on never moves.
+        if (commit) applyOps(ops)
+        return Promise.resolve()
+      },
+    },
+  } as ScopeStub & { scope: unknown }
 }
 
 const DEFAULT_CUSTOM = {
@@ -91,8 +104,8 @@ function bindInjected(
   commit = true,
 ): {
   injected: CompressionSelectorInjected
-  writes: { field: string, value: unknown }[]
-  sectionOf: (key: string) => unknown
+  writes: PathOp[][]
+  snapshot: () => Record<string, unknown>
 } {
   const settings: ContextCompressionSettings = {
     profile: 'tokenpilot-inspired',
@@ -104,9 +117,6 @@ function bindInjected(
   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()
@@ -117,54 +127,52 @@ function bindInjected(
         return () => {}
       },
     },
+    // apply consumes the services through their declarative-inject faces
+    // (ctx.locale / ctx.settingsScope), the same shape cordis binds on the host.
+    locale: { bind: () => (key: string) => key, register: () => {} },
+    settingsScope: { bind: () => (stub as unknown as { scope: unknown }).scope },
   }
   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 }
+  return { injected: factory(), writes: stub.writes, snapshot: stub.snapshot }
 }
 
-describe('presetOptions writes preserve sibling fields', () => {
+describe('presetOptions writes are path-addressed', () => {
   it('keeps the estimator channel when a provider is chosen afterwards', async () => {
-    const { injected, sectionOf } = bindInjected({ estimatorMode: 'host' })
+    const { injected, writes, snapshot } = 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',
-      },
-    }])
+    expect(snapshot()['presetOptions']).toEqual({ estimatorMode: 'host', estimatorProvider: 'local-35b' })
+    expect(writes).toEqual([[{ op: 'set', path: ['presetOptions', 'estimatorProvider'], value: 'local-35b' }]])
   })
 
-  it('keeps every unrelated override across successive edits', async () => {
-    const { injected, sectionOf } = bindInjected({
+  it('never replaces the whole section, so sibling overrides survive', async () => {
+    const { injected, writes, snapshot } = bindInjected({
       estimatorMode: 'direct',
+      estimatorBaseUrl: 'http://192.168.100.242:8200',
       dedupeToolResults: false,
       readState: false,
     })
     await injected.savePresetOptions({ estimatorModel: 'Qwen3.6-35B-A3B' })
     await injected.savePresetOptions({ estimatorProvider: 'local-35b' })
-    expect(sectionOf('presetOptions')).toEqual({
+    expect(snapshot()['presetOptions']).toEqual({
       estimatorMode: 'direct',
+      estimatorBaseUrl: 'http://192.168.100.242:8200',
       dedupeToolResults: false,
       readState: false,
       estimatorModel: 'Qwen3.6-35B-A3B',
       estimatorProvider: 'local-35b',
     })
+    for (const batch of writes) {
+      for (const op of batch) expect(op.path.length).toBe(2)
+    }
   })
 
   it('clears exactly the field a patch names with undefined', async () => {
-    const { injected, sectionOf } = bindInjected({ estimatorMode: 'direct', estimatorApiKey: 'sk-stored' })
+    const { injected, writes, snapshot } = bindInjected({ estimatorMode: 'direct', estimatorApiKey: 'sk-stored' })
     await injected.savePresetOptions({ estimatorApiKey: undefined })
-    expect(sectionOf('presetOptions')).toEqual({ estimatorMode: 'direct' })
+    expect(snapshot()['presetOptions']).toEqual({ estimatorMode: 'direct' })
+    expect(writes).toEqual([[{ op: 'unset', path: ['presetOptions', 'estimatorApiKey'] }]])
   })
 
   it('writes nothing when the patch already matches the stored section', async () => {

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

@@ -15,15 +15,18 @@ 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 SessionProjectionRegistry from '@deepseek-ai/dsh-session-projection'
 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'
 
+// 0.1.5 removed the settingsNamespace() wrapper; namespaces are validated at runtime.
+const nsBrand = (value: string): SettingsNamespace => value as unknown as SettingsNamespace
+
 const CORDIS_ORIGINAL = Symbol.for('cordis.original')
 type Traceable = { [CORDIS_ORIGINAL]?: unknown }
 
@@ -74,21 +77,23 @@ async function harness(): Promise<Context> {
   const presets = await createPresetRoot()
   const runtime = new Context()
   runtime.baseUrl = `${pathToFileURL(presets).href}/`
-  await runtime.plugin(Loader)
+  await runtime.plugin(Loader).await()
   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(LlmRuntime).await()
+  await runtime.plugin(SessionStore).await()
+  await runtime.plugin(SystemPrompt).await()
+  await runtime.plugin(ToolRuntime).await()
+  await runtime.plugin(AgentRegistry).await()
+  await runtime.plugin(AgentLoop).await()
+  await runtime.plugin(CommandRuntime).await()
+  await runtime.plugin(SessionProjectionRegistry).await()
+  await runtime.plugin(TokenMeter).await()
+  await runtime.plugin(MemorySettings).await()
   await runtime.plugin(AgentPresets, {
     default: 'standard',
     roots: [{ path: presets, trust: 'system' }],
+    includeShippedRoot: false,
     includeUserRoot: false,
   })
   await runtime.plugin({
@@ -187,7 +192,7 @@ describe('standalone selector Bundle through the real preset Loader', () => {
 
   it('publishes the daily Custom defaults from the plugin-owned settings row', async () => {
     const runtime = await harness()
-    const namespace = settingsNamespace('context-compression')
+    const namespace = nsBrand('context-compression')
     const settings = runtime.settings.get(namespace) as CustomSettings
 
     expect(settings.custom.history.trigger).toBe(500_000)

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

@@ -164,8 +164,11 @@ describe('plugin-owned preset overlay decorator', () => {
     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)
+    // Windows (NTFS) ignores POSIX permission bits: mode stays 0o666.
+    if (process.platform !== 'win32') {
+      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')

package/packages/selector/tests/profiles.client.spec.tsx

@@ -244,14 +244,14 @@ describe('context compression profiles', () => {
     },
   )
 
-  it('explains that Minimal keeps the selector effectively off without overwriting the saved profile', () => {
+  it('keeps the selector selectable under a Minimal preset: 0.1.5 no longer exposes agentPreset client-side, so availability cannot gate the UI', () => {
     const { state } = renderReady(
       vi.fn(() => Promise.resolve()), false, key => COPY[key] ?? key,
       { agentPreset: 'minimal' },
     )
 
-    expect(screen.getByText(/Minimal mode does not load context compression.*effectively off.*native behavior remains/)).not.toBeNull()
-    expect(screen.getByRole<HTMLButtonElement>('button', { name: /Context compression/ }).disabled).toBe(true)
+    expect(screen.queryByText(/Minimal mode does not load context compression.*effectively off.*native behavior remains/)).toBeNull()
+    expect(screen.getByRole<HTMLButtonElement>('button', { name: /Context compression/ }).disabled).toBe(false)
     expect(state.getSnapshot().value?.profile).toBe('native')
   })
 

package/packages/selector/tests/public/package-contract.client.spec.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { describe, expect, it } from 'vitest'
 
@@ -19,10 +19,34 @@ describe('standalone package contract', () => {
     expect(Object.keys(selector.peerDependencies ?? {})).not.toContain('dsh-context-compression-improved-runtime')
     expect(Object.keys(selector.peerDependencies ?? {})).not.toContain('@deepseek-ai/dsh-compaction-tool-result-pruner')
     expect(selector.peerDependencies?.['@deepseek-ai/dsh-compaction-basic'])
-      .toBe('>=0.1.1-rc.2 <0.2.0')
+      .toBe('>=0.1.5-rc.2 <0.2.0-0')
     expect(selector.peerDependencies?.['@deepseek-ai/dsh-command-compact'])
-      .toBe('>=0.1.1-rc.2 <0.2.0')
+      .toBe('>=0.1.5-rc.2 <0.2.0-0')
     expect(selector.publishConfig?.tag).toBe('latest')
+    expect(existsSync(resolve(root, '../runtime/package.json'))).toBe(false)
+  })
+
+  it('makes the repository root the one git install surface', () => {
+    const rootManifest = JSON.parse(readFileSync(resolve(root, '../package.json'), 'utf8')) as {
+      name: string
+      exports?: Record<string, unknown>
+      dependencies?: Record<string, string>
+      engines?: Record<string, string>
+      dsh?: { bundle?: { patch?: string }, client?: { inject?: string[] } }
+    }
+    expect(rootManifest.name).toBe('dsh-context-compression-improved')
+    for (const specifier of ['.', './invariant', './pruner', './client']) {
+      expect(rootManifest.exports?.[specifier]).toBeDefined()
+    }
+    expect(rootManifest.dependencies?.['@huggingface/tokenizers']).toBe('0.1.3')
+    expect(rootManifest.dependencies?.['js-yaml']).toBe('^4.3.2')
+    expect(rootManifest.dsh?.bundle?.patch).toBe('./packages/selector/cordis.patch.yml')
+    expect(rootManifest.dsh?.client?.inject).toEqual([
+      '@deepseek-ai/dsh-client-locale',
+      '@deepseek-ai/dsh-client-ui-slots',
+      '@deepseek-ai/dsh-client-ui-settings',
+    ])
+    expect(rootManifest.engines?.dsh).toBe('>=0.1.5-alpha.1 <0.2.0-0')
   })
 
   it('uses the community package in the one Bundle patch', () => {