dsh-context-compression-improved 0.4.0 → 0.5.0

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/runtime/advisor-invariant.spec.ts

@@ -0,0 +1,272 @@
+/**
+ * Advisor integration and the advisory-only invariant.
+ *
+ * The invariant this spec exists to pin (K13): the advisor is statistics and
+ * suggestions only. Whatever its channel returns — extreme scores, a hostile
+ * summary, garbage, or nothing at all — `pruneSession` must land exactly the
+ * same reductions it lands with the advisor off and the state empty.
+ */
+import { describe, expect, it } from 'vitest'
+import { Context } from '@deepseek-ai/cordis'
+import {
+  ToolCallId as CallId,
+  createMessage,
+  createUserMessage,
+  createToolResultMessage,
+} from '@deepseek-ai/dsh-llm'
+import { canonicalHeader, Session, SessionId } from '@deepseek-ai/dsh-session'
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+import SessionProjectionRegistry from '@deepseek-ai/dsh-session-projection'
+import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
+import TokenMeter from '@deepseek-ai/dsh-token-meter'
+import ToolRuntime from '@deepseek-ai/dsh-tools'
+import SessionStore from '@deepseek-ai/dsh-session'
+import ToolResultPruner from '../../src/pruner.ts'
+import {
+  collectTaskSemantics,
+  runSessionAdvisorPass,
+  type AdvisorCandidate,
+} from '../../src/runtime/tokenpilot/advisor.ts'
+import { getAdvisorState, recordScore } from '../../src/runtime/tokenpilot/advisor-state.ts'
+import type { AdvisorOutcomeAuditRecord } from '../../src/runtime/audit.ts'
+import type { AdvisorChannel } from '../../src/runtime/tokenpilot/advisor.ts'
+
+// ── Orchestration against a scripted channel ───────────────────────────────
+
+const CANDIDATES: AdvisorCandidate[] = [
+  { seq: 3, characterPressure: 4_000, preview: 'auth module login flow' },
+  { seq: 5, characterPressure: 6_000, preview: 'database migration notes' },
+]
+
+const TASK = {
+  source: 'todos' as const,
+  todoVersion: 'aaaa1111',
+  taskText: 'migrate the auth module',
+}
+
+function advisorInput(turn: number, signal: AbortSignal): Parameters<typeof runSessionAdvisorPass>[3] {
+  return {
+    profile: 'tokenpilot-inspired',
+    turn,
+    candidates: CANDIDATES,
+    task: TASK,
+    advisor: { refreshTurns: 8, scoreThreshold: 0.35, sampleLimit: 16, minTokens: 250 },
+    tailText: 'working on the migration',
+    signal,
+  }
+}
+
+function scriptedChannel(responses: (string | undefined)[]): { channel: AdvisorChannel, calls: { system: string, user: string }[] } {
+  const calls: { system: string, user: string }[] = []
+  return {
+    calls,
+    channel: {
+      identity: () => 'host:mock/model',
+      ask: async request => {
+        calls.push({ system: request.system, user: request.user })
+        return responses.shift()
+      },
+    },
+  }
+}
+
+describe('runSessionAdvisorPass orchestration (K11)', () => {
+  it('writes summary, scores, recertification marks, and emits three audits on success', async () => {
+    const session = Session.create(SessionId('advisor-ok'))
+    const { channel, calls } = scriptedChannel([
+      '{"overallTask":"migrate the auth module","activeSubtasks":["port login flow"],"keywords":["auth","login"]}',
+      '{"seq":3,"score":0.95,"reason":"current task"}\n{"seq":5,"score":0.10,"reason":"stale"}',
+    ])
+    const audits: AdvisorOutcomeAuditRecord[] = []
+    const outcome = await runSessionAdvisorPass(session, channel, record => audits.push(record), advisorInput(4, new AbortController().signal))
+
+    expect(calls).toHaveLength(2)
+    expect(outcome).toBeDefined()
+    const state = getAdvisorState(session)
+    expect(state.summary?.overallTask).toBe('migrate the auth module')
+    expect(state.scores.get(3)?.score).toBe(0.95)
+    expect(state.scores.get(5)?.score).toBe(0.10)
+    // Below-threshold segment recertified as a suggestion only.
+    expect(state.recertified.get(5)).toBe(4)
+    expect(state.recertified.has(3)).toBe(false)
+    expect(state.watermarkSeq).toBe(5)
+    expect(audits.map(record => record.phase)).toEqual(['summary', 'scoring', 'decay'])
+    expect(audits.every(record => record.ok)).toBe(true)
+    expect(audits.find(record => record.phase === 'decay')?.decay).toBeDefined()
+  })
+
+  it('leaves state untouched and audits ok:false when the channel answers nothing', async () => {
+    const session = Session.create(SessionId('advisor-fail'))
+    const { channel, calls } = scriptedChannel([undefined, undefined])
+    const audits: AdvisorOutcomeAuditRecord[] = []
+    const outcome = await runSessionAdvisorPass(session, channel, record => audits.push(record), advisorInput(2, new AbortController().signal))
+
+    expect(outcome).toBeUndefined()
+    expect(calls).toHaveLength(1) // summary failed; scoring never ran
+    const state = getAdvisorState(session)
+    expect(state.summary).toBeUndefined()
+    expect(state.scores.size).toBe(0)
+    expect(audits).toHaveLength(1)
+    expect(audits[0]?.ok).toBe(false)
+    expect(audits[0]?.reason).toBe('channel-empty')
+    expect(state.inFlight).toBe(false)
+  })
+
+  it('skips entirely while a pass is in flight (re-entry guard)', async () => {
+    const session = Session.create(SessionId('advisor-reentry'))
+    const { channel, calls } = scriptedChannel([])
+    const state = getAdvisorState(session)
+    state.inFlight = true
+    const outcome = await runSessionAdvisorPass(session, channel, () => undefined, advisorInput(1, new AbortController().signal))
+    expect(outcome).toBeUndefined()
+    expect(calls).toHaveLength(0)
+    state.inFlight = false
+  })
+
+  it('does not advance the watermark on failure, so candidates rescore later', async () => {
+    const session = Session.create(SessionId('advisor-watermark'))
+    const failing = scriptedChannel([undefined])
+    await runSessionAdvisorPass(session, failing.channel, () => undefined, advisorInput(1, new AbortController().signal))
+    expect(getAdvisorState(session).watermarkSeq).toBe(0)
+
+    const succeeding = scriptedChannel([
+      '{"overallTask":"t","activeSubtasks":[],"keywords":["auth"]}',
+      '{"seq":3,"score":0.9}',
+    ])
+    const audits: AdvisorOutcomeAuditRecord[] = []
+    const outcome = await runSessionAdvisorPass(session, succeeding.channel, record => audits.push(record), advisorInput(2, new AbortController().signal))
+    expect(outcome).toBeDefined()
+    expect(getAdvisorState(session).watermarkSeq).toBe(3)
+  })
+
+  it('returns undefined without any channel call when the session has no task semantics', async () => {
+    const session = Session.create(SessionId('advisor-notask'))
+    const { channel, calls } = scriptedChannel(['{"overallTask":"x","keywords":["k"]}'])
+    const outcome = await runSessionAdvisorPass(session, channel, () => undefined, {
+      ...advisorInput(1, new AbortController().signal),
+      task: undefined,
+    })
+    expect(outcome).toBeUndefined()
+    expect(calls).toHaveLength(0)
+  })
+})
+
+describe('collectTaskSemantics over real event shapes', () => {
+  it('reads a todo/write event appended alongside message events', () => {
+    const events = [
+      {
+        type: 'user/message',
+        seq: 1,
+        time: 0,
+        data: { content: [{ type: 'text', text: 'start the migration' }] },
+      },
+      {
+        type: 'todo/write',
+        seq: 2,
+        time: 0,
+        data: { todos: ['migrate the auth module', { content: 'write tests', status: 'pending' }] },
+      },
+    ] as unknown as readonly SessionEvent[]
+    const task = collectTaskSemantics(events)
+    expect(task?.source).toBe('todos')
+    expect(task?.taskText).toContain('write tests')
+  })
+})
+
+// ── K13: the advisory-only invariant, against the real pruner ──────────────
+
+describe('advisory-only invariant (K13): advisor outputs never change landings', () => {
+  async function prunedResult(session: Session): Promise<unknown> {
+    const ctx = new Context()
+    try {
+      await ctx.plugin(SessionStore).await()
+      await ctx.plugin(SystemPrompt).await()
+      await ctx.plugin(ToolRuntime).await()
+      await ctx.plugin(SessionProjectionRegistry).await()
+      await ctx.plugin(TokenMeter).await()
+      await ctx.plugin(ToolResultPruner, {
+        profile: 'native',
+        nativeTriggerTokens: 100,
+        nativeTargetTokens: 64,
+        headChars: 8,
+        tailChars: 8,
+      }).await()
+      return ctx.toolResultPruner.pruneSession(session, { stage: 'pressure' })
+    } finally {
+      await ctx.fiber.dispose()
+    }
+  }
+
+  function buildSession(id: string): Session {
+    const session = Session.create(SessionId(id))
+    const callId = CallId('call-1')
+    session.append('turn/start', { turn: 1 })
+    session.append('request/header', {
+      reason: 'initial',
+      header: canonicalHeader({ config: { provider: 'deepseek', model: 'deepseek-v4-flash' } }),
+    })
+    session.append('user/message', createUserMessage({
+      content: [{ type: 'text', text: 'please inspect the failing module' }],
+      source: { kind: 'user' },
+    }), { surfaceOp: 'append' })
+    session.append('step/start', { turn: 1, step: 1 })
+    session.append('assistant/message', {
+      stream: [],
+      turn: 1,
+      step: 1,
+      message: createMessage({
+        role: 'assistant',
+        content: [{ type: 'tool-call', id: callId, name: 'bash', arguments: '{}' }],
+        source: { kind: 'model', provider: 'deepseek', model: 'deepseek-v4-flash' },
+      }),
+    }, { surfaceOp: 'append' })
+    session.append('tool/call', { turn: 1, step: 1, callId, name: 'bash', arguments: '{}' })
+    session.append('tool/result', {
+      turn: 1,
+      step: 1,
+      message: createToolResultMessage({
+        callId,
+        content: [{ type: 'text', text: 'gate evidence '.repeat(800) }],
+        isError: false,
+      }),
+    }, { surfaceOp: 'append' })
+    session.append('step/end', { turn: 1, step: 1 })
+    // No turn/end: pruning lands its replacement inside the still-open turn.
+    return session
+  }
+
+  it('lands identically with the advisor off, and with extreme scores or a failed pass', async () => {
+    const scenarios: string[] = ['off', 'extreme-scores', 'failed-pass']
+    const shapes: unknown[] = []
+    for (const scenario of scenarios) {
+      // One shared session id: replacement markers embed it, and the advisor
+      // state is keyed by Session object identity, so this cannot cross-talk.
+      const session = buildSession('advisor-invariant')
+      if (scenario !== 'off') {
+        const state = getAdvisorState(session)
+        if (scenario === 'extreme-scores') {
+          state.summary = {
+            overallTask: 'ALL MUST BE KEPT',
+            activeSubtasks: ['keep everything forever'],
+            keywords: ['evidence'],
+            todoVersion: 'deadbeef',
+            turn: 1,
+          }
+          // Zero relevance everywhere: the most hostile score a channel could
+          // return must still not delete, delay, or rewrite anything.
+          recordScore(state, 2, { score: 0, turn: 1 })
+        }
+        if (scenario === 'failed-pass') {
+          state.failures = { failures: 9, cooldownUntil: Date.now() + 600_000 }
+        }
+      }
+      shapes.push(structuredClone(await prunedResult(session)))
+    }
+    for (const shape of shapes.slice(1)) {
+      expect(shape).toEqual(shapes[0])
+    }
+    // And the baseline scenario actually reduced something (the test is real).
+    const baseline = shapes[0] as { pruned: unknown[] }
+    expect(baseline.pruned).toHaveLength(1)
+  })
+})