dsh-context-compression-improved 0.5.0 → 0.5.2

package/packages/selector/src/runtime/tokenpilot/review-storage.ts

@@ -1,122 +0,0 @@
-/**
- * TokenPilot-inspired R4: the storageDomain adapter for the review queue.
- *
- * The `storageDomain` seam is resolved OPTIONALLY at runtime (`ctx.get`), never
- * declared as a hard plugin inject: a host without storage backends must load
- * the plugin anyway and serve the review queue from its in-memory fallback.
- * Any open failure degrades the same way — the caller receives `undefined` and
- * logs one warning.
- *
- * The domain spec is a plain structural object with a hand-rolled `safeParse`
- * validator, so the plugin carries no runtime dependency on
- * `@deepseek-ai/dsh-storage-domain` (or on a compatible zod instance); hosts
- * that reject the structural spec simply fall into the same degrade path.
- */
-import type { ReviewQueueStore, ReviewSessionRecord } from './review-queue.ts'
-
-/** Domain name — `UNIT_NAME_RE` (`/^[a-z][a-z0-9_]*$/`) allows no hyphens. */
-export const REVIEW_STORAGE_DOMAIN = 'context_compression_review'
-
-/** The one declared table: one record per session id. */
-export const REVIEW_STORAGE_TABLE = 'sessions'
-
-/** Minimal structural face of one opened domain table (sync reads, durable writes). */
-interface ReviewStorageTableLike {
-  get(key: string): unknown
-  put(key: string, value: unknown): Promise<void>
-  keys(): IterableIterator<string>
-}
-
-/** Minimal structural face of the `storageDomain` service. */
-interface StorageDomainServiceLike {
-  open(spec: unknown): Promise<{ table(name: string): ReviewStorageTableLike }>
-}
-
-/** Structural validator: accepts exactly the shape this module persists. */
-function reviewSessionRecordValidator(): { safeParse(value: unknown): { success: boolean, data?: ReviewSessionRecord } } {
-  return {
-    safeParse(value: unknown): { success: boolean, data?: ReviewSessionRecord } {
-      if (typeof value !== 'object' || value === null) return { success: false }
-      const record = value as { version?: unknown, proposals?: unknown }
-      if (record.version !== 1 || !Array.isArray(record.proposals)) return { success: false }
-      for (const proposal of record.proposals) {
-        if (typeof proposal !== 'object' || proposal === null) return { success: false }
-        const entry = proposal as {
-          id?: unknown, sessionId?: unknown, kind?: unknown, status?: unknown,
-          items?: unknown, benefit?: unknown, enqueuedTurn?: unknown, lastTurnIndex?: unknown,
-        }
-        if (typeof entry.id !== 'string' || typeof entry.sessionId !== 'string') return { success: false }
-        if (entry.kind !== 'estimator' && entry.kind !== 'dedup' && entry.kind !== 'read-state') {
-          return { success: false }
-        }
-        if (entry.status !== 'pending' && entry.status !== 'approved') return { success: false }
-        if (!Number.isSafeInteger(entry.enqueuedTurn) || !Number.isSafeInteger(entry.lastTurnIndex)) {
-          return { success: false }
-        }
-        if (!Array.isArray(entry.items) || typeof entry.benefit !== 'object' || entry.benefit === null) {
-          return { success: false }
-        }
-        for (const item of entry.items) {
-          if (typeof item !== 'object' || item === null) return { success: false }
-          const one = item as { seq?: unknown, digest?: unknown }
-          if (!Number.isSafeInteger(one.seq) || typeof one.digest !== 'string') return { success: false }
-        }
-      }
-      return { success: true, data: value as ReviewSessionRecord }
-    },
-  }
-}
-
-function reviewStorageSpec(): unknown {
-  return {
-    name: REVIEW_STORAGE_DOMAIN,
-    version: 1,
-    layout: 'per-record',
-    tables: {
-      [REVIEW_STORAGE_TABLE]: { valueSchema: reviewSessionRecordValidator() },
-    },
-  }
-}
-
-/** Adapter presenting the sync KV face the queue expects over the domain table. */
-class StorageDomainReviewStore implements ReviewQueueStore {
-  constructor(private readonly table: ReviewStorageTableLike) {}
-
-  load(sessionId: string): ReviewSessionRecord | undefined {
-    const value = this.table.get(sessionId)
-    return typeof value === 'object' && value !== null ? value as ReviewSessionRecord : undefined
-  }
-
-  save(sessionId: string, record: ReviewSessionRecord): void {
-    // Durability is fire-and-forget: the domain's write chain lands the record
-    // while the queue proceeds; failures are logged by the host backend and
-    // the in-memory state still serves reads.
-    void this.table.put(sessionId, record).catch(() => undefined)
-  }
-
-  ids(): readonly string[] {
-    return [...this.table.keys()]
-  }
-}
-
-/**
- * Attempt to open the review storage domain through the optional
- * `storageDomain` seam.
- * @param getService - resolved once with the seam name; `undefined` means the
- * host lacks the service.
- * @returns the durable store, or `undefined` when the seam is absent or fails
- * (the caller falls back to the in-memory store and logs one warning).
- */
-export async function openReviewStorage(
-  getService: (name: string) => unknown,
-): Promise<ReviewQueueStore | undefined> {
-  let service: unknown
-  try {
-    service = getService('storageDomain')
-  } catch {
-    return undefined
-  }
-  if (service === undefined || service === null) return undefined
-  const domain = await (service as StorageDomainServiceLike).open(reviewStorageSpec())
-  return new StorageDomainReviewStore(domain.table(REVIEW_STORAGE_TABLE))
-}

