dsh-context-compression-improved 0.1.1 → 0.2.0

package/packages/selector/src/index.ts

@@ -0,0 +1,327 @@
+/** Host owner of the context-compression preference consumed by the browser selector. */
+
+import type { Context } from '@deepseek-ai/cordis'
+import z from '@deepseek-ai/schemastery'
+import {
+  type SettingsScope,
+  type default as SettingsService,
+} from '@deepseek-ai/dsh-settings'
+import {
+  CONTEXT_COMPRESSION_SETTINGS_NAMESPACE,
+  ContextCompressionSettingsSchema,
+} from './runtime/config.ts'
+import { buildEstimatorCatalog, type EstimatorCatalogDeps } from './estimator-catalog.ts'
+import {
+  decorateAgentPresets,
+  resolveCompressionModulePaths,
+} from './preset-overlay.ts'
+
+// 0.1.1/0.1.2 客户端 API 前缀是 /endpoint，0.1.5 起改为 /api —— 两条绝对路径都
+// 注册（各自的 (kind, path) 表项），一份处理器服务两个前缀。
+const ESTIMATOR_CATALOG_ROUTES = [
+  '/endpoint/dsh-context-compression-improved/estimator-catalog',
+  '/api/dsh-context-compression-improved/estimator-catalog',
+] as const
+
+/**
+ * The one service the catalog route actually needs. `llm` and
+ * `agentDefaultModel` are payload enrichment the handler resolves per request,
+ * never reasons to withhold the route.
+ */
+const ESTIMATOR_CATALOG_ROUTE_DEPS: readonly ['webServer'] = ['webServer']
+
+/** Runtime detection of the host web server (same pattern as dsh-perm-gate). */
+interface WebServerLike {
+  register: (spec: {
+    kind: 'exact'
+    path: string
+    handler: (req: unknown, res: unknown) => void
+  }) => unknown
+}
+
+/** The estimator-side service the catalog handler enriches its response with. */
+interface AgentDefaultModelLike {
+  /** Current host model-group selection, when the service exposes one. */
+  currentSelection?: () => { provider?: unknown, model?: unknown } | undefined
+}
+
+function asWebServer(value: unknown): WebServerLike | undefined {
+  const register = (value as { register?: unknown } | undefined)?.register
+  if (typeof register !== 'function') return undefined
+  // Hand back the service itself -- never a wrapper re-exporting `register`.
+  // The host reads its route tables off `this` (`this.exact` / `this.prefixes`),
+  // so a detached call makes `this` the wrapper and throws "Cannot read
+  // properties of undefined (reading 'has')" inside the host, after which the
+  // route is simply absent and the client sees a bare 404.
+  return value as WebServerLike
+}
+
+/**
+ * Serve `GET /api/dsh-context-compression-improved/estimator-catalog` — the
+ * settings card's host-route dropdowns (live provider/model groups from the DSH
+ * `llm` service plus the effective selection). This lives on the top-level
+ * plugin context, NOT inside the isolated toolResultPruner service.
+ *
+ * (The isolation reason this placement was originally justified with — "a route
+ * registered there can never reach `webServer` across the isolation boundary" —
+ * is **unverified**: no `@deepseek-ai` package calls `.isolate(`, so there is no
+ * boundary to cross here. Top-level placement is still the right choice, for a
+ * reason that needs no framework rule: the route is host-wide, not
+ * per-pruner-instance. Don't promote the isolation wording into a rule.)
+ *
+ * The route gates on `webServer` **alone**. `llm` and `agentDefaultModel` only
+ * enrich the response and are resolved per request, so listing them here would
+ * let an estimator-side service the handler never needs keep the route
+ * unregistered. That failure is silent by construction — an unsatisfied
+ * `ctx.inject` callback never runs, so the plugin simply has no HTTP API and
+ * every request falls through to the host 404.
+ *
+ * Two channels cover the two arrival orders: a direct lookup catches a
+ * `webServer` that is already active when the plugin loads, and `ctx.inject`
+ * catches one that activates later. Both funnel into a single guarded
+ * registration, because a late-arriving service must not re-register a
+ * `(kind, path)` the host treats as a composition-contract violation.
+ */
+function registerEstimatorCatalogRoute(ctx: Context): void {
+  const readService = (name: string): unknown => {
+    try {
+      return (ctx as unknown as { get: (service: string) => unknown }).get(name)
+    } catch {
+      return undefined
+    }
+  }
+  // `console`, not `ctx.logger`: measured on the 0.1.2 host, the cordis logger
+  // surfaces no plugin output in the `dsh web` terminal at all — a full boot
+  // produced zero plugin log lines while the process itself stayed chatty — so
+  // a lifecycle diagnostic published there is unobservable. `dsh-perm-gate`
+  // uses `console.warn` for the same message class on the same host.
+  const log = (level: 'info' | 'warn', message: string, ...args: unknown[]): void => {
+    console[level](message, ...args)
+  }
+
+  let registered = false
+  const register = (webServer: WebServerLike, channel: 'direct' | 'inject'): void => {
+    if (registered) return
+    const handler = (_req: unknown, res: unknown): void => {
+      const resTyped = res as {
+        writeHead: (code: number, headers?: Record<string, string>) => void
+        end: (body?: string) => void
+      }
+      if (typeof resTyped?.writeHead !== 'function' || typeof resTyped?.end !== 'function') return
+      const llm = readService('llm')
+      const defaults = readService('agentDefaultModel') as AgentDefaultModelLike | undefined
+      const deps: EstimatorCatalogDeps = {
+        ...(llm === undefined
+          ? {}
+          : { llm: llm as NonNullable<EstimatorCatalogDeps['llm']> }),
+        ...(typeof defaults?.currentSelection === 'function'
+          ? { currentSelection: () => defaults.currentSelection?.() }
+          : {}),
+      }
+      buildEstimatorCatalog(deps).then(
+        catalog => {
+          resTyped.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-cache' })
+          resTyped.end(JSON.stringify({ ok: true, ...catalog }))
+        },
+        (error: unknown) => {
+          resTyped.writeHead(500, { 'content-type': 'application/json; charset=utf-8' })
+          resTyped.end(JSON.stringify({ ok: false, error: String((error as Error)?.message ?? error) }))
+        },
+      )
+    }
+    try {
+      const disposers = ESTIMATOR_CATALOG_ROUTES
+        .map(path => webServer.register({ kind: 'exact', path, handler }))
+        .filter((off): off is () => void => typeof off === 'function')
+      registered = true
+      ctx.effect(
+        () => () => { for (const off of disposers) off() },
+        'contextCompressionSelector.estimator-catalog route',
+      )
+      log('info', 'context-compression estimator catalog route registered (%s): %s', channel, ESTIMATOR_CATALOG_ROUTES.join(', '))
+    } catch (error) {
+      log('warn', 'context-compression estimator catalog route registration failed (%s): %o', channel, error)
+    }
+  }
+
+  const active = asWebServer(readService('webServer'))
+  if (active !== undefined) {
+    register(active, 'direct')
+    if (registered) return
+  }
+
+  ctx.inject([...ESTIMATOR_CATALOG_ROUTE_DEPS], (injected) => {
+    const webServer = asWebServer((injected as { webServer?: unknown }).webServer)
+    if (webServer === undefined) {
+      log('warn', 'context-compression webServer exposes no register() — estimator catalog route not registered')
+      return
+    }
+    register(webServer, 'inject')
+  })
+
+  log('warn', 'context-compression webServer not active yet — estimator catalog route pending: %s', ESTIMATOR_CATALOG_ROUTES.join(', '))
+}
+
+// Harness 0.1.1 exposed a namespace-branding helper; 0.1.2 validates the
+// same public literal at SettingsProvider.register/get instead.
+const CONTEXT_COMPRESSION_NAMESPACE = CONTEXT_COMPRESSION_SETTINGS_NAMESPACE as never
+
+/** Shared state forwarded through every Cordis proxy of one settings service. */
+interface SharedSettingsRegistration {
+  /** Plugin fibers currently leasing the namespace. */
+  readonly owners: Set<SettingsOwner>
+  /** Owner whose fiber currently carries settings.register's native effect. */
+  registrationOwner: SettingsOwner
+  /** Current owner scope; replaced without changing the stored document. */
+  scope: SettingsScope<unknown>
+}
+
+/** One selector Host row able to own the registration effect. */
+interface SettingsOwner {
+  /** Traceable service proxy binding register() to this row's fiber. */
+  readonly settings: SettingsService
+}
+
+/** Symbol properties reach the shared service target through Cordis proxies. */
+const SHARED_SETTINGS = Symbol.for(
+  'dsh-context-compression-improved/settings-registration',
+)
+
+type SettingsCarrier = SettingsService & {
+  [SHARED_SETTINGS]?: SharedSettingsRegistration
+}
+
+/** Standalone Bundle behavior; the settings/UI owner remains safe when false. */
+export interface Config {
+  /** Add the canonical compression stack to every non-Minimal preset. */
+  presetOverlay?: boolean
+  /**
+   * Own the estimator catalog HTTP route. Set on the Loader row that declares
+   * `inject: [webServer]`.
+   *
+   * **Measured, and it contradicts the note this field was introduced with.**
+   * The original justification — "registering a route authorizes against the
+   * calling fiber, and a fiber that has not declared `webServer` cannot reach
+   * it, not even through `ctx.inject` or `ctx.get`" — is wrong on both halves:
+   * the host's `register` performs no authorization at all (it reads
+   * `this.exact` / `this.prefixes` and throws only on a duplicate
+   * `(kind, path)`), and `ctx.get(name, strict)` checks only that the providing
+   * fiber is active (`state === 2`), never the caller's `inject` list. The one
+   * inject-gated path is the `ctx.webServer` **property** access, which this
+   * plugin never uses: `registerEstimatorCatalogRoute` uses `ctx.get` plus its
+   * own `ctx.inject(['webServer'], …)`.
+   *
+   * So the row-level `inject` is **not load-bearing**; it is kept as
+   * belt-and-braces so the route row stays inactive until `webServer` exists,
+   * and the flag keeps the route off standalone Bundle rows on profiles that
+   * have no web server. The internal two-channel registration is what actually
+   * covers both arrival orders. Do not cite this comment as a rule to the
+   * 0.1.5 replay — cite the host source.
+   */
+  estimatorCatalogRoute?: boolean
+}
+
+/** Loader validation for the standalone Bundle opt-in. */
+export const Config: z<Config> = z.object({
+  presetOverlay: z.boolean().default(false),
+  estimatorCatalogRoute: z.boolean().default(false),
+})
+
+/** Register the persisted default read by the currently mounted root pruner. */
+export function apply(ctx: Context, config: Config = {}): void {
+  // Measured on the 0.1.2 host: a plugin-load failure surfaces only through the
+  // cordis logger, which prints nothing in the `dsh web` terminal — so a throw
+  // here is completely invisible and looks exactly like a plugin that loaded
+  // and quietly did nothing. Report it to a sink the host shows, then re-throw
+  // unchanged: behaviour is untouched, only observability is restored.
+  try {
+    ctx.inject(['settings'], (settingsCtx) => {
+      acquireSettingsRegistration(settingsCtx)
+    })
+
+    if (config.estimatorCatalogRoute === true) registerEstimatorCatalogRoute(ctx)
+
+    if (config.presetOverlay !== true) return
+
+    ctx.inject(['agentPresets'], (presetsCtx) => {
+      const installation = decorateAgentPresets(
+        presetsCtx.agentPresets,
+        {
+          modules: resolveCompressionModulePaths(),
+          excludedPresetIds: ['minimal'],
+          autoCompactThresholdPercent: () => resolveAutoCompactThresholdPercent(presetsCtx),
+        },
+      )
+      presetsCtx.effect(() => () => installation.dispose(), 'contextCompressionSelector.agentPresets()')
+    })
+  } catch (error) {
+    console.error('context-compression apply() failed:', error)
+    throw error
+  }
+}
+
+/**
+ * Read the current Auto Compact threshold ratio at composition time. Settings
+ * values are revalidated here, and any unreadable value falls back to the 80%
+ * default rather than blocking preset composition.
+ */
+function resolveAutoCompactThresholdPercent(presetsCtx: Context): number {
+  const raw = presetsCtx.get('settings')?.get(CONTEXT_COMPRESSION_NAMESPACE)
+  try {
+    const parsed = ContextCompressionSettingsSchema(structuredClone(raw) as never)
+    return parsed.autoCompact.thresholdPercent
+  } catch {
+    return 80
+  }
+}
+
+/**
+ * Lease one native settings registration across duplicate Host rows.
+ *
+ * The lease effect is intentionally registered before settings.register().
+ * Cordis disposes effects in reverse order, so the native registration first
+ * releases the namespace; this disposer can then transfer it to another live
+ * owner without a duplicate-registration window.
+ */
+function acquireSettingsRegistration(ctx: Context): void {
+  const settings = ctx.settings as SettingsCarrier
+  const owner: SettingsOwner = { settings }
+  let shared = settings[SHARED_SETTINGS]
+  if (shared === undefined) {
+    shared = {
+      owners: new Set(),
+      registrationOwner: owner,
+      scope: undefined as unknown as SettingsScope<unknown>,
+    }
+    Object.defineProperty(settings, SHARED_SETTINGS, {
+      configurable: true,
+      enumerable: false,
+      writable: false,
+      value: shared,
+    })
+  }
+  shared.owners.add(owner)
+  const state = shared
+
+  ctx.effect(() => () => {
+    state.owners.delete(owner)
+    if (state.registrationOwner === owner && state.owners.size > 0) {
+      const next = state.owners.values().next().value as SettingsOwner
+      state.registrationOwner = next
+      state.scope = next.settings.register(
+        CONTEXT_COMPRESSION_NAMESPACE,
+        ContextCompressionSettingsSchema,
+      )
+    }
+    if (state.owners.size === 0 && settings[SHARED_SETTINGS] === state) {
+      Reflect.deleteProperty(settings, SHARED_SETTINGS)
+    }
+  }, 'contextCompressionSelector.settingsLease()')
+
+  if (state.owners.size === 1) {
+    state.scope = settings.register(
+      CONTEXT_COMPRESSION_NAMESPACE,
+      ContextCompressionSettingsSchema,
+    )
+  }
+}

