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

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

@@ -71,6 +71,18 @@ 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' }
+  /**
+   * Human-gated review pipeline (beta): edge/high-impact candidates queue for
+   * manual approval and execute in one merged batch at the next turn boundary
+   * instead of the automatic path (R4).
+   */
+  readonly reviewMode: boolean
+  /** Turn-boundary patience: pending review proposals older than this many turns auto-expire (R4). */
+  readonly reviewTimeoutTurns: number
+  /** Cache-hit discount rate α in the benefit model; expectedSaving = α·R·Ŝ − (1−α)·tail. */
+  readonly cacheHitDiscountAlpha: number
+  /** Candidates whose tokenBefore reaches this threshold bypass payback triage and always enter review (R4). */
+  readonly reviewHighImpactTokens: number
 }
 
 /** Common user-authored Custom stages shared by persisted policy versions. */
@@ -128,6 +140,11 @@ export interface PresetOptionsSettings {
   readonly prefixStabilizer?: boolean
   readonly readState?: boolean
   readonly estimatorMode?: '' | 'host' | 'direct'
+  /** Review-mode overrides (beta); see PresetOptions.reviewMode. */
+  readonly reviewMode?: boolean
+  readonly reviewTimeoutTurns?: number
+  readonly cacheHitDiscountAlpha?: number
+  readonly reviewHighImpactTokens?: number
   /**
    * Estimator endpoint fields. Persisted-settings only: they never enter the
    * frozen CompressionPolicy, which is emitted verbatim by policy-resolved

package/packages/selector/tests/code-skeleton.client.spec.ts

@@ -56,8 +56,9 @@ describe('codeSkeleton confirm-on-write client contract', () => {
       settingsScope: { bind: vi.fn(() => scope) },
       slots: {
         inject: (_slot: string, install: () => unknown) => { install() },
-        register: (registration: { inject: () => CompressionSelectorInjected }) => {
-          injected = registration.inject
+        register: (registration: { inject?: () => CompressionSelectorInjected }) => {
+          // The R4 overlay registration carries no inject face; keep the card's.
+          if (typeof registration.inject === 'function') injected = registration.inject
           return () => {}
         },
       },

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

@@ -148,8 +148,9 @@ describe('context compression browser contract', () => {
       settingsScope: { bind: vi.fn(() => scope) },
       slots: {
         inject: (_slot: string, install: () => unknown) => { install() },
-        register: (registration: { inject: () => CompressionSelectorInjected }) => {
-          injected = registration.inject
+        register: (registration: { inject?: () => CompressionSelectorInjected }) => {
+          // The R4 overlay registration carries no inject face; keep the card's.
+          if (typeof registration.inject === 'function') injected = registration.inject
           return () => {}
         },
       },

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

@@ -123,7 +123,9 @@ function bindInjected(
         return typeof result === 'function' ? result : () => {}
       },
       register: (registerOptions: Record<string, unknown>) => {
-        options = registerOptions
+        // The R4 overlay registration rides the same slots service; only the
+        // settings card carries the inject factory these tests drive.
+        if (registerOptions.name === 'settings.section') options = registerOptions
         return () => {}
       },
     },
@@ -146,6 +148,37 @@ describe('presetOptions writes are path-addressed', () => {
     expect(writes).toEqual([[{ op: 'set', path: ['presetOptions', 'estimatorProvider'], value: 'local-35b' }]])
   })
 
+  it('writes and clears the review-mode fields without touching estimator siblings', async () => {
+    const { injected, writes, snapshot } = bindInjected({ estimatorMode: 'host' })
+    await injected.savePresetOptions({
+      reviewMode: true,
+      reviewTimeoutTurns: 8,
+      cacheHitDiscountAlpha: 0.2,
+      reviewHighImpactTokens: 6000,
+    })
+    expect(snapshot()['presetOptions']).toEqual({
+      estimatorMode: 'host',
+      reviewMode: true,
+      reviewTimeoutTurns: 8,
+      cacheHitDiscountAlpha: 0.2,
+      reviewHighImpactTokens: 6000,
+    })
+    await injected.savePresetOptions({ reviewMode: undefined })
+    expect(snapshot()['presetOptions']).toEqual({
+      estimatorMode: 'host',
+      reviewTimeoutTurns: 8,
+      cacheHitDiscountAlpha: 0.2,
+      reviewHighImpactTokens: 6000,
+    })
+    for (const batch of writes) {
+      for (const op of batch) {
+        expect(op.path).toEqual(['presetOptions', op.path[1] ?? ''])
+        expect(['reviewMode', 'reviewTimeoutTurns', 'cacheHitDiscountAlpha', 'reviewHighImpactTokens'])
+          .toContain(op.path[1])
+      }
+    }
+  })
+
   it('never replaces the whole section, so sibling overrides survive', async () => {
     const { injected, writes, snapshot } = bindInjected({
       estimatorMode: 'direct',

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

@@ -0,0 +1,118 @@
+// @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.host.spec.ts

@@ -0,0 +1,290 @@
+/**
+ * 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)
+  })
+})

package/packages/selector/tests/runtime/audit.spec.ts

@@ -126,4 +126,48 @@ describe('context-compression audit records', () => {
       }, record)
     }).not.toThrow()
   })
+
+  it('keeps review-outcome records free of proposal content', () => {
+    const record: CompressionAuditRecord = {
+      schemaVersion: 1,
+      kind: 'review-outcome',
+      sessionId: 'review-session',
+      proposalId: 'a1b2c3d4e5f6',
+      proposalKind: 'read-state',
+      event: 'apply-receipt',
+      receiptStatus: 'applied',
+      itemSeqs: [7, 9],
+      tokensBefore: 1400,
+      tokensAfter: 1000,
+      turnIndex: 12,
+    }
+
+    const line = formatCompressionAudit(record)
+    const parsed = JSON.parse(line.slice(COMPRESSION_AUDIT_PREFIX.length)) as CompressionAuditRecord
+    expect(parsed).toEqual(record)
+    // Only ids, enums, and numbers: no digests, no content fields.
+    expect(line).not.toContain('digest')
+    expect(line).not.toContain('"content"')
+    expect(line).not.toContain('"text"')
+    expect(line).not.toContain('apiKey')
+  })
+
+  it('carries reason codes on void and deferred review events', () => {
+    const record: CompressionAuditRecord = {
+      schemaVersion: 1,
+      kind: 'review-outcome',
+      sessionId: 'review-session',
+      proposalId: 'b2c3d4e5f6a1',
+      proposalKind: 'dedup',
+      event: 'apply-void',
+      reasonCode: 'review_receipt_digest_invalid',
+      itemSeqs: [3],
+      tokensBefore: 5000,
+      tokensAfter: 4000,
+    }
+    const parsed = JSON.parse(
+      formatCompressionAudit(record).slice(COMPRESSION_AUDIT_PREFIX.length),
+    ) as CompressionAuditRecord
+    expect(parsed).toEqual(record)
+  })
 })

package/packages/selector/tests/runtime/tokenpilot/estimator.spec.ts

@@ -9,6 +9,7 @@ import {
   buildEstimatorUserPrompt,
   isCoolingDown,
   parseEstimatorAnswer,
+  parseEstimatorAnswerDetailed,
 } from '../../../src/runtime/tokenpilot/estimator.ts'
 
 describe('tokenpilot estimator helpers', () => {
@@ -30,6 +31,28 @@ describe('tokenpilot estimator helpers', () => {
     expect(parseEstimatorAnswer('not json [')).toEqual([])
   })
 
+  it('reads the optional expectedRemainingTurns from the extended object form', () => {
+    const answer = parseEstimatorAnswerDetailed(
+      'Result: {"expectedRemainingTurns":7.9,"items":[{"seq":3,"expired":false}]} end',
+    )
+    expect(answer.verdicts).toEqual([{ seq: 3, expired: false }])
+    // Fractional estimates floor to whole turns.
+    expect(answer.expectedRemainingTurns).toBe(7)
+  })
+
+  it('stays Ŝ-less for legacy arrays and malformed turn fields', () => {
+    const legacy = parseEstimatorAnswerDetailed('Verdicts: [{"seq":7,"expired":true}] done')
+    expect(legacy.verdicts).toEqual([{ seq: 7, expired: true }])
+    expect(legacy.expectedRemainingTurns).toBeUndefined()
+    const malformed = parseEstimatorAnswerDetailed('{"expectedRemainingTurns":"soon","items":[{"seq":1,"expired":true}]}')
+    expect(malformed.verdicts).toEqual([{ seq: 1, expired: true }])
+    expect(malformed.expectedRemainingTurns).toBeUndefined()
+    // Negative estimates are rejected like any other non-numeric field.
+    const negative = parseEstimatorAnswerDetailed('{"expectedRemainingTurns":-2,"items":[{"seq":1,"expired":true}]}')
+    expect(negative.expectedRemainingTurns).toBeUndefined()
+    expect(negative.verdicts).toEqual([{ seq: 1, expired: true }])
+  })
+
   it('builds a path-only user prompt without file content', () => {
     const prompt = buildEstimatorUserPrompt([
       { seq: 4, path: 'src/a.ts', turn: 2 },

package/packages/selector/tests/runtime/tokenpilot/profile-baseline.spec.ts

@@ -61,6 +61,11 @@ describe('tokenpilot-inspired preset', () => {
       prefixStabilizer: true,
       readState: true,
       estimator: { mode: '' },
+      // Review pipeline (beta) ships off with its documented defaults.
+      reviewMode: false,
+      reviewTimeoutTurns: 6,
+      cacheHitDiscountAlpha: 0.1,
+      reviewHighImpactTokens: 4000,
     })
     // Other profiles never carry the capability matrix.
     expect(resolvePolicy(config, 'balanced').presetOptions).toBeUndefined()