package/packages/selector/tests/review-overlay.client.spec.tsx

@@ -1,118 +0,0 @@
-// @vitest-environment jsdom
-
-import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { ReviewOverlay } from '../src/client/ReviewOverlay.tsx'
-import type { SettingsScopeLike } from '../src/client/review-scope.ts'
-
-afterEach(() => {
-  cleanup()
-  vi.unstubAllGlobals()
-})
-
-const QUEUE_ROUTE = '/api/dsh-context-compression-improved/review-queue'
-const DECIDE_ROUTE = '/api/dsh-context-compression-improved/review-decide'
-
-const PROPOSAL = {
-  sessionId: 's1',
-  id: 'abc123def456',
-  kind: 'read-state',
-  items: [{ seq: 6, tokensBefore: 2401, tokensAfter: 134 }],
-  benefit: { recoveredTokens: 400, paybackTurns: 2.25, expectedSaving: 312 },
-}
-
-function scopeStub(reviewMode: boolean): SettingsScopeLike {
-  return {
-    getSnapshot: () => ({
-      status: 'ready',
-      value: { presetOptions: { reviewMode } },
-    }),
-    subscribe: () => () => {},
-  }
-}
-
-type FetchCall = { input: string | URL | Request, init?: RequestInit | undefined }
-
-function stubFetch(responses: Array<{ match: (input: string) => boolean, body: unknown, status?: number }>): {
-  calls: FetchCall[]
-} {
-  const calls: FetchCall[] = []
-  vi.stubGlobal('fetch', vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
-    calls.push({ input, init })
-    const url = String(input)
-    const match = responses.find(entry => entry.match(url))
-    return {
-      ok: (match?.status ?? 200) < 400,
-      status: match?.status ?? 200,
-      json: async () => match?.body,
-    } as Response
-  }))
-  return { calls }
-}
-
-const queueBody = {
-  ok: true,
-  total: 1,
-  pending: [PROPOSAL],
-  summary: { autoApplied: 2, reviewApplied: 1, expired: 3, voided: 0 },
-}
-
-describe('review overlay (client)', () => {
-  it('renders the pending list and the four-state summary row', async () => {
-    stubFetch([{ match: url => url.includes(QUEUE_ROUTE), body: queueBody }])
-    render(<ReviewOverlay scope={scopeStub(true)} t={key => key} />)
-
-    await waitFor(() => { expect(screen.getByText('review.badge 1')).toBeDefined() })
-    fireEvent.click(screen.getByText('review.badge 1'))
-    expect(screen.getByText('review.title')).toBeDefined()
-    expect(screen.getByText(/review.summary.autoApplied: 2/)).toBeDefined()
-    expect(screen.getByText(/review.summary.expired: 3/)).toBeDefined()
-    // Estimated saving is labelled as an estimate.
-    expect(screen.getByText(/review.row.estimated/)).toBeDefined()
-  })
-
-  it('posts the three decisions through the decide route and refreshes', async () => {
-    const { calls } = stubFetch([
-      { match: url => url.includes(QUEUE_ROUTE), body: queueBody },
-      { match: url => url.includes(DECIDE_ROUTE), body: { ok: true } },
-    ])
-    render(<ReviewOverlay scope={scopeStub(true)} t={key => key} />)
-    await waitFor(() => { expect(screen.getByText('review.badge 1')).toBeDefined() })
-    fireEvent.click(screen.getByText('review.badge 1'))
-
-    fireEvent.click(screen.getByText('review.action.approve'))
-    await waitFor(() => {
-      expect(calls.some(call => String(call.input) === DECIDE_ROUTE && call.init?.method === 'POST')).toBe(true)
-    })
-    const posted = JSON.parse(String(calls.find(call => call.init?.method === 'POST')?.init?.body))
-    expect(posted).toEqual({ sessionId: 's1', proposalId: 'abc123def456', decision: 'approved' })
-
-    fireEvent.click(screen.getByText('review.action.reject'))
-    await waitFor(() => {
-      expect(calls.some(call => String(call.input) === DECIDE_ROUTE
-        && JSON.parse(String(call.init?.body)).decision === 'rejected')).toBe(true)
-    })
-    fireEvent.click(screen.getByText('review.action.ignore'))
-    await waitFor(() => {
-      expect(calls.some(call => String(call.input) === DECIDE_ROUTE
-        && JSON.parse(String(call.init?.body)).decision === 'ignored')).toBe(true)
-    })
-  })
-
-  it('renders nothing while nothing is pending', async () => {
-    stubFetch([{ match: url => url.includes(QUEUE_ROUTE), body: { ok: true, total: 0, pending: [] } }])
-    const { container } = render(<ReviewOverlay scope={scopeStub(true)} t={key => key} />)
-    await waitFor(() => {
-      expect((container.querySelector('.dsh-cc-review-badge'))).toBeNull()
-    })
-  })
-
-  it('renders nothing while review mode is off', async () => {
-    const fetchMock = vi.fn()
-    vi.stubGlobal('fetch', fetchMock)
-    const { container } = render(<ReviewOverlay scope={scopeStub(false)} t={key => key} />)
-    await new Promise(resolve => setTimeout(resolve, 30))
-    expect(container.querySelector('.dsh-cc-review-badge')).toBeNull()
-    expect(fetchMock).not.toHaveBeenCalled()
-  })
-})

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