package/packages/selector/src/invariant.ts

@@ -0,0 +1,113 @@
+/** Package-owned invariants for standard-prune compression publications. */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type { InvariantFailure, InvariantInstaller } from '@deepseek-ai/dsh-invariants'
+import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
+import type {} from '@deepseek-ai/dsh-compaction'
+import { validatePublishedTailTrim } from './runtime/tail-trim.ts'
+import { sessionEvents } from './runtime/session-events.ts'
+
+const PACKAGE_NAME = 'dsh-context-compression-improved-runtime'
+
+/** Cordis companion plugin name. */
+export const name = 'context-compression-selector-runtime-invariant'
+/** Services required before the companion can register. */
+export const inject = ['invariants']
+
+type PruneEvent = SessionEvent<'compaction/prune'>
+
+/** Whether the next event claims the unresolved prune's replacement range. */
+function resemblesCompanion(prune: PruneEvent, event: SessionEvent): boolean {
+  if ((event.type !== 'tool/result' && event.type !== 'user/message')
+    || typeof event.surfaceOp !== 'object') return false
+  const sources = new Set(event.sourceEventSeqs ?? [])
+  return (event.surfaceOp.start === prune.data.shadowedRange.start
+      && event.surfaceOp.end === prune.data.shadowedRange.end)
+    || prune.data.shadowedSeqs.some(seq => sources.has(seq))
+}
+
+/** Validate one standard prune's immediately adjacent surface replacement. */
+function validateCompanion(
+  session: Session,
+  prune: PruneEvent,
+  event: SessionEvent,
+  fail: InvariantFailure,
+): void {
+  if ((event.type !== 'tool/result' && event.type !== 'user/message')
+    || typeof event.surfaceOp !== 'object') {
+    fail(`compaction/prune at seq ${prune.seq} must be immediately followed by a replacement surface event`)
+  }
+  const { shadowedRange, shadowedSeqs } = prune.data
+  if (shadowedSeqs.length === 0
+    || shadowedSeqs[0] !== shadowedRange.start
+    || shadowedSeqs.at(-1) !== shadowedRange.end) {
+    fail(`compaction/prune at seq ${prune.seq} has a shadowed range inconsistent with shadowedSeqs`)
+  }
+  if (event.surfaceOp.start !== shadowedRange.start || event.surfaceOp.end !== shadowedRange.end) {
+    fail(`replacement at seq ${event.seq} does not replace compaction/prune range ${shadowedRange.start}-${shadowedRange.end}`)
+  }
+  const sources = new Set(event.sourceEventSeqs ?? [])
+  const missing = shadowedSeqs.filter(seq => !sources.has(seq))
+  if (missing.length > 0) {
+    fail(`replacement at seq ${event.seq} omits shadowed source seqs ${missing.join(', ')}`)
+  }
+  if (event.type === 'user/message' && validatePublishedTailTrim(session, prune.seq) === null) {
+    fail(`TailTrim publication at seq ${prune.seq} is invalid`)
+  }
+}
+
+/** Validate a replayed log and return its only legal unresolved tail. */
+function seedPending(session: Session, fail: InvariantFailure): PruneEvent | undefined {
+  let pending: PruneEvent | undefined
+  for (const event of sessionEvents(session)) {
+    if (pending !== undefined) {
+      // A prune whose synchronous companion never committed is an inert,
+      // aborted publication. It must not brick a restored Session. A surface
+      // replacement that claims the prune is still validated strictly.
+      if (resemblesCompanion(pending, event)) validateCompanion(session, pending, event, fail)
+      pending = undefined
+    }
+    if (event.type === 'compaction/prune') pending = event
+  }
+  return pending
+}
+
+/** Install adjacency checks with pre-commit staging. */
+const install: InvariantInstaller = Object.assign((ctx: Context, fail: InvariantFailure) => {
+  const pending = new WeakMap<Session, PruneEvent | undefined>()
+  const staged = new WeakMap<SessionEvent, { session: Session; next: PruneEvent | undefined }>()
+  const seed = (session: Session): void => { pending.set(session, seedPending(session, fail)) }
+  const current = (session: Session): PruneEvent | undefined => {
+    if (!pending.has(session)) seed(session)
+    return pending.get(session)
+  }
+
+  for (const session of ctx.sessions.list()) seed(session)
+  ctx.on('session/created', seed, { global: true })
+
+  ctx.on('internal/dispatch', (_mode, eventName, args) => {
+    if (eventName !== 'session/event') return
+    const [session, event] = args as [Session, SessionEvent]
+    const open = current(session)
+    if (open !== undefined && resemblesCompanion(open, event)) {
+      validateCompanion(session, open, event, fail)
+    }
+    staged.set(event, {
+      session,
+      next: event.type === 'compaction/prune' ? event : undefined,
+    })
+  }, { global: true })
+
+  ctx.on('session/event', (session, event) => {
+    const candidate = staged.get(event)
+    if (candidate === undefined || candidate.session !== session) {
+      return fail('session/event reached publication without matching pre-commit validation')
+    }
+    staged.delete(event)
+    pending.set(session, candidate.next)
+  }, { global: true })
+}, { inject: ['sessions'] })
+
+/** Register this package's invariant companion. */
+export const apply = (ctx: Context): Promise<() => void> =>
+  Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install))