dsh-context-compression-improved 0.4.0-beta.1 → 0.5.0

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

@@ -0,0 +1,103 @@
+/**
+ * Tool-source classification (R1/R2), narrowed to FOUR classes (tasks v2 G4):
+ * `read` / `shell` / `search` / `path-listing`, everything else `generic`.
+ *
+ * Form routing beats identity routing — most tools' results land through
+ * `read`/`cat` — so this layer exists to keep the OBSERVED misroutes out of
+ * the wrong reducers, not to add per-identity behavior:
+ * - `web_search` / `memory_search` are not content-search (findings §0)
+ * - `glob` is path listing, not search
+ * - `execute_sql` is not shell; `research` is not search (substring era bugs)
+ * - MCP output has no predictable identity (`mcp` token → generic, C8)
+ *
+ * Judgment order (C15): name whitelist → command hit → content fallback, and
+ * a hit at any earlier stage is never overridden by a later one.
+ */
+
+export type ToolClass = 'read' | 'shell' | 'search' | 'path-listing' | 'generic'
+
+/** task_11 (AD3): exact-token matching, no substring hits. */
+const TOKEN_SEPARATOR = /[-_/]+/
+
+/** Multi-token names that must match as a whole word, not as a token. */
+const READ_NAMES = new Set(['open_file'])
+const READ_TOKENS = new Set(['read', 'cat', 'view'])
+const SHELL_TOKENS = new Set(['shell', 'bash', 'pwsh', 'powershell', 'terminal', 'exec', 'command'])
+const SEARCH_TOKENS = new Set(['grep', 'rg', 'ripgrep'])
+const PATH_LISTING_TOKENS = new Set(['glob', 'tree', 'ls', 'fd', 'find'])
+
+const SEARCH_COMMAND_PATTERN = /(?:^|\s)(?:rg|grep|ripgrep)\s/
+const PATH_COMMAND_PATTERN = /(?:^|\s)(?:find|fd|ls|tree)\s/
+
+/** grep-style hit line: `path:line[:column][: content]`. */
+const PATH_LINE_CONTENT_PATTERN = /^(.*?):(\d+)(?::\d+)?(?::|\s+-\s+)(.*)$/
+
+/**
+ * Classify a tool result's source.
+ * @param name - raw tool name (case-insensitive).
+ * @param command - extracted command argument, '' when absent.
+ * @param text - result text; enables the C13/C14 content fallback for names
+ *   that no whitelist (and no command hit) claims.
+ * @returns the tool source class.
+ */
+export function classifyToolSource(name: string, command: string, text?: string): ToolClass {
+  const lowered = name.toLowerCase()
+  const tokens = lowered.split(TOKEN_SEPARATOR).filter(token => token !== '')
+  // C8: an `mcp` token means the output identity is arbitrary — generic first,
+  // before any content heuristic gets a vote.
+  if (tokens.includes('mcp')) return 'generic'
+  const byName = classifyByName(lowered, tokens)
+  if (byName !== 'generic') return byName
+  const byCommand = classifyByCommand(command)
+  if (byCommand !== 'generic') return byCommand
+  return text === undefined ? 'generic' : classifyByContent(text)
+}
+
+function classifyByName(lowered: string, tokens: readonly string[]): ToolClass {
+  if (READ_NAMES.has(lowered) || tokens.some(token => READ_TOKENS.has(token))) return 'read'
+  if (tokens.some(token => SHELL_TOKENS.has(token))) return 'shell'
+  if (tokens.some(token => SEARCH_TOKENS.has(token))) return 'search'
+  if (tokens.some(token => PATH_LISTING_TOKENS.has(token))) return 'path-listing'
+  return 'generic'
+}
+
+function classifyByCommand(command: string): ToolClass {
+  if (command === '') return 'generic'
+  if (SEARCH_COMMAND_PATTERN.test(command)) return 'search'
+  if (PATH_COMMAND_PATTERN.test(command)) return 'path-listing'
+  return 'generic'
+}
+
+/** A path-shaped hit locator needs a path-looking prefix, not just `:digits`. */
+function looksLikeFilePath(prefix: string): boolean {
+  if (prefix.includes('://')) return false
+  return prefix.includes('/') || prefix.includes('\\') || /\.[A-Za-z0-9]{1,8}$/.test(prefix)
+}
+
+/** A bare path: no whitespace, no URL scheme, with a separator or an extension. */
+function isPurePathLine(line: string): boolean {
+  if (/\s/.test(line) || line.includes('://')) return false
+  return line.includes('/') || line.includes('\\') || /\.[A-Za-z0-9]{1,8}$/.test(line)
+}
+
+/**
+ * Content fallback (C13/C14) for unknown names: one path-plausible
+ * `path:line:content` line reads as grep output; a body of ≥80% pure paths
+ * reads as a directory listing. Both require file-path evidence so prose
+ * (`Note: 2024 - ...`) and URLs (`https://host:8080 - ...`) stay generic.
+ */
+function classifyByContent(text: string): ToolClass {
+  let nonEmpty = 0
+  let purePaths = 0
+  let pathLineHits = 0
+  for (const line of text.split('\n')) {
+    if (line.trim() === '') continue
+    nonEmpty += 1
+    const match = PATH_LINE_CONTENT_PATTERN.exec(line)
+    if (match !== null && looksLikeFilePath(match[1] ?? '')) pathLineHits += 1
+    if (isPurePathLine(line)) purePaths += 1
+  }
+  if (pathLineHits >= 1) return 'search'
+  if (nonEmpty >= 4 && purePaths / nonEmpty >= 0.8) return 'path-listing'
+  return 'generic'
+}

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

