dsh-llm-verifier 0.3.0 → 0.4.0

package/src/replay.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest'
+import { parseStatisticsRecords, replayDecisionScores, sweepThresholds } from './replay.ts'
+
+const statistics = JSON.stringify({
+  version: 1,
+  records: [
+    { toolName: 'verifier_current_session', startedAt: 1, success: true, verdict: { phase: 'final', score: 1, baselineScore: 0, winner: 'A', criteria: [{ id: 'a', score: 1 }, { id: 'b', score: 1 }], threshold: 0.65 } },
+    { toolName: 'verifier_current_session', startedAt: 2, success: true, verdict: { phase: 'final', score: 0.6, baselineScore: 0, winner: 'A', criteria: [{ id: 'a', score: 1 }, { id: 'b', score: 0.2 }], threshold: 0.65 } },
+    { toolName: 'verifier_current_session', startedAt: 3, success: false },
+    { toolName: 'verifier_compare', startedAt: 4, success: true, verdict: { phase: 'compare', score: 0.9, scoreB: 0.1, winner: 'A' } },
+  ],
+})
+
+describe('parseStatisticsRecords', () => {
+  it('reads the verdict fields a sweep needs and survives a malformed document', () => {
+    const records = parseStatisticsRecords(statistics)
+    expect(records).toHaveLength(4)
+    expect(records[0]).toMatchObject({ toolName: 'verifier_current_session', score: 1, winner: 'A' })
+    expect(records[0]!.criteria).toEqual([{ id: 'a', score: 1 }, { id: 'b', score: 1 }])
+    // A failed invocation has no verdict at all: it must still parse, with no score.
+    expect(records[2]).toMatchObject({ success: false, criteria: [] })
+    expect(records[2]!.score).toBeUndefined()
+    expect(parseStatisticsRecords('not json')).toEqual([])
+    expect(parseStatisticsRecords('{"version":1}')).toEqual([])
+  })
+})
+
+describe('sweepThresholds', () => {
+  it('reports what each threshold decides, including the per-criterion floor', () => {
+    const records = parseStatisticsRecords(statistics)
+    const rows = sweepThresholds(records, [0.5, 0.65, 0.9])
+    // Only the two session acceptances are gate decisions: compare uses another threshold.
+    expect(rows.every(row => row.total === 3)).toBe(true)
+    // At 0.5 the second record's mean (0.6) clears the bar, but its criterion b = 0.2 does not:
+    // that is exactly the failure the mean alone used to hide.
+    expect(rows.find(row => row.threshold === 0.5)).toMatchObject({ accepted: 1, rejectedVerdict: 0, rejectedMean: 0, rejectedCriterion: 1, unscored: 1 })
+    // At 0.65 the mean itself is short, so the floor never comes into play for that record.
+    expect(rows.find(row => row.threshold === 0.65)).toMatchObject({ accepted: 1, rejectedMean: 1, rejectedCriterion: 0, unscored: 1 })
+    expect(rows.find(row => row.threshold === 0.9)).toMatchObject({ accepted: 1, rejectedVerdict: 0, rejectedMean: 1, rejectedCriterion: 0, unscored: 1 })
+  })
+
+  it('bounds the sweep at the extremes instead of producing NaN', () => {
+    const records = parseStatisticsRecords(statistics)
+    // A threshold of 0 disables the floor as well: every scored acceptance passes (the one
+    // unscored record is never an acceptance, at any threshold).
+    expect(sweepThresholds(records, [0])[0]).toMatchObject({ accepted: 2, rejectedCriterion: 0, unscored: 1 })
+    expect(sweepThresholds(records, [1])[0]).toMatchObject({ accepted: 1, rejectedMean: 1 })
+    expect(sweepThresholds([], [0.65])[0]).toMatchObject({ total: 0, accepted: 0 })
+  })
+})
+
+describe('replayDecisionScores', () => {
+  it('re-parses a stored explicit-tag answer and flags drift and unparseable answers', () => {
+    const rows = replayDecisionScores([
+      // K is the 10th letter: (20 - 10) - 1 over 19 = 9/19.
+      { label: 'clean', channel: 'explicit-tag', output: '<score_A> K </score_A>\n<score_B> T </score_B>', score: 9 / 19 },
+      { label: 'changed', channel: 'explicit-tag', output: '<score_A> A </score_A>\n<score_B> T </score_B>', score: 0.5 },
+      // A tag that is present but carries no valid letter is a real parser failure.
+      { label: 'broken', channel: 'explicit-tag', output: '<score_A> ZZ </score_A>', score: 0.5 },
+      { label: 'distribution', channel: 'top-logprobs', output: '<score_A> A </score_A>', score: 0.83 },
+    ])
+    expect(rows[0]).toMatchObject({ mode: 'match', reparsed: 9 / 19 })
+    expect(rows[1]).toMatchObject({ mode: 'drift', reparsed: 1 })
+    expect(rows[2]!.mode).toBe('unreadable')
+    // A top-logprobs score is an expectation over a distribution the snapshot does not keep.
+    expect(rows[3]).toMatchObject({ mode: 'drift', stored: 0.83 })
+  })
+
+  it('replays a progress answer against the last checkpoint, inverted, and ignores non-scoring calls', () => {
+    const rows = replayDecisionScores([
+      // Track stores the LAST checkpoint and progresses A(=0) .. T(=1): <c2> T </c2> is 1.0.
+      { label: 'progress repeat 1/3', channel: 'explicit-tag', output: '<c1> K </c1>\n<c2> T </c2>', score: 1 },
+      { label: 'progress repeat 2/3', channel: 'explicit-tag', output: '<c1> K </c1>\n<c2> T </c2>', score: 0.5 },
+      // A route classification answers strict JSON — no score tag exists by design, and counting
+      // it as unreadable made every routing snapshot look like a regression.
+      { label: 'route classify', channel: 'explicit-tag', output: '{"kind":"none","confidence":0.9}', score: undefined },
+    ])
+    expect(rows[0]).toMatchObject({ mode: 'match', reparsed: 1 })
+    expect(rows[1]).toMatchObject({ mode: 'drift', reparsed: 1 })
+    expect(rows[2]!.mode).toBe('not-scored')
+  })
+})