@@ -1,142 +0,0 @@
-/**
- * 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/review-routes.host.spec.ts

@@ -1,290 +0,0 @@
-/**
- * Host-side guard for the review pipeline's HTTP transport (R4).
- *
- * Pins the client↔runtime contract: the two routes (queue read, decide write)
- * register under both prefixes, the happy path answers a sanitized payload
- * (ids/seqs/counts, never digests or content), and every error path answers a
- * precise status — 400 for malformed input, 404 for unknown session/proposal,
- * 503 when the review pipeline is not serving the session.
- */
-
-import { Context } from '@deepseek-ai/cordis'
-import { afterEach, describe, expect, it } from 'vitest'
-import { apply } from '../src/index.ts'
-
-const QUEUE_ROUTE = '/api/dsh-context-compression-improved/review-queue'
-const DECIDE_ROUTE = '/api/dsh-context-compression-improved/review-decide'
-const LEGACY_QUEUE_ROUTE = '/endpoint/dsh-context-compression-improved/review-queue'
-const LEGACY_DECIDE_ROUTE = '/endpoint/dsh-context-compression-improved/review-decide'
-
-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 () => {}
-        },
-      })
-    },
-  })
-}
-
-interface PrunerBehavior {
-  readonly reviewOn: boolean
-  decideOutcome?: { ok: true } | { ok: false, reason: string } | undefined
-}
-
-function mountReviewServices(runtime: Context, behavior: PrunerBehavior): void {
-  void runtime.plugin({
-    name: 'fake-review-services',
-    apply(serviceCtx) {
-      serviceCtx.provide('agents', {
-        get: (id: unknown) => (id === 's1' ? { session: { id: 's1' } } : undefined),
-      })
-      const sampleProposal = {
-        id: 'abc123def456',
-        kind: 'read-state',
-        status: 'pending',
-        items: [{
-          seq: 6, kind: 'read-state', component: 'history', tokensBefore: 2401, tokensAfter: 134,
-          digest: 'dd'.repeat(32),
-        }],
-        benefit: { recoveredTokens: 400, penaltyTokens: 900, paybackTurns: 2.25 },
-        enqueuedTurn: 3,
-        lastTurnIndex: 3,
-      }
-      serviceCtx.provide('toolResultPruner', {
-        listReviewProposals: (session: unknown) => {
-          const id = (session as { id?: string }).id
-          return id === 's1' && behavior.reviewOn ? [sampleProposal] : []
-        },
-        listAllReviewProposals: () => (behavior.reviewOn
-          ? [{ sessionId: 's1', proposals: [sampleProposal] }]
-          : []),
-        reviewSummary: () => ({ autoApplied: 2, reviewApplied: 1, expired: 3, voided: 0 }),
-        decideReviewProposal: (_session: unknown, proposalId: string) => {
-          if (behavior.reviewOn === false) return undefined
-          if (proposalId !== 'abc123def456') return { ok: false, reason: 'unknown-proposal' }
-          return behavior.decideOutcome ?? { ok: true }
-        },
-      })
-    },
-  })
-}
-
-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('review queue route registration', () => {
-  it('registers both route prefixes only when the row opts in', async () => {
-    const routes: RegisteredRoute[] = []
-    const runtime = new Context()
-    ctx = runtime
-    await mountWebServer(runtime, routes)
-
-    apply(runtime, { reviewQueueRoute: true })
-    await settle()
-
-    expect(routes.map(route => route.path)).toEqual([
-      LEGACY_QUEUE_ROUTE, QUEUE_ROUTE, LEGACY_DECIDE_ROUTE, DECIDE_ROUTE,
-    ])
-
-    const routesAfterOptOut: RegisteredRoute[] = []
-    const plain = new Context()
-    ctx = plain
-    await mountWebServer(plain, routesAfterOptOut)
-    apply(plain, { presetOverlay: false })
-    await settle()
-    expect(routesAfterOptOut).toHaveLength(0)
-  })
-
-  it('answers the queue read with a sanitized payload', async () => {
-    const routes: RegisteredRoute[] = []
-    const runtime = new Context()
-    ctx = runtime
-    await mountWebServer(runtime, routes)
-    mountReviewServices(runtime, { reviewOn: true })
-    apply(runtime, { reviewQueueRoute: true })
-    await settle()
-
-    const route = routes.find(candidate => candidate.path === QUEUE_ROUTE)
-    const response = await invoke(route as RegisteredRoute, { url: `${QUEUE_ROUTE}?sessionId=s1` })
-
-    expect(response.status).toBe(200)
-    const body = JSON.parse(String(response.body)) as {
-      ok: boolean
-      summary?: Record<string, number>
-      pending: readonly { id: string, items: readonly Record<string, unknown>[] }[]
-    }
-    expect(body.ok).toBe(true)
-    expect(body.pending).toHaveLength(1)
-    expect(body.pending[0]!.id).toBe('abc123def456')
-    expect(body.summary).toEqual({ autoApplied: 2, reviewApplied: 1, expired: 3, voided: 0 })
-    // Digests never leave the runtime: the client only needs ids and counts.
-    expect(String(response.body)).not.toContain('digest')
-    expect(String(response.body)).not.toContain('"content"')
-  })
-
-  it('aggregates every live session when the read carries no sessionId', async () => {
-    const routes: RegisteredRoute[] = []
-    const runtime = new Context()
-    ctx = runtime
-    await mountWebServer(runtime, routes)
-    mountReviewServices(runtime, { reviewOn: true })
-    apply(runtime, { reviewQueueRoute: true })
-    await settle()
-
-    const route = routes.find(candidate => candidate.path === QUEUE_ROUTE) as RegisteredRoute
-    const response = await invoke(route, { url: QUEUE_ROUTE })
-
-    expect(response.status).toBe(200)
-    const body = JSON.parse(String(response.body)) as {
-      ok: boolean
-      total: number
-      pending: readonly { sessionId: string, id: string }[]
-    }
-    expect(body).toMatchObject({ ok: true, total: 1 })
-    expect(body.pending[0]).toMatchObject({ sessionId: 's1', id: 'abc123def456' })
-  })
-
-  it('rejects a queue read for an unknown session', async () => {
-    const routes: RegisteredRoute[] = []
-    const runtime = new Context()
-    ctx = runtime
-    await mountWebServer(runtime, routes)
-    mountReviewServices(runtime, { reviewOn: true })
-    apply(runtime, { reviewQueueRoute: true })
-    await settle()
-    const route = routes.find(candidate => candidate.path === QUEUE_ROUTE) as RegisteredRoute
-
-    const unknown = await invoke(route, { url: `${QUEUE_ROUTE}?sessionId=nope` })
-    expect(unknown.status).toBe(404)
-  })
-
-  it('answers 503 when the pruner is not serving review proposals', async () => {
-    const routes: RegisteredRoute[] = []
-    const runtime = new Context()
-    ctx = runtime
-    await mountWebServer(runtime, routes)
-    apply(runtime, { reviewQueueRoute: true })
-    await settle()
-
-    const route = routes.find(candidate => candidate.path === QUEUE_ROUTE) as RegisteredRoute
-    const response = await invoke(route, { url: `${QUEUE_ROUTE}?sessionId=s1` })
-    expect(response.status).toBe(503)
-  })
-
-  it('rejects malformed decide bodies with 400', async () => {
-    const routes: RegisteredRoute[] = []
-    const runtime = new Context()
-    ctx = runtime
-    await mountWebServer(runtime, routes)
-    mountReviewServices(runtime, { reviewOn: true })
-    apply(runtime, { reviewQueueRoute: true })
-    await settle()
-    const route = routes.find(candidate => candidate.path === DECIDE_ROUTE) as RegisteredRoute
-
-    const notJson = await invoke(route, { on: (event: string, listener: (chunk?: Buffer) => void) => {
-      if (event === 'end') listener()
-    } })
-    expect(notJson.status).toBe(400)
-
-    const missingDecision = await invoke(route, { on: (event: string, listener: (chunk?: Buffer) => void) => {
-      if (event === 'data') listener(Buffer.from(JSON.stringify({ sessionId: 's1', proposalId: 'abc123def456' })))
-      if (event === 'end') listener()
-    } })
-    expect(missingDecision.status).toBe(400)
-
-    const badDecision = await invoke(route, { on: (event: string, listener: (chunk?: Buffer) => void) => {
-      if (event === 'data') listener(Buffer.from(JSON.stringify({ sessionId: 's1', proposalId: 'abc123def456', decision: 'maybe' })))
-      if (event === 'end') listener()
-    } })
-    expect(badDecision.status).toBe(400)
-  })
-
-  it('maps decide outcomes to 200, 404, and 503', async () => {
-    const routes: RegisteredRoute[] = []
-    const runtime = new Context()
-    ctx = runtime
-    await mountWebServer(runtime, routes)
-    mountReviewServices(runtime, { reviewOn: true })
-    apply(runtime, { reviewQueueRoute: true })
-    await settle()
-    const route = routes.find(candidate => candidate.path === DECIDE_ROUTE) as RegisteredRoute
-
-    const post = (body: unknown): unknown => ({
-      on: (event: string, listener: (chunk?: Buffer) => void) => {
-        if (event === 'data') listener(Buffer.from(JSON.stringify(body)))
-        if (event === 'end') listener()
-      },
-    })
-
-    const ok = await invoke(route, post({ sessionId: 's1', proposalId: 'abc123def456', decision: 'approved' }))
-    expect(ok.status).toBe(200)
-    expect(JSON.parse(String(ok.body))).toMatchObject({ ok: true, decision: 'approved' })
-
-    const unknownProposal = await invoke(route, post({ sessionId: 's1', proposalId: 'nope', decision: 'approved' }))
-    expect(unknownProposal.status).toBe(404)
-
-    const unknownSession = await invoke(route, post({ sessionId: 'nope', proposalId: 'abc123def456', decision: 'approved' }))
-    expect(unknownSession.status).toBe(404)
-  })
-
-  it('answers 503 when review mode is off for the session', async () => {
-    const routes: RegisteredRoute[] = []
-    const runtime = new Context()
-    ctx = runtime
-    await mountWebServer(runtime, routes)
-    mountReviewServices(runtime, { reviewOn: false })
-    apply(runtime, { reviewQueueRoute: true })
-    await settle()
-
-    const queueRoute = routes.find(candidate => candidate.path === QUEUE_ROUTE) as RegisteredRoute
-    expect((await invoke(queueRoute, { url: `${QUEUE_ROUTE}?sessionId=s1` })).status).toBe(200)
-
-    const decideRoute = routes.find(candidate => candidate.path === DECIDE_ROUTE) as RegisteredRoute
-    const response = await invoke(decideRoute, {
-      on: (event: string, listener: (chunk?: Buffer) => void) => {
-        if (event === 'data') listener(Buffer.from(JSON.stringify({ sessionId: 's1', proposalId: 'abc123def456', decision: 'approved' })))
-        if (event === 'end') listener()
-      },
-    })
-    expect(response.status).toBe(503)
-  })
-})