@@ -71,6 +71,20 @@ export interface PresetOptions {
   readonly readState: boolean
   /** Optional estimator channel; `''` keeps every estimator consumer on rule-only fallbacks (E1/E2). */
   readonly estimator: { readonly mode: '' | 'host' | 'direct' }
+  /**
+   * Advisory relevance advisor: statistics and suggestions only — every output
+   * (summaries, scores, decay, recertification) is observational and must never
+   * suppress, delay, or rewrite any reduction that would land. `''` (the
+   * default) keeps the advisor fully off.
+   */
+  readonly advisor: {
+    readonly mode: '' | 'host' | 'direct'
+    readonly timeoutMs: number
+    readonly refreshTurns: number
+    readonly scoreThreshold: number
+    readonly sampleLimit: number
+    readonly minTokens: number
+  }
   /**
    * Human-gated review pipeline (beta): edge/high-impact candidates queue for
    * manual approval and execute in one merged batch at the next turn boundary
@@ -155,6 +169,13 @@ export interface PresetOptionsSettings {
   readonly estimatorBaseUrl?: string
   readonly estimatorApiKey?: string
   readonly estimatorTimeoutMs?: number
+  /** Advisory advisor channel; `''` (the default) keeps the advisor off. */
+  readonly advisorMode?: '' | 'host' | 'direct'
+  readonly advisorTimeoutMs?: number
+  readonly advisorRefreshTurns?: number
+  readonly advisorScoreThreshold?: number
+  readonly advisorSampleLimit?: number
+  readonly advisorMinTokens?: number
 }
 
 /** Durable global preference exposed through `ctx.settings`. */