package/src/replay.ts

@@ -0,0 +1,155 @@
+import { extractScore } from './core.ts'
+import { sessionAccepted } from './auto.ts'
+
+/** One persisted invocation, reduced to the fields an acceptance decision depends on. */
+export interface ReplayInvocation {
+  toolName: string
+  startedAt: number
+  success: boolean
+  score?: number
+  baselineScore?: number
+  winner?: 'A' | 'B' | 'tie'
+  criteria: Array<{ id: string; score: number }>
+}
+
+function numberAt(row: Record<string, unknown>, key: string): number | undefined {
+  const value = row[key]
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+/**
+ * Read one topic's statistics file into the records a threshold sweep can replay.
+ *
+ * Loose on purpose, exactly like the store's own loader: a record written by an older or newer
+ * plugin must not abort the replay. Records that carry no verdict (failed invocations) come back
+ * with no score, and the sweep reports them as unscored rather than as acceptances.
+ * @param text - raw `verifier/statistics-v1.json`.
+ * @returns The parsed invocations; an unreadable document yields an empty list.
+ */
+export function parseStatisticsRecords(text: string): ReplayInvocation[] {
+  let document: unknown
+  try { document = JSON.parse(text) } catch { return [] }
+  const records = typeof document === 'object' && document !== null ? (document as { records?: unknown }).records : undefined
+  if (!Array.isArray(records)) return []
+  const out: ReplayInvocation[] = []
+  for (const entry of records) {
+    if (typeof entry !== 'object' || entry === null) continue
+    const row = entry as Record<string, unknown>
+    const verdict = typeof row.verdict === 'object' && row.verdict !== null ? row.verdict as Record<string, unknown> : {}
+    const criteria: Array<{ id: string; score: number }> = []
+    for (const item of Array.isArray(verdict.criteria) ? verdict.criteria : []) {
+      if (typeof item !== 'object' || item === null) continue
+      const criterion = item as Record<string, unknown>
+      if (typeof criterion.id !== 'string') continue
+      const score = numberAt(criterion, 'score')
+      if (score !== undefined) criteria.push({ id: criterion.id, score })
+    }
+    const score = numberAt(verdict, 'score')
+    const baselineScore = numberAt(verdict, 'baselineScore')
+    const winner = verdict.winner === 'A' || verdict.winner === 'B' || verdict.winner === 'tie' ? verdict.winner : undefined
+    out.push({
+      toolName: typeof row.toolName === 'string' ? row.toolName : '',
+      startedAt: numberAt(row, 'startedAt') ?? 0,
+      success: row.success === true,
+      criteria,
+      ...(score !== undefined ? { score } : {}),
+      ...(baselineScore !== undefined ? { baselineScore } : {}),
+      ...(winner !== undefined ? { winner } : {}),
+    })
+  }
+  return out
+}
+
+/** Why a recorded acceptance failed at one threshold, so a sweep shows WHAT the threshold decides. */
+export interface ThresholdRow {
+  threshold: number
+  total: number
+  accepted: number
+  /** Losing to the empty-work baseline (or an unreadable verdict) can never pass. */
+  rejectedVerdict: number
+  /** The mean itself was below the threshold. */
+  rejectedMean: number
+  /** The mean passed but at least one criterion was below the threshold. */
+  rejectedCriterion: number
+  /** The record has no usable score (a failed invocation). */
+  unscored: number
+}
+
+/**
+ * Re-score every recorded session acceptance at each threshold with the LIVE acceptance rule.
+ *
+ * This is the tuning tool the plan calls for: `autoVerifyThreshold` (and the per-criterion
+ * floor that {@link sessionAccepted} applies) is currently a hand-picked number with no evidence
+ * behind it. The stored verdict already carries the session score, the baseline score, the winner
+ * and the per-criterion scores — everything the gate looked at — so a sweep costs no model calls.
+ *
+ * Only `verifier_current_session` records are gate decisions; routed compare/select/track
+ * verdicts use different thresholds and are skipped.
+ * @param invocations - records from {@link parseStatisticsRecords}.
+ * @param thresholds - thresholds to test, typically 0.5..0.9.
+ * @returns One row per threshold, in the given order.
+ */
+export function sweepThresholds(invocations: readonly ReplayInvocation[], thresholds: readonly number[]): ThresholdRow[] {
+  const gateRecords = invocations.filter(record => record.toolName === 'verifier_current_session')
+  return thresholds.map(threshold => {
+    const row: ThresholdRow = { threshold, total: gateRecords.length, accepted: 0, rejectedVerdict: 0, rejectedMean: 0, rejectedCriterion: 0, unscored: 0 }
+    for (const record of gateRecords) {
+      if (record.score === undefined || record.winner === undefined) { row.unscored += 1; continue }
+      if (sessionAccepted({ score: record.score, winner: record.winner, criteria: record.criteria }, threshold)) { row.accepted += 1; continue }
+      if (record.winner !== 'A') row.rejectedVerdict += 1
+      else if (record.score < threshold) row.rejectedMean += 1
+      else row.rejectedCriterion += 1
+    }
+    return row
+  })
+}
+
+/** One captured judge call re-parsed through the current scorer. */
+export interface DecisionReplayRow {
+  label: string
+  channel: string
+  stored?: number
+  reparsed?: number
+  /**
+   * `not-scored` means the answer carries no score tag at all — a route classification, or any
+   * other non-scoring call. Counting those as failures made the report cry wolf on every
+   * `track` and `verifier_route_classify` snapshot.
+   */
+  mode: 'match' | 'drift' | 'unreadable' | 'not-scored'
+}
+
+/**
+ * Re-parse captured judge answers with the current score parser.
+ *
+ * A snapshot stores the raw answer, so the parser can be replayed offline: a pairwise call must
+ * parse back to exactly the score it produced, and a drift means the parser (or the prompt format)
+ * changed under a stored answer. A top-logprobs call's stored score is an expectation over a token
+ * distribution the snapshot does not keep, so a text-channel re-parse is expected to differ and is
+ * reported as drift — read those rows as informational, not as regressions.
+ *
+ * The tag depends on the call: pairwise judging answers `<score_A>`, while progress judging answers
+ * `<c1>..<cN>` and the trace stores the LAST checkpoint, inverted (progress runs A = nothing done
+ * .. T = certainly done, the reverse of the pairwise scale). A call with neither tag is a route
+ * classification, i.e. not a score at all.
+ * @param calls - captured calls with their raw answers.
+ * @returns One row per call.
+ */
+export function replayDecisionScores(calls: ReadonlyArray<{ label: string; channel: string; output: string; score?: number }>): DecisionReplayRow[] {
+  return calls.map(call => {
+    const completion = { text: call.output, tokens: [], positions: [] }
+    const progressTags = [...call.output.matchAll(/<c(\d+)>/gu)].map(match => '<c' + match[1] + '>')
+    const tagged = call.output.includes('<score_A>') || progressTags.length > 0
+    let reparsed: number | undefined
+    if (tagged) {
+      try {
+        reparsed = call.output.includes('<score_A>')
+          ? extractScore(completion, '<score_A>')
+          : 1 - extractScore(completion, progressTags[progressTags.length - 1]!)
+      } catch { reparsed = undefined }
+    }
+    const head = { label: call.label, channel: call.channel, ...(call.score !== undefined ? { stored: call.score } : {}) }
+    if (!tagged) return { ...head, mode: 'not-scored' as const }
+    if (reparsed === undefined) return { ...head, mode: 'unreadable' as const }
+    return { ...head, reparsed, mode: call.score !== undefined && Math.abs(call.score - reparsed) < 1e-9 ? 'match' as const : 'drift' as const }
+  })
+}

package/src/router.test.ts

@@ -13,10 +13,18 @@ function tool(value: ReturnType<typeof session>, name: string, id: string, text:
   value.append('tool/call', { turn, step, callId: id as never, name, arguments: '{}' })
   value.append('tool/result', { turn, step, message: createToolResultMessage({ callId: id as never, content: [{ type: 'text', text }], isError: false }) }, { surfaceOp: 'append' })
 }
+/** The full-output evidence block of one rendered step, i.e. everything before its digest. */
+function evidenceBlock(step: string): string {
+  const start = step.indexOf('Latest observed tool output')
+  if (start < 0) return ''
+  const rest = step.slice(start)
+  const end = rest.indexOf('\n\n')
+  return end < 0 ? rest : rest.slice(0, end)
+}
 function assistant(value: ReturnType<typeof session>, text: string, turn = 1, step = 1) {
   value.append('assistant/message', { turn, step, message: createAssistantMessage({ content: [{ type: 'text', text }], source: { provider: 'deepseek-official', model: 'deepseek-v4-flash' } }) }, { surfaceOp: 'append' })
 }
-const policy: RouterPolicy = { mode: 'smart', minConfidence: .9, maxCandidates: 8, maxPerTask: 5, maxPerSession: 20, maxModelCallsPerTask: 48, maxModelCallsPerSession: 160, maxInputChars: 60000, maxItemChars: 20000 }
+const policy: RouterPolicy = { mode: 'smart', minConfidence: .9, maxCandidates: 8, maxRoutePerTask: 5, maxRoutePerSession: 20, maxFinalPerTask: 2, maxFinalPerSession: 8, maxModelCallsPerTask: 48, maxModelCallsPerSession: 160, maxInputChars: 60000, maxItemChars: 20000 }
 const envelope = (count: number) => JSON.stringify({ protocol: 'dsh-verifier-candidates', version: 1, groupId: 'auth', candidates: Array.from({ length: count }, (_, i) => ({ id: String(i + 1), label: 'C' + (i + 1), status: 'completed', content: 'candidate ' + (i + 1) })) })
 
 describe('production structured routing', () => {
@@ -162,6 +170,193 @@ describe('production structured routing', () => {
     expect(decision.steps[1]).not.toContain('counts:')
   })
 
+  it('never attaches a deliverable presentation as checkpoint evidence', () => {
+    // Regression (live session, four routes in a row): `present` is the last call of a
+    // turn, so the newest "observed tool output" reaching the judge was the wrapper's
+    // `presented: 1` — the paths the agent had just declared — while the typecheck and
+    // test run sat one call earlier. The judge's own rule ("a state without real
+    // verification should not exceed K") then capped the newest checkpoint at exactly
+    // K = 52.6% against a 0.8 threshold, so every route steered "continue the
+    // unfinished work" for work that was finished and verified, until the per-task
+    // route budget ran out.
+    const value = session()
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'in_progress' }, { content: 'Test', status: 'pending' }] })
+    tool(value, 'pwsh', 'verify', 'TYPECHECK_EXIT=0\nTests 309 passed')
+    value.append('tool/call', { turn: 1, step: 1, callId: 'wrap' as never, name: 'run_code', arguments: '{}' })
+    value.append('tool/ptc-dispatch' as never, { rootCallId: 'wrap', subCallId: 'wrap:ptc:1', name: 'present', arguments: '{}', isError: false, content: [{ type: 'text', text: 'Presented C:\\repo\\src\\mapper.ts' }] } as never)
+    value.append('tool/result', { turn: 1, step: 1, message: createToolResultMessage({ callId: 'wrap' as never, content: [{ type: 'text', text: 'presented: 1' }], isError: false }) }, { surfaceOp: 'append' })
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'completed' }, { content: 'Test', status: 'completed' }] })
+    const decision = analyzeStructuredRoute(value.events, 8, 20000, 60000)
+    expect(decision?.kind).toBe('track')
+    if (decision?.kind !== 'track') return
+    // The verification run is older than the presentation and must still win the
+    // evidence slot; the presentation survives only as one line of digest context.
+    const step = decision.steps[1]!
+    expect(evidenceBlock(step)).toContain('309 passed')
+    expect(evidenceBlock(step)).not.toContain('Presented C:')
+    expect(evidenceBlock(step)).not.toContain('presented: 1')
+    expect(step).toContain('Recent tool results')
+    expect(step).toContain('present: Presented C:')
+  })
+
+  it('shows the newest verification run when the newest output is not one', () => {
+    // Regression (live session): the full suite passed, then 88 tool calls closed issues
+    // and printed a status summary. The newest checkpoint carried only that summary, so
+    // the judge applied its own "no real verification" ceiling — exactly K = 52.6%
+    // against a 0.8 threshold — and the route steered "continue" for finished work.
+    const value = session()
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'in_progress' }, { content: 'Test', status: 'pending' }] })
+    tool(value, 'pwsh', 'verify', 'Test Files  10 passed (10)\n     Tests  86 passed (86)')
+    tool(value, 'pwsh', 'close', '1517 closed completed')
+    tool(value, 'pwsh', 'status', '--- ahead/behind origin/dev ---\n0\t0\nlib-artifact-check: OK')
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'completed' }, { content: 'Test', status: 'completed' }] })
+    const decision = analyzeStructuredRoute(value.events, 8, 20000, 60000)
+    expect(decision?.kind).toBe('track')
+    if (decision?.kind !== 'track') return
+    const step = decision.steps[1]!
+    // The newest output stays the primary evidence...
+    expect(step).toContain('lib-artifact-check: OK')
+    // ...and the run it was hiding comes back, with how much happened after it.
+    expect(step).toContain('Latest observed verification run')
+    expect(step).toContain('86 passed')
+    expect(step).toContain('tool result(s) since')
+    // Historical checkpoints never grow this block: they describe past states.
+    expect(decision.steps[0]).not.toContain('Latest observed verification run')
+  })
+
+  it('does not repeat a verification run that is already the newest output', () => {
+    const value = session()
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'in_progress' }, { content: 'Test', status: 'pending' }] })
+    tool(value, 'pwsh', 'verify', 'Test Files  1 passed (1)\n     Tests  9 passed (9)')
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'completed' }, { content: 'Test', status: 'completed' }] })
+    const decision = analyzeStructuredRoute(value.events, 8, 20000, 60000)
+    expect(decision?.kind).toBe('track')
+    if (decision?.kind !== 'track') return
+    expect(decision.steps[1]).toContain('Latest observed tool output at routing time')
+    expect(decision.steps[1]).not.toContain('Latest observed verification run')
+  })
+
+  it('leaves the checkpoints alone when the task never verified anything', () => {
+    const value = session()
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'in_progress' }, { content: 'Test', status: 'pending' }] })
+    tool(value, 'pwsh', 'edit', 'The file has been updated successfully.')
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'completed' }, { content: 'Test', status: 'completed' }] })
+    const decision = analyzeStructuredRoute(value.events, 8, 20000, 60000)
+    expect(decision?.kind).toBe('track')
+    if (decision?.kind !== 'track') return
+    expect(decision.steps[1]).toContain('The file has been updated successfully.')
+    expect(decision.steps[1]).not.toContain('Latest observed verification run')
+  })
+
+  it('keeps the extra verification block inside the checkpoint caps', () => {
+    const value = session()
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'in_progress' }, { content: 'Test', status: 'pending' }] })
+    tool(value, 'pwsh', 'verify', 'Test Files  10 passed (10)\n' + 'T'.repeat(4000))
+    tool(value, 'pwsh', 'tail', 'Z'.repeat(4000))
+    assistant(value, 'Q'.repeat(4000))
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'completed' }, { content: 'Test', status: 'completed' }] })
+    for (const maxItemChars of [128, 200, 500, 2000, 20000]) {
+      const maxInputChars = Math.max(60000, maxItemChars * 2)
+      const decision = analyzeStructuredRoute(value.events, 8, maxItemChars, maxInputChars)
+      expect(decision, 'maxItemChars=' + maxItemChars).toMatchObject({ kind: 'track' })
+      if (decision?.kind !== 'track') continue
+      for (const step of decision.steps) expect(step.length, 'maxItemChars=' + maxItemChars).toBeLessThanOrEqual(maxItemChars)
+      expect(decision.steps.reduce((sum, step) => sum + step.length, 0), 'maxItemChars=' + maxItemChars).toBeLessThanOrEqual(maxInputChars)
+      expect(boundDecision(decision, { ...policy, maxItemChars, maxInputChars }), 'maxItemChars=' + maxItemChars).toBeDefined()
+    }
+  })
+
+  it('never attaches coordination output as checkpoint evidence', () => {
+    // The same rule as `present`, applied to the rest of the agent's own control
+    // surface: every one of these runs AFTER the work, so as the newest result it hides
+    // the verification run and the judge caps the checkpoint at K — the ceiling its own
+    // prompt sets for "no real verification" — against the 0.8 progress threshold.
+    const value = session()
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'in_progress' }, { content: 'Test', status: 'pending' }] })
+    tool(value, 'pwsh', 'verify', 'TYPECHECK_EXIT=0\nTests 309 passed')
+    tool(value, 'job_list', 'jobs', '(no background jobs)')
+    tool(value, 'job_kill', 'kill', 'requested cancellation of job job-1')
+    tool(value, 'send_message', 'send', '{"messageId":"m1"}')
+    tool(value, 'list_subagent_models', 'models', 'antigravity/gemini-3.8-flash — Gemini 3.8 Flash')
+    // A previous verdict is not observed work output either: grading progress from it
+    // would be the judge grading itself.
+    tool(value, 'verifier_current_session', 'verdict', '{"winner":"A","score":1,"baselineScore":0,"threshold":0.65}')
+    tool(value, 'subagent', 'child', 'started subagent 042f004d-fe19-4ccb-8b98-f08a00b32e87')
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'completed' }, { content: 'Test', status: 'completed' }] })
+    const decision = analyzeStructuredRoute(value.events, 8, 20000, 60000)
+    expect(decision?.kind).toBe('track')
+    if (decision?.kind !== 'track') return
+    const step = decision.steps[1]!
+    expect(evidenceBlock(step)).toContain('309 passed')
+    for (const marker of ['(no background jobs)', 'requested cancellation', 'messageId', 'Gemini 3.8 Flash', '"baselineScore"', 'started subagent']) {
+      expect(evidenceBlock(step), marker).not.toContain(marker)
+    }
+    // The digest still shows them as one-line context — that tail is what the judge has
+    // to weigh — but a previous verdict never appears at all.
+    expect(step).toContain('Recent tool results')
+    expect(step).toContain('(no background jobs)')
+    expect(step).not.toContain('verifier_current_session')
+  })
+
+  it('summarises the recent calls in one line each, newest last', () => {
+    // The verification block says HOW MUCH happened after the run; the digest says WHAT,
+    // so a judge can tell "only issue bookkeeping since" from "twelve writes since".
+    const value = session()
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'in_progress' }, { content: 'Test', status: 'pending' }] })
+    tool(value, 'pwsh', 'verify', 'Test Files  3 passed (3)\n     Tests  12 passed (12)')
+    tool(value, 'pwsh', 'close', '1517 closed completed')
+    tool(value, 'todo_write', 'todos', 'Updated todo list: 0 pending, 0 in progress, 13 completed.')
+    tool(value, 'present', 'present', 'Presented C:\\repo\\src\\mapper.ts')
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'completed' }, { content: 'Test', status: 'completed' }] })
+    const decision = analyzeStructuredRoute(value.events, 8, 20000, 60000)
+    expect(decision?.kind).toBe('track')
+    if (decision?.kind !== 'track') return
+    const step = decision.steps[1]!
+    const digest = step.slice(step.indexOf('Recent tool results'))
+    expect(digest).toContain('pwsh: 1517 closed completed')
+    expect(digest).toContain('todo_write: Updated todo list')
+    expect(digest).toContain('present: Presented C:')
+    // Newest last, and the two calls already rendered in full are marked, not repeated.
+    expect(digest.indexOf('1517 closed completed')).toBeLessThan(digest.indexOf('present: Presented C:'))
+    expect(digest).toContain('[shown above]')
+    // Historical checkpoints describe past states and never grow the digest.
+    expect(decision.steps[0]).not.toContain('Recent tool results')
+  })
+
+  it('keeps a foreground subagent report as checkpoint evidence', () => {
+    // Only the start acknowledgement is coordination. A foreground child returns the
+    // report it was asked for, which for delegated work is the deliverable itself.
+    const value = session()
+    value.append('todo/write', { todos: [{ content: 'Investigate', status: 'in_progress' }, { content: 'Report', status: 'pending' }] })
+    tool(value, 'subagent', 'child', 'Report: the mapper drops image parts when resolveRequestImages is undefined.')
+    value.append('todo/write', { todos: [{ content: 'Investigate', status: 'completed' }, { content: 'Report', status: 'completed' }] })
+    const decision = analyzeStructuredRoute(value.events, 8, 20000, 60000)
+    expect(decision?.kind).toBe('track')
+    if (decision?.kind !== 'track') return
+    expect(decision.steps[1]).toContain('the mapper drops image parts')
+  })
+
+  it('treats a wrapper that only started a background child as coordination', () => {
+    // In the PTC preset the picked result is the wrapper's own text, so the
+    // acknowledgement has to be recognised on the dispatch as well.
+    const value = session()
+    tool(value, 'pwsh', 'verify', 'all tests passed: 91 passed')
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'in_progress' }, { content: 'Test', status: 'pending' }] })
+    value.append('tool/call', { turn: 1, step: 1, callId: 'wrap' as never, name: 'run_code', arguments: '{}' })
+    value.append('tool/ptc-dispatch' as never, { rootCallId: 'wrap', subCallId: 'wrap:ptc:1', name: 'subagent', arguments: '{}', isError: false, content: [{ type: 'text', text: 'started subagent 042f004d' }] } as never)
+    value.append('tool/result', { turn: 1, step: 1, message: createToolResultMessage({ callId: 'wrap' as never, content: [{ type: 'text', text: 'started subagent 042f004d' }], isError: false }) }, { surfaceOp: 'append' })
+    value.append('todo/write', { todos: [{ content: 'Implement', status: 'completed' }, { content: 'Test', status: 'completed' }] })
+    const decision = analyzeStructuredRoute(value.events, 8, 20000, 60000)
+    expect(decision?.kind).toBe('track')
+    if (decision?.kind !== 'track') return
+    const step = decision.steps[1]!
+    expect(evidenceBlock(step)).toContain('all tests passed')
+    expect(evidenceBlock(step)).not.toContain('started subagent')
+    // It is still visible as digest context: the point is not to hide the call, it is to
+    // stop an acknowledgement from occupying the evidence slot.
+    expect(step).toContain('started subagent')
+  })
+
   it('keeps a wrapper that dispatched real work', () => {
     const value = session()
     value.append('tool/call', { turn: 1, step: 1, callId: 'wrap' as never, name: 'run_code', arguments: '{}' })
@@ -236,10 +431,18 @@ describe('semantic evidence references', () => {
     tool(value, 'subagent', 'a', 'candidate A from a real subagent')
     tool(value, 'create_goal', 'goal', '{"goal":{"id":"g1","phase":"active"}}')
     tool(value, 'skill', 'skill', 'loaded review skill body')
+    tool(value, 'present', 'present', 'Presented C:\\repo\\src\\mapper.ts')
+    tool(value, 'job_list', 'jobs', '(no background jobs)')
+    tool(value, 'verifier_current_session', 'verdict', '{"winner":"A","score":1}')
+    tool(value, 'subagent', 'child-bg', 'started subagent 042f004d')
     const prompt = buildSemanticRoutePrompt('pick the better one', value.events, 8, 20000, 60000)
     expect(prompt).toContain('candidate A from a real subagent')
     expect(prompt).not.toContain('"phase":"active"')
     expect(prompt).not.toContain('loaded review skill body')
+    expect(prompt).not.toContain('Presented C:')
+    expect(prompt).not.toContain('(no background jobs)')
+    expect(prompt).not.toContain('"winner":"A"')
+    expect(prompt).not.toContain('started subagent')
   })
 
   it('rejects a semantic decision that cites bookkeeping evidence', () => {
@@ -396,6 +599,36 @@ describe('transactional router state', () => {
     const final = router.reserve(agent, 'final', 'final', 4, policy)!
     expect(router.commit(agent, final)).toBe(true); expect(router.finalRequired(agent)).toBeUndefined()
   })
+  it('reserves final-verification budget independently of routing attempts', () => {
+    const value = session(); const agent = { id: value.id, session: value }; const router = new AutoVerifierRouter()
+    // Routing gets exactly its own cap: exhausting it must not refuse the armed final gate.
+    const budget = { ...policy, maxRoutePerTask: 1, maxFinalPerTask: 2 }
+    const first = router.reserve(agent, 'track', 'route-1', 1, budget)
+    expect(first).toBeDefined()
+    expect(router.commit(agent, first!, 7)).toBe(true)
+    expect(router.finalRequired(agent)).toBe(7)
+    expect(router.reserve(agent, 'track', 'route-2', 1, budget)).toBeUndefined()
+    expect(router.budgetExhausted(agent, 1, budget)).toBe(true)
+    const final = router.reserve(agent, 'final', 'final-1', 4, budget)
+    expect(final).toBeDefined()
+    expect(router.commit(agent, final!)).toBe(true)
+    expect(router.finalRequired(agent)).toBeUndefined()
+  })
+  it('prefers the final gate after a track route clears the completion threshold', () => {
+    const value = session(); const agent = { id: value.id, session: value }; const router = new AutoVerifierRouter()
+    expect(router.finalPreferred(agent)).toBe(false)
+    const track = router.reserve(agent, 'track', 'track-pass', 3, policy)!
+    expect(router.commit(agent, track, 9)).toBe(true)
+    router.preferFinal(agent)
+    expect(router.finalPreferred(agent)).toBe(true)
+    // Reserving the final attempt consumes the preference, and a failed acceptance must
+    // release routing again rather than disabling it for the rest of the task.
+    const final = router.reserve(agent, 'final', 'final', 4, policy)!
+    expect(router.finalPreferred(agent)).toBe(false)
+    router.fail(agent, final, false)
+    expect(router.finalPreferred(agent)).toBe(false)
+    expect(router.reserve(agent, 'track', 'route-after-failure', 1, policy)).toBeDefined()
+  })
   it('does not arm final verification when a plan pre-review passes', () => {
     const value = session(); const agent = { id: value.id, session: value }; const router = new AutoVerifierRouter()
     const plan = router.reserve(agent, 'plan_review', 'plan', 1, policy)!
@@ -442,6 +675,12 @@ describe('transactional router state', () => {
     expect(routedRepeats(select, 3)).toBe(3)
     expect(routedRepeats(track, 1)).toBe(1)
     expect(routedRepeats(track, 3)).toBe(3)
+    // track carries its own count: with the explicit-tag channel one call samples ONE
+    // letter (5.3% of the A-T scale), so repeats are averaged to keep sampling noise from
+    // flipping the progress curve between bands.
+    expect(routedRepeats(track, 1, 3)).toBe(3)
+    expect(routedRepeats(compare, 1, 3)).toBe(2)
+    expect(routedRepeats(select, 1, 3)).toBe(1)
   })
 
   it('estimates routed calls from the real tournament shape', () => {