@@ -199,6 +220,14 @@ export interface ToolResultPruneConfig {
   historyKeepRecentTokens?: number
   /** Minimum reclaim required before historical aging is worth a cache break. Profile default when omitted. */
   historyMinReclaimTokens?: number
+  /**
+   * Read-class input cap in characters. Invariant (startup-asserted in
+   * `resolvePolicy`): when set it must exceed `freshTriggerTokens × 4.0` —
+   * the conservative chars/token upper bound — otherwise the cap sits below
+   * the fresh trigger and silently silences the fresh path for every read
+   * result. Unset profiles (host cap 50k–59.5k chars observed) stay untouched.
+   */
+  readInputCapChars?: number
   /**
    * Auto Compact threshold percent frozen into this deployment by the preset
    * overlay generation (50–90 integer). When present it supersedes the live
@@ -228,6 +257,12 @@ export interface CompressionPolicy {
   readonly historyKeepRecentToolCalls: number
   readonly historyKeepRecentTokens: number
   readonly historyMinReclaimTokens: number
+  /**
+   * Read-class input cap in characters when configured; absent otherwise.
+   * Startup-asserted to exceed `freshTriggerTokens × 4.0` so it can never
+   * silently silence the fresh path (G2 invariant).
+   */
+  readonly readInputCapChars?: number
   /**
    * Auto Compact token watermark `A = floor(C × a)` when the standard-profile
    * History linkage resolved for this Session; absent for Custom, Off, Native,
@@ -267,6 +302,8 @@ export interface ResolvedConfig {
   readonly historyKeepRecentToolCalls?: number
   readonly historyKeepRecentTokens?: number
   readonly historyMinReclaimTokens?: number
+  /** Read-class input cap in characters when configured; absent otherwise. */
+  readonly readInputCapChars?: number
   /**
    * Auto Compact threshold percent frozen into this deployment by the preset
    * overlay generation (50-90 integer). Supersedes the live Host setting.

package/packages/selector/tests/advisor-report.host.spec.ts

@@ -0,0 +1,223 @@
+/**
+ * Host-side guard for the advisory advisor's HTTP report route.
+ *
+ * Pins the read-only contract: the route registers under both prefixes only
+ * when the row opts in, a session whose advisor never ran reports nulls and
+ * empty arrays (not an error), a populated session reports its decay figure
+ * and score distribution content-free, and every error path answers a
+ * precise status — 400 for a missing sessionId, 404 for an unknown session,
+ * 503 when no agents service can resolve sessions at all.
+ */
+
+import { Context } from '@deepseek-ai/cordis'
+import { afterEach, describe, expect, it } from 'vitest'
+import { apply } from '../src/index.ts'
+import { getAdvisorState, recordScore, recordRecertified } from '../src/runtime/tokenpilot/advisor-state.ts'
+
+const REPORT_ROUTE = '/api/dsh-context-compression-improved/advisor-report'
+const LEGACY_REPORT_ROUTE = '/endpoint/dsh-context-compression-improved/advisor-report'
+
+interface RegisteredRoute {
+  kind: string
+  path: string
+  handler: (req: unknown, res: unknown) => unknown
+}
+
+interface FakeResponse {
+  status?: number
+  body?: string
+}
+
+let ctx: Context | undefined
+
+afterEach(async () => {
+  await ctx?.fiber.dispose()
+  ctx = undefined
+})
+
+const settle = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 20))
+
+async function mountWebServer(runtime: Context, routes: RegisteredRoute[]): Promise<void> {
+  await runtime.plugin({
+    name: 'fake-webserver',
+    apply(webCtx) {
+      webCtx.provide('webServer', {
+        tables: { exact: new Map<string, RegisteredRoute>() },
+        register(this: { tables: { exact: Map<string, RegisteredRoute> } }, 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 an agents service that knows session 's1' (and nothing else). */
+function mountAgents(runtime: Context): void {
+  void runtime.plugin({
+    name: 'fake-agents',
+    apply(serviceCtx) {
+      serviceCtx.provide('agents', {
+        get: (id: unknown) => {
+          if (id !== 's1') return undefined
+          const session = { id: 's1' }
+          const state = getAdvisorState(session as never)
+          state.summary = {
+            overallTask: 'migrate the auth module',
+            activeSubtasks: ['port login flow'],
+            keywords: ['auth'],
+            todoVersion: 'aaaa1111',
+            turn: 4,
+          }
+          state.lastDecay = { decay: 0.42, weightedChars: 10_000, turn: 4 }
+          recordScore(state, 3, { score: 0.95, turn: 4 })
+          recordScore(state, 5, { score: 0.10, turn: 4 })
+          recordRecertified(state, 5, 4)
+          return { session }
+        },
+      })
+    },
+  })
+}
+
+async function invoke(route: RegisteredRoute, req?: unknown): Promise<FakeResponse> {
+  const captured: FakeResponse = {}
+  const res = {
+    writeHead(code: number) { captured.status = code },
+    end(body?: string) { if (body !== undefined) captured.body = body },
+  }
+  await route.handler(req ?? { method: 'GET' }, res)
+  await settle()
+  return captured
+}
+
+describe('advisor report route registration', () => {
+  it('registers both prefixes only when the row opts in', async () => {
+    const routes: RegisteredRoute[] = []
+    const runtime = new Context()
+    ctx = runtime
+    await mountWebServer(runtime, routes)
+    apply(runtime, { advisorReportRoute: true })
+    await settle()
+    const paths = routes.map(route => route.path)
+    expect(paths).toContain(REPORT_ROUTE)
+    expect(paths).toContain(LEGACY_REPORT_ROUTE)
+  })
+
+  it('registers nothing by default (advisor off adds zero behavior)', async () => {
+    const routes: RegisteredRoute[] = []
+    const runtime = new Context()
+    ctx = runtime
+    await mountWebServer(runtime, routes)
+    apply(runtime, {})
+    await settle()
+    expect(routes.map(route => route.path)).not.toContain(REPORT_ROUTE)
+  })
+})
+
+describe('advisor report route responses', () => {
+  async function mountedRoute(): Promise<RegisteredRoute> {
+    const routes: RegisteredRoute[] = []
+    const runtime = new Context()
+    ctx = runtime
+    await mountWebServer(runtime, routes)
+    apply(runtime, { advisorReportRoute: true })
+    await settle()
+    const route = routes.find(entry => entry.path === REPORT_ROUTE)
+    expect(route).toBeDefined()
+    return route as RegisteredRoute
+  }
+
+  it('answers 503 without an agents service', async () => {
+    const route = await mountedRoute()
+    const response = await invoke(route, { url: `${REPORT_ROUTE}?sessionId=s1` })
+    expect(response.status).toBe(503)
+  })
+
+  it('answers 404 for an unknown session and 400 for a missing sessionId', async () => {
+    const routes: RegisteredRoute[] = []
+    const runtime = new Context()
+    ctx = runtime
+    await mountWebServer(runtime, routes)
+    mountAgents(runtime)
+    apply(runtime, { advisorReportRoute: true })
+    await settle()
+    const route = routes.find(entry => entry.path === REPORT_ROUTE) as RegisteredRoute
+
+    const unknown = await invoke(route, { url: `${REPORT_ROUTE}?sessionId=other` })
+    expect(unknown.status).toBe(404)
+
+    const missing = await invoke(route, { url: REPORT_ROUTE })
+    expect(missing.status).toBe(400)
+  })
+
+  it('serves the decay figure, summary, and scores content-free', async () => {
+    const routes: RegisteredRoute[] = []
+    const runtime = new Context()
+    ctx = runtime
+    await mountWebServer(runtime, routes)
+    mountAgents(runtime)
+    apply(runtime, { advisorReportRoute: true })
+    await settle()
+    const route = routes.find(entry => entry.path === REPORT_ROUTE) as RegisteredRoute
+
+    const response = await invoke(route, { url: `${REPORT_ROUTE}?sessionId=s1` })
+    expect(response.status).toBe(200)
+    const body = JSON.parse(response.body ?? '{}') as {
+      ok: boolean
+      sessionId: string
+      advisor: {
+        summary: { overallTask: string } | null
+        decay: number | null
+        weightedChars: number | null
+        scores: { seq: number, score: number }[]
+        lowRelevanceSeqs: number[]
+      }
+    }
+    expect(body.ok).toBe(true)
+    expect(body.sessionId).toBe('s1')
+    expect(body.advisor.decay).toBeCloseTo(0.42, 12)
+    expect(body.advisor.summary?.overallTask).toBe('migrate the auth module')
+    expect(body.advisor.scores).toHaveLength(2)
+    expect(body.advisor.lowRelevanceSeqs).toEqual([5])
+    // Content-free: no message text ever rides along.
+    expect(response.body).not.toContain('"text"')
+    expect(response.body).not.toContain('"content"')
+    expect(response.body).not.toContain('apiKey')
+  })
+
+  it('answers an empty report (nulls, not an error) for a session whose advisor never ran', async () => {
+    const routes: RegisteredRoute[] = []
+    const runtime = new Context()
+    ctx = runtime
+    await mountWebServer(runtime, routes)
+    void runtime.plugin({
+      name: 'fake-agents-empty',
+      apply(serviceCtx) {
+        serviceCtx.provide('agents', {
+          get: (id: unknown) => (id === 's1' ? { session: { id: 's1' } } : undefined),
+        })
+      },
+    })
+    apply(runtime, { advisorReportRoute: true })
+    await settle()
+    const route = routes.find(entry => entry.path === REPORT_ROUTE) as RegisteredRoute
+
+    const response = await invoke(route, { url: `${REPORT_ROUTE}?sessionId=s1` })
+    expect(response.status).toBe(200)
+    const body = JSON.parse(response.body ?? '{}') as {
+      ok: boolean
+      advisor: { summary: unknown, decay: unknown, scores: unknown[], lowRelevanceSeqs: unknown[] }
+    }
+    expect(body.ok).toBe(true)
+    expect(body.advisor.summary).toBeNull()
+    expect(body.advisor.decay).toBeNull()
+    expect(body.advisor.scores).toEqual([])
+    expect(body.advisor.lowRelevanceSeqs).toEqual([])
+  })
+})

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

@@ -43,10 +43,11 @@ describe('standalone package contract', () => {
     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-primitives',
       '@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')
+    expect(rootManifest.engines?.dsh).toBe('>=0.1.5-rc.1 <0.2.0-0')
   })
 
   it('uses the community package in the one Bundle patch', () => {

package/packages/selector/tests/review-routes-registry.host.spec.ts

@@ -0,0 +1,142 @@
+/**
+ * Production-shaped guard for the review routes' pruner resolution.
+ *
+ * The older suite provided `toolResultPruner` at the TOP LEVEL, which is a shape
+ * production never has: `canonicalCompressionRows()` mounts every pruner inside
+ * an agent preset's isolated group, so a top-level `ctx.get('toolResultPruner')`
+ * resolves nothing and the queue route answered 503 "review pipeline
+ * unavailable" for every request while the pipeline itself ran normally.
+ *
+ * These cases mount NO top-level service and publish through the review registry
+ * from a CHILD fiber instead — the path the fix relies on.
+ */
+
+import { Context } from '@deepseek-ai/cordis'
+import { afterEach, describe, expect, it } from 'vitest'
+import { apply } from '../src/index.ts'
+import { registerReviewPruner, type ReviewPrunerFace } from '../src/runtime/tokenpilot/review-registry.ts'
+
+const QUEUE_ROUTE = '/api/dsh-context-compression-improved/review-queue'
+
+interface RegisteredRoute {
+  kind: string
+  path: string
+  handler: (req: unknown, res: unknown) => unknown
+}
+
+let ctx: Context | undefined
+
+afterEach(async () => {
+  await ctx?.fiber.dispose()
+  ctx = undefined
+})
+
+const settle = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 20))
+
+/** A pruner face carrying one pending proposal for session `s1`. */
+const SAMPLE = {
+  id: 'abc123def456',
+  kind: 'read-state',
+  items: [{ seq: 6, kind: 'read-state', component: 'history', tokensBefore: 2401, tokensAfter: 134 }],
+  benefit: { recoveredTokens: 400, penaltyTokens: 900, paybackTurns: 2.25 },
+  enqueuedTurn: 3,
+  lastTurnIndex: 3,
+} as const
+
+function samplePruner(): ReviewPrunerFace {
+  return {
+    listReviewProposals: (session: unknown) => ((session as { id?: string }).id === 's1' ? [SAMPLE] : []),
+    listAllReviewProposals: () => [{ sessionId: 's1', proposals: [SAMPLE] }],
+    reviewSummary: () => ({ autoApplied: 2, reviewApplied: 1, expired: 3, voided: 0 }),
+    decideReviewProposal: (_session: unknown, proposalId: string) => (proposalId === SAMPLE.id
+      ? { ok: true }
+      : { ok: false, reason: 'unknown-proposal' }),
+  }
+}
+
+/** Mount the fake web server the routes register against. */
+async function mountWebServer(runtime: Context, routes: RegisteredRoute[]): Promise<void> {
+  await runtime.plugin({
+    name: 'fake-webserver',
+    apply(webCtx) {
+      webCtx.provide('webServer', {
+        tables: { exact: new Map<string, RegisteredRoute>() },
+        register(this: { tables: { exact: Map<string, RegisteredRoute> } }, route: RegisteredRoute) {
+          const table = this.tables.exact
+          if (table.has(route.path)) throw new Error(`webserver: duplicate ${route.path}`)
+          table.set(route.path, route)
+          routes.push(route)
+          return () => {}
+        },
+      })
+    },
+  })
+}
+
+/** Boot the host plugin with both routes opted in, as the Bundle row does. */
+async function bootWithRoutes(): Promise<RegisteredRoute[]> {
+  const routes: RegisteredRoute[] = []
+  ctx = new Context()
+  await mountWebServer(ctx, routes)
+  apply(ctx, { estimatorCatalogRoute: true, reviewQueueRoute: true })
+  await settle()
+  return routes
+}
+
+async function readQueue(routes: RegisteredRoute[]): Promise<{ status: number, body: string }> {
+  const route = routes.find(candidate => candidate.path === QUEUE_ROUTE)
+  expect(route, `route ${QUEUE_ROUTE} must be registered`).toBeDefined()
+  // `exactOptionalPropertyTypes` forbids assigning an explicit `undefined` to an
+  // optional property, so the widened type must spell it out.
+  const captured: { status?: number, body?: string | undefined } = {}
+  const res = {
+    writeHead(code: number) { captured.status = code },
+    end(body?: string) { captured.body = body },
+  }
+  await route!.handler({ url: QUEUE_ROUTE }, res)
+  return { status: captured.status ?? 0, body: captured.body ?? '' }
+}
+
+describe('review routes resolve a preset-scoped pruner', () => {
+  it('answers 503 while no pruner has been published', async () => {
+    const routes = await bootWithRoutes()
+    const { status, body } = await readQueue(routes)
+    expect(status).toBe(503)
+    expect(body).toContain('review pipeline unavailable')
+  })
+
+  it('reaches a pruner published from a CHILD fiber with no top-level service', async () => {
+    const routes = await bootWithRoutes()
+    // Production shape: the pruner is mounted in a preset's isolated group.
+    await ctx!.plugin({
+      name: 'preset-scoped-pruner',
+      apply(childCtx) {
+        childCtx.effect(() => registerReviewPruner(samplePruner()), 'test-preset-pruner')
+      },
+    })
+    await settle()
+
+    const { status, body } = await readQueue(routes)
+    expect(status).toBe(200)
+    const parsed = JSON.parse(body) as { ok: boolean, total: number, pending: readonly { id: string }[] }
+    expect(parsed.ok).toBe(true)
+    expect(parsed.total).toBe(1)
+    expect(parsed.pending[0]?.id).toBe(SAMPLE.id)
+  })
+
+  it('drops back to 503 once the publishing fiber disposes', async () => {
+    const routes = await bootWithRoutes()
+    const fork = await ctx!.plugin({
+      name: 'preset-scoped-pruner',
+      apply(childCtx) {
+        childCtx.effect(() => registerReviewPruner(samplePruner()), 'test-preset-pruner')
+      },
+    })
+    await settle()
+    expect((await readQueue(routes)).status).toBe(200)
+
+    await fork.dispose()
+    await settle()
+    expect((await readQueue(routes)).status).toBe(503)
+  })
+})

package/packages/selector/tests/runtime/adaptive-cost.spec.ts

@@ -31,9 +31,9 @@ describe('Conservative Adaptive interval', () => {
       expectedTokenizerRevision: 'DeepSeek-V4-Pro-0813',
       previousRequestMeasurement: exact(30_500),
       measuredNodes: [
-        { seq: 0, count: exact(10_000) },
-        { seq: 2, count: exact(20_000) },
-        { seq: 3, count: exact(500) },
+        { seq: 0, count: exact(10_000), characterPressure: 40_000 },
+        { seq: 2, count: exact(20_000), characterPressure: 80_000 },
+        { seq: 3, count: exact(500), characterPressure: 2_000 },
       ],
     })).toEqual({
       kind: 'available',
@@ -57,7 +57,7 @@ describe('Conservative Adaptive interval', () => {
         estimatorRevision: 'r1',
         calibration: { sampleCount: 1, conservativeMarginTokens: 200 },
       }),
-      measuredNodes: [{ seq: 0, count: exact(10_000) }],
+      measuredNodes: [{ seq: 0, count: exact(10_000), characterPressure: 40_000 }],
     })).toMatchObject({
       kind: 'available',
       measurementKind: 'tokenizer-estimate',
@@ -79,7 +79,7 @@ describe('Conservative Adaptive interval', () => {
       previousPromptTokens: 200,
       expectedTokenizerRevision: 'DeepSeek-V4-Pro-0813',
       previousRequestMeasurement: measurement,
-      measuredNodes: [{ seq: 0, count: exact(50) }],
+      measuredNodes: [{ seq: 0, count: exact(50), characterPressure: 200 }],
     })).toEqual({ kind: 'unknown', reason })
   })
 
@@ -90,7 +90,7 @@ describe('Conservative Adaptive interval', () => {
       previousPromptTokens: 200,
       expectedTokenizerRevision: 'DeepSeek-V4-Pro-0813',
       previousRequestMeasurement: exact(200, 'DeepSeek-V4-Flash-0731'),
-      measuredNodes: [{ seq: 0, count: exact(50) }],
+      measuredNodes: [{ seq: 0, count: exact(50), characterPressure: 200 }],
     })).toEqual({ kind: 'unknown', reason: 'request-tokenizer-revision-mismatch' })
   })
 
@@ -101,7 +101,7 @@ describe('Conservative Adaptive interval', () => {
       previousPromptTokens: 200,
       expectedTokenizerRevision: 'DeepSeek-V4-Pro-0813',
       previousRequestMeasurement: exact(200),
-      measuredNodes: [{ seq: 0, count: exact(50, 'DeepSeek-V4-Flash-0731') }],
+      measuredNodes: [{ seq: 0, count: exact(50, 'DeepSeek-V4-Flash-0731'), characterPressure: 200 }],
     })).toEqual({ kind: 'unknown', reason: 'exact-prefix-tokenizer-revision-mismatch' })
   })