dsh-llm-verifier 0.6.0 → 0.6.2

package/src/decisions.test.ts

@@ -113,6 +113,22 @@ describe('DecisionStore', () => {
     expect(document.records).toHaveLength(1)
   })
 
+  it('files a snapshot under the caller\'s invocation id, so the statistics row can resolve it', async () => {
+    // Regression: the dashboard lists statistics rows and asks for a row's snapshot BY the id it
+    // listed the row under. Two independently generated uuids made every lookup miss, and the panel
+    // then blamed pruning or a deleted topic while the snapshot sat in this very file.
+    const root = await mkdtemp(join(tmpdir(), 'dsh-verifier-decisions-'))
+    const file = join(root, 'decisions.json')
+    const store = new DecisionStore(file)
+    const record = await store.record({ id: 'invocation-7', toolName: 'verifier_current_session', phase: 'final', startedAt: 1, provider: 'p', model: 'm', calls: [call()] })
+    expect(record?.id).toBe('invocation-7')
+    expect(await store.find('invocation-7')).toMatchObject({ toolName: 'verifier_current_session' })
+    // An unusable id falls back to a fresh uuid instead of merging two invocations.
+    const fallback = await store.record({ id: '', toolName: 'verifier_track', phase: 'track', startedAt: 2, provider: 'p', model: 'm', calls: [call()] })
+    expect(fallback?.id).toBeTruthy()
+    expect(fallback?.id).not.toBe('')
+  })
+
   it('writes nothing when no call was captured', async () => {
     const root = await mkdtemp(join(tmpdir(), 'dsh-verifier-decisions-'))
     const file = join(root, 'decisions.json')

package/src/decisions.ts

@@ -148,6 +148,14 @@ export interface DecisionInput {
   provider: string
   model: string
   calls: readonly DecisionCall[]
+  /**
+   * Invocation id to file the snapshot under; a fresh uuid when omitted.
+   *
+   * The dashboard lists STATISTICS rows and asks for the snapshot of one row by ITS id, so the
+   * caller passes the id the statistics row was stored with. Two independent uuids made every
+   * lookup miss and the panel claim the snapshot was pruned or never captured.
+   */
+  id?: string
 }
 
 /**
@@ -171,7 +179,7 @@ export class DecisionStore {
     const calls = boundDecisionCalls(input.calls)
     if (calls.length === 0) return undefined
     const record: DecisionRecord = {
-      id: randomUUID(),
+      id: idOf(input.id),
       toolName: input.toolName,
       phase: input.phase,
       startedAt: input.startedAt,
@@ -228,6 +236,19 @@ export class DecisionStore {
   }
 }
 
+/**
+ * The id a snapshot is filed under.
+ *
+ * A caller-supplied id is the statistics row's own id ({@link DecisionInput.id}), which is what
+ * makes the dashboard's "one snapshot per row" lookup resolve; anything unusable falls back to a
+ * fresh uuid so a malformed argument can never merge two invocations into one record.
+ * @param candidate - id supplied by the caller, if any.
+ * @returns The id to store the record under.
+ */
+function idOf(candidate: string | undefined): string {
+  return typeof candidate === 'string' && candidate.length > 0 ? candidate : randomUUID()
+}
+
 /**
  * Loose validation, so a record written by a newer/older plugin still loads.
  * @param value - parsed JSON entry.

package/src/index.test.ts

@@ -723,6 +723,38 @@ describe('usage diagnostics in tool outputs', () => {
   })
 })
 
+/**
+ * The dashboard's "why did the judge decide that" path.
+ *
+ * The statistics row and its decision snapshot must share ONE id: the row is listed under it, the
+ * snapshot is filed under it, and the decision endpoint resolves "the snapshot of this row" by
+ * exactly that value. Two independently generated uuids made every click answer "pruned, never
+ * captured, or belongs to a deleted topic" while the snapshot sat in the topic sidecar.
+ */
+describe('decision snapshots behind a dashboard row', () => {
+  it('resolves the snapshot from the invocation id the row was listed under', async () => {
+    const { tools, rpc } = assemble(JUDGE, {
+      stream: () => textStream('reasoning\n<score_A> A </score_A>\n<score_B> T </score_B>'),
+      sessions: [{ id: 'session-1', createdAt: 1 }],
+    })
+    await tools.get('verifier_compare')!.execute({ problem: 'pick the better plan', candidate_a: 'AAA', candidate_b: 'BBB', repeats: 1 }, exec)
+    const handler = rpc.get('/llm-verifier')!
+    const overview = await handler('statistics', { fromMs: 0, toMs: Date.now() + 60_000 }) as { value: { recent: Array<{ id: string; toolName: string; success: boolean }> } }
+    const row = overview.value.recent.find(entry => entry.success)
+    expect(row).toBeDefined()
+
+    const found = await handler('decision', { id: row!.id }) as { ok: boolean; value?: { decision: { id: string; toolName: string; calls: Array<{ prompt: string; output: string }> } } }
+    expect(found.ok).toBe(true)
+    expect(found.value?.decision.id).toBe(row!.id)
+    expect(found.value?.decision.toolName).toBe('verifier_compare')
+    expect(found.value?.decision.calls.length).toBeGreaterThan(0)
+    expect(found.value?.decision.calls[0]?.prompt).toContain('pick the better plan')
+
+    // A genuinely unknown id still fails closed instead of inventing a snapshot.
+    expect(await handler('decision', { id: 'never-recorded' })).toMatchObject({ ok: false })
+  })
+})
+
 /**
  * The turn-stopping gate is the one place a manual pass would previously be honoured even
  * when it reviewed only an older slice of the task. These drive the REAL registered hook

package/src/index.ts

@@ -15,7 +15,7 @@ import { extractSession, sanitizeVerifierText, sessionEvents } from './session.t
 import { CriteriaResolver, type ResolvedCriteria } from './criteria.ts'
 import { analyzeAutoTask, automaticFeedback, compareRouteFeedbackDetail, failedAcceptanceCriteria, isSubagentSession, selectRouteFeedbackDetail, sessionAccepted, MAX_ROUTE_FEEDBACK_CHARS, type AcceptanceCriterion, type RoutedCandidateRef } from './auto.ts'
 import { AutoVerifierRouter, analyzeStructuredRoute, boundDecision, buildSemanticRouteView, estimateRoutedCalls, inspectDeliveryPhase, inspectRecoverySignal, latestDirectUserSeq, nextDiagnosticCycleId, parseSemanticRoute, routedRepeats, semanticDecision, semanticReferencesVisible, semanticRouteHint, type CandidateArtifact, type Reservation, type RouteDecision, type RoutedVerifierKind, type SemanticRouteView } from './router.ts'
-import type { ProcessActivityView } from './process-activity.ts'
+import { VerifierActivities, createActivityObserver, type ActivityView } from './verifier-activity.ts'
 import { ProcessCycleStore, ProcessSelector, resolveProcessFile, type ProcessCycleReport } from './process-selection.ts'
 import { DEFAULT_GROUND_TRUTH_NOTE, EMPTY_WORK_BASELINE, PROPOSAL_CRITERIA, buildGenerationPrompt, buildPairwisePrompt, extractScore, renderDiagnostics, renderReferenceContext, type Diagnostic, type ReviewStage } from './core.ts'
 import { buildPlanPreReviewPrompt, parseVerdictLetter, planFromArguments } from './plan-gate.ts'
@@ -198,7 +198,11 @@ export function apply(ctx: Context, config: Config = {}): void {
   // this closure, so the callback goes through a holder instead of capturing a TDZ binding.
   let clearProcessIntents: () => void = () => {}
   const current = installVerifierSettings(ctx, entry, () => { limiter = new RequestLimiter(current().maxConcurrency); clearProcessIntents() })
-  const autoRouter = new AutoVerifierRouter()
+  // ONE activity table per plugin instance: the router publishes every granted cycle into it, P06
+  // adds its own richer records, and the chat chip's RPC reads it. It is UI state only — never a
+  // verdict, never the model history (see `verifier-activity.ts` for why it is not a session event).
+  const activities = new VerifierActivities()
+  const autoRouter = new AutoVerifierRouter(createActivityObserver(activities))
   const topics = new Map<string, { dataDir: string; cache: ScoreCache; capabilities: TopLogprobCapabilityCache; flights: SingleFlight<{ value: CachedPairScore; hit: boolean }>; statistics: StatisticsStore; decisions: DecisionStore; process: ProcessCycleStore }>()
   const topic = (header: SessionHeader) => {
     const selected = current()
@@ -326,11 +330,15 @@ export function apply(ctx: Context, config: Config = {}): void {
       const completed = await operation(trace)
       selected = completed.selected
       const value = { ...completed.result as T & object, ...route(selected) } as T & { provider: string; model: string }
-      await statistics.record({ toolName, sessionId: String(agent.id), startedAt, success: true, provider: selected.provider, model: selected.model, stats: statsFrom(value), verdict: verdictFrom(toolName, value, phase), ...(observation ? { route: observation } : {}) }).catch(() => {})
+      // The statistics row and its decision snapshot share ONE id: the dashboard lists statistics
+      // rows and asks for "the snapshot of this row" by the id it was listed under. Two
+      // independently generated uuids made every lookup miss, and the panel then reported the
+      // snapshot as pruned / never captured even though it was sitting in the topic's sidecar.
+      const invocation = await statistics.record({ toolName, sessionId: String(agent.id), startedAt, success: true, provider: selected.provider, model: selected.model, stats: statsFrom(value), verdict: verdictFrom(toolName, value, phase), ...(observation ? { route: observation } : {}) }).catch(() => undefined)
       // Order by label before storing: the engine reports calls as they complete, so a concurrent
       // fan-out reports them in network order. Sorting makes "which calls are in the snapshot"
       // reproducible even when the record has to bound its text.
-      if (calls.length > 0) await topicEntry.decisions.record({ toolName, phase, startedAt, provider: selected.provider, model: selected.model, calls: boundDecisionCalls([...calls].sort((a, b) => (a.label < b.label ? -1 : a.label > b.label ? 1 : 0))) }).catch(() => {})
+      if (calls.length > 0) await topicEntry.decisions.record({ ...(invocation === undefined ? {} : { id: invocation.id }), toolName, phase, startedAt, provider: selected.provider, model: selected.model, calls: boundDecisionCalls([...calls].sort((a, b) => (a.label < b.label ? -1 : a.label > b.label ? 1 : 0))) }).catch(() => {})
       return value
     } catch (error) {
       const details = errorDetails(error)
@@ -754,6 +762,7 @@ export function apply(ctx: Context, config: Config = {}): void {
     sanitize: (text, maxChars) => sanitizeVerifierText(text, maxChars),
     policy: processPolicy,
     router: () => autoRouter,
+    activities,
     store: agent => topic((agent as Agent).session.header).process,
     // The whole task, not just the user's question: the judge has to judge whether the next step
     // addresses the REAL failure, which needs the constraints the request was made under, the
@@ -785,17 +794,18 @@ export function apply(ctx: Context, config: Config = {}): void {
       }, request.signal)
       // The decision snapshot is written here, but the STATISTICS row is written once for the whole
       // cycle (see record below): a second row would count the same judge calls twice.
-      if (calls.length > 0) {
-        await topic(agent.session.header).decisions.record({
-          toolName: 'verifier_compare',
-          phase: 'process',
-          startedAt,
-          provider: selected.provider,
-          model: selected.model,
-          calls: boundDecisionCalls([...calls].sort((a, b) => (a.label < b.label ? -1 : a.label > b.label ? 1 : 0))),
-        }).catch(() => {})
-      }
-      return result
+      const snapshot = calls.length === 0 ? undefined : await topic(agent.session.header).decisions.record({
+        toolName: 'verifier_compare',
+        phase: 'process',
+        startedAt,
+        provider: selected.provider,
+        model: selected.model,
+        calls: boundDecisionCalls([...calls].sort((a, b) => (a.label < b.label ? -1 : a.label > b.label ? 1 : 0))),
+      }).catch(() => undefined)
+      // This cycle's statistics row is written later (once the winner is known), so the snapshot
+      // hands its id forward and that row is stored under it: the dashboard asks for a row's
+      // snapshot BY the id it listed the row with.
+      return snapshot === undefined ? result : { ...result, decisionId: snapshot.id }
     },
     // The tournament seam. Optional by construction: it is only reached when autoProcessCandidates
     // asks for more than two candidates, and a cycle without it compares one pair instead.
@@ -815,17 +825,16 @@ export function apply(ctx: Context, config: Config = {}): void {
         ...(trace ? { trace } : {}),
       }, request.signal)
       // One decision snapshot, one statistics row for the whole cycle — exactly like the pair path.
-      if (calls.length > 0) {
-        await topic(agent.session.header).decisions.record({
-          toolName: 'verifier_select',
-          phase: 'process',
-          startedAt,
-          provider: selected.provider,
-          model: selected.model,
-          calls: boundDecisionCalls([...calls].sort((a, b) => (a.label < b.label ? -1 : a.label > b.label ? 1 : 0))),
-        }).catch(() => {})
-      }
-      return result
+      const snapshot = calls.length === 0 ? undefined : await topic(agent.session.header).decisions.record({
+        toolName: 'verifier_select',
+        phase: 'process',
+        startedAt,
+        provider: selected.provider,
+        model: selected.model,
+        calls: boundDecisionCalls([...calls].sort((a, b) => (a.label < b.label ? -1 : a.label > b.label ? 1 : 0))),
+      }).catch(() => undefined)
+      // Same id hand-off as the pairwise path: one statistics row, one snapshot, one shared id.
+      return snapshot === undefined ? result : { ...result, decisionId: snapshot.id }
     },
     record: async (report: ProcessCycleReport) => {
       const agent = report.agent as Agent
@@ -849,6 +858,9 @@ export function apply(ctx: Context, config: Config = {}): void {
           : { phase: 'process', outcome: report.outcome }
       const failedCall = report.outcome === 'generation-failed' || report.outcome === 'comparison-failed'
       await topic(agent.session.header).statistics.record({
+        // The snapshot of this cycle was already written while the comparison ran; the row adopts
+        // its id so the dashboard can fetch that snapshot from the row it lists.
+        ...(report.decisionId === undefined ? {} : { id: report.decisionId }),
         toolName: report.select === undefined ? 'verifier_compare' : 'verifier_select',
         sessionId: String(agent.id),
         startedAt: report.startedAt,
@@ -953,23 +965,26 @@ export function apply(ctx: Context, config: Config = {}): void {
   const isDecisionQuery = (payload: unknown): boolean => typeof payload === 'object' && payload !== null && (payload as { kind?: unknown }).kind === 'decision'
 
   /**
-   * Whether a payload asks what the process-selection (P06) cycle of one session is doing.
+   * Whether a payload asks what this plugin is doing for one session.
    *
-   * This is what the chat chip polls while a turn runs. The answer is in-memory state only: no
-   * sidecar read, no model call, and nothing durable, so polling it cannot cost anything or change
-   * a verdict. A session that never bought a cycle answers with an empty object.
+   * This is what the chat chip polls while a turn runs: a P06 cycle (which buffers the reply), a
+   * routed review, or the final acceptance. The wire name is historical — it covers every stage now,
+   * and keeping it means a page holding the older client bundle keeps working.
    */
   const isProcessQuery = (payload: unknown): boolean => typeof payload === 'object' && payload !== null && (payload as { kind?: unknown }).kind === 'process'
 
   /**
-   * Read the in-flight / just-settled process cycle of one session.
+   * Read the in-flight / just-settled cycle of one session.
+   *
+   * In-memory state only: no sidecar read, no model call, nothing durable, so polling it cannot cost
+   * anything or change a verdict. A session with nothing to show answers with an empty object.
    * @param payload - the RPC payload; `sessionId` is required.
    * @returns The activity view, or a bad-request failure.
    */
-  const handleProcessQuery = async (payload: unknown): Promise<{ ok: true; value: { sessionId: string } & ProcessActivityView } | ReturnType<typeof rpcFailure>> => {
+  const handleProcessQuery = async (payload: unknown): Promise<{ ok: true; value: { sessionId: string } & ActivityView } | ReturnType<typeof rpcFailure>> => {
     const sessionId = (payload as { sessionId?: unknown } | null)?.sessionId
     if (typeof sessionId !== 'string' || sessionId === '') return rpcFailure('a sessionId is required')
-    return rpcSuccess({ sessionId, ...processSelector.activity(sessionId) })
+    return rpcSuccess({ sessionId, ...activities.read(sessionId, Date.now()) })
   }
 
   /**

package/src/process-selection.test.ts

@@ -457,6 +457,19 @@ describe('process cycle execution', () => {
     expect(report?.observation.replayed).toBe('candidate')
   })
 
+  it('carries the snapshot id the judging seam reported, so the statistics row can link to it', async () => {
+    // The seam files the decision snapshot while it judges, but the statistics row only exists once
+    // the winner is known: the id travels with the report so that row can adopt it (the dashboard
+    // asks for "the snapshot of this row" by the id it listed the row under).
+    const linked = harness({ compare: async () => compareResult('B', { decisionId: 'snapshot-1' }) })
+    const { report } = await run(linked, { original: textChunks('ORIGINAL') })
+    expect(report?.decisionId).toBe('snapshot-1')
+
+    // Nothing captured (every judge call was a cache hit): the row keeps its own generated id.
+    const plain = harness({ compare: async () => compareResult('B') })
+    expect((await run(plain, { original: textChunks('ORIGINAL') })).report?.decisionId).toBeUndefined()
+  })
+
   it('replays the original verbatim on a tie, on an A win, and records which', async () => {
     for (const winner of ['A', 'tie'] as const) {
       const original = textChunks('ORIGINAL')

package/src/process-selection.ts

@@ -22,7 +22,7 @@ import { addUsage, emptyUsage, GENERATION_TEMPERATURE, type UsageStats } from '.
 import { stableHash } from './cache.ts'
 import { PROCESS_CRITERIA, type Criterion } from './core.ts'
 import { mergeRunStats, partialStats, type CompareResult, type RunStats, type SelectResult } from './engine.ts'
-import { ProcessActivities, type ProcessActivityView } from './process-activity.ts'
+import { VerifierActivities, classifyProcessOutcome, type ActivityView } from './verifier-activity.ts'
 import { estimateRoutedCalls, itemBudget, type AutoVerifierRouter, type Reservation, type RouterPolicy, type RoutedAgent } from './router.ts'
 import type { RouteObservation } from './statistics.ts'
 
@@ -147,6 +147,14 @@ export interface ProcessCycleReport {
   compare?: CompareResult
   /** Present when the cycle ran the tournament (N>2). */
   select?: SelectResult
+  /**
+   * Id of the decision snapshot the judging seam filed, when it filed one.
+   *
+   * The seam writes the snapshot while it judges, but the statistics row only exists once the
+   * winner is known. Reporting the id lets that row adopt it, so the dashboard can fetch a row's
+   * snapshot by the id it listed the row under.
+   */
+  decisionId?: string
   error?: string
 }
 
@@ -209,6 +217,13 @@ export interface ProcessSelectorDeps {
   /** The routing policy in force, including the final-acceptance floor and the process allowance. */
   policy(): Promise<RouterPolicy>
   router(): AutoVerifierRouter
+  /**
+   * Shared activity table the router's cycles and these P06 cycles are published to.
+   *
+   * Injected so one plugin instance has ONE table: the chip's read must see a routed review and a
+   * process cycle in the same place. Defaults to a private table, which is all a focused test needs.
+   */
+  activities?: VerifierActivities
   /** Durable cycle log of one topic. */
   store(agent: unknown): ProcessCycleStore
   /** Newest session state, used for staleness and for the comparison's task evidence. */
@@ -217,14 +232,14 @@ export interface ProcessSelectorDeps {
   current(intent: ProcessIntent): boolean
   /** Independent dispatch for the alternative reply (a fresh request object). */
   stream(options: GenerateOptions): AsyncIterable<StreamChunk>
-  compare(request: ProcessCompareRequest): Promise<CompareResult>
+  compare(request: ProcessCompareRequest): Promise<CompareResult & { decisionId?: string }>
   /**
    * Tournament over 3+ candidates; required only when `settings.candidates` is above 2.
    *
    * Optional on purpose: an embedder that never raises the count needs no tournament seam, and a
    * cycle that asks for one without it falls back to the pairwise path with a warning.
    */
-  select?(request: ProcessSelectRequest): Promise<SelectResult>
+  select?(request: ProcessSelectRequest): Promise<SelectResult & { decisionId?: string }>
   record(report: ProcessCycleReport): Promise<void>
   /**
    * Rewrite the STATISTICS row of one already-recorded cycle because its delivery changed.
@@ -812,17 +827,22 @@ export class ProcessSelector {
    *
    * Host-only and in memory: a session event would carry the same information, but the persistence
    * read path refuses unknown event types for an out-of-repo plugin, and `Session.append` cannot
-   * set the `ignorable` marker that would make one loadable (see `process-activity.ts`).
+   * set the `ignorable` marker that would make one loadable (see `verifier-activity.ts`).
    */
-  private readonly activities = new ProcessActivities()
+  private readonly activities: VerifierActivities
 
-  constructor(private readonly deps: ProcessSelectorDeps) {}
+  constructor(private readonly deps: ProcessSelectorDeps) {
+    this.activities = deps.activities ?? new VerifierActivities()
+  }
 
   /**
    * The cycle one session has to show right now, for the UI chip (in flight, or just settled).
+   *
+   * Reads the SAME table the router publishes into, so a routed review and a process cycle are never
+   * two different answers to "what is this session doing".
    * @param sessionId - the session to read.
    */
-  activity(sessionId: string): ProcessActivityView { return this.activities.read(sessionId, this.deps.now()) }
+  activity(sessionId: string): ActivityView { return this.activities.read(sessionId, this.deps.now()) }
 
   /** Register (or replace) the pending intent of one session. */
   register(intent: ProcessIntent): void { this.intents.set(intent.sessionId, intent) }
@@ -966,6 +986,7 @@ export class ProcessSelector {
     // streaming text of its own, so the chip is the only thing that can explain it.
     this.activities.begin(intent.sessionId, {
       cycleId: reservation.id,
+      stage: 'process',
       phase: 'generating',
       candidates: count,
       ...(observation.alternativeModel === undefined ? {} : { alternativeModel: observation.alternativeModel }),
@@ -1230,8 +1251,8 @@ export class ProcessSelector {
       }
       // The generation and the buffering are behind us; everything this cycle still owes the user
       // is judge latency.
-      this.activities.phase(intent.sessionId, reservation.id, 'comparing')
-      let judged: { judgeCalls: number; winner: BufferedCandidate | undefined; tie: boolean; stats: RunStats; compare?: CompareResult; select?: SelectResult }
+      this.activities.update(intent.sessionId, reservation.id, { phase: 'comparing' })
+      let judged: { judgeCalls: number; winner: BufferedCandidate | undefined; tie: boolean; stats: RunStats; compare?: CompareResult; select?: SelectResult; decisionId?: string }
       try {
         if ('candidateA' in view) {
           const compared = await this.deps.compare({
@@ -1244,7 +1265,7 @@ export class ProcessSelector {
             repeats: PROCESS_REPEATS,
             signal: phase.signal,
           })
-          judged = { judgeCalls: compared.calls, winner: compared.winner === 'B' ? alternatives[0] : undefined, tie: compared.winner === 'tie', stats: compared.stats, compare: compared }
+          judged = { judgeCalls: compared.calls, winner: compared.winner === 'B' ? alternatives[0] : undefined, tie: compared.winner === 'tie', stats: compared.stats, compare: compared, ...(compared.decisionId === undefined ? {} : { decisionId: compared.decisionId }) }
         } else {
           const selected = await this.deps.select!({
             agent: intent.agent,
@@ -1255,7 +1276,7 @@ export class ProcessSelector {
             repeats: PROCESS_REPEATS,
             signal: phase.signal,
           })
-          judged = { judgeCalls: selected.calls, winner: selected.index > 0 ? alternatives[selected.index - 1] : undefined, tie: false, stats: selected.stats, select: selected }
+          judged = { judgeCalls: selected.calls, winner: selected.index > 0 ? alternatives[selected.index - 1] : undefined, tie: false, stats: selected.stats, select: selected, ...(selected.decisionId === undefined ? {} : { decisionId: selected.decisionId }) }
         }
       } catch (error) {
         // The judge run really happened before it failed: fold in every call the engine attached to
@@ -1306,7 +1327,7 @@ export class ProcessSelector {
           // dep. Both must state the delivery, and `finish` overwrites the cycle's own record.
           await this.deps.store(intent.agent).finish(reservation.id, outcome, 'original')
           // The chip follows the same correction: it was already settled as a replacement.
-          this.activities.finish(intent.sessionId, reservation.id, outcome, 'original', this.deps.now())
+          this.activities.finish(intent.sessionId, reservation.id, classifyProcessOutcome(outcome, 'original'), this.deps.now())
           try {
             await this.deps.correctDelivery({ agent: intent.agent, cycleId: reservation.id, outcome, replayed: 'original' })
           } catch (error) {
@@ -1366,16 +1387,20 @@ export class ProcessSelector {
   }
 
   /** Record a purchased cycle and stamp its durable outcome. */
-  private async report(input: { intent: ProcessIntent; reservation: Reservation; observation: RouteObservation; startedAt: number; outcome: string; replayed: 'original' | 'candidate'; generatedCalls: number; judgeCalls: number; sameCandidate: boolean; usage: RunStats; compare?: CompareResult; select?: SelectResult; error?: string }): Promise<void> {
+  private async report(input: { intent: ProcessIntent; reservation: Reservation; observation: RouteObservation; startedAt: number; outcome: string; replayed: 'original' | 'candidate'; generatedCalls: number; judgeCalls: number; sameCandidate: boolean; usage: RunStats; compare?: CompareResult & { decisionId?: string }; select?: SelectResult & { decisionId?: string }; error?: string }): Promise<void> {
     // The chip is told first: it is live UI state, and it must not depend on the cycle log or the
     // statistics row being writable (a read-only topic still gets an honest indicator).
-    this.activities.finish(input.intent.sessionId, input.reservation.id, input.outcome, input.replayed, this.deps.now())
+    this.activities.finish(input.intent.sessionId, input.reservation.id, classifyProcessOutcome(input.outcome, input.replayed), this.deps.now())
     await this.deps.store(input.intent.agent).finish(input.reservation.id, input.outcome, input.replayed)
+    // The judging seam filed the snapshot under an id of its own; the statistics row adopts it, so
+    // "the snapshot of this row" resolves from the dashboard. Absent when nothing was captured.
+    const decisionId = input.compare?.decisionId ?? input.select?.decisionId
     await this.deps.record({
       agent: input.intent.agent,
       cycleId: input.reservation.id,
       purchased: true,
       startedAt: input.startedAt,
+      ...(decisionId === undefined ? {} : { decisionId }),
       outcome: input.outcome,
       replayed: input.replayed,
       generatedCalls: input.generatedCalls,

package/src/router.test.ts

@@ -913,6 +913,52 @@ describe('structured route dedup and selection', () => {
   })
 })
 
+describe('cycle observer for the chat chip', () => {
+  it('reports the grant, the promotion and the settlement of one cycle', () => {
+    const value = session(); const agent = { id: value.id, session: value }
+    const seen: string[] = []
+    const router = new AutoVerifierRouter({
+      begin: (_agent, reservation) => { seen.push('begin:' + reservation.phase + ':' + String(reservation.expectedCalls)) },
+      promoted: (_agent, reservation) => { seen.push('promoted:' + reservation.phase + ':' + String(reservation.expectedCalls)) },
+      settled: (_agent, reservation, outcome) => { seen.push('settled:' + reservation.phase + ':' + outcome) },
+    })
+    const classified = router.reserve(agent, 'semantic', 'classify', 1, policy)!
+    router.promote(agent, classified, 'compare', 'resolve', 5, policy)
+    expect(router.commit(agent, classified, 3)).toBe(true)
+    // The promotion is reported on the SAME reservation, which is what lets the chip move from
+    // "classifying" to "reviewing" instead of leaving a second cycle behind.
+    expect(seen).toEqual(['begin:semantic:1', 'promoted:compare:6', 'settled:compare:committed'])
+
+    const final = router.reserve(agent, 'final', 'final', 4, policy)!
+    router.fail(agent, final, false)
+    expect(seen.at(-1)).toBe('settled:final:failed')
+  })
+
+  it('reports nothing twice when a settlement is refused', () => {
+    const value = session(); const agent = { id: value.id, session: value }
+    let settled = 0
+    const router = new AutoVerifierRouter({ settled: () => { settled += 1 } })
+    const route = router.reserve(agent, 'compare', 'route', 4, policy)!
+    expect(router.commit(agent, route, 1)).toBe(true)
+    // A second commit for the same reservation is a no-op, and must not fake an edge.
+    expect(router.commit(agent, route, 1)).toBe(false)
+    expect(settled).toBe(1)
+  })
+
+  it('lets a broken observer throw without changing routing', () => {
+    // The observer is a reporting channel: a bug in the UI path must never cost a reservation, a
+    // verdict or the ability to route again.
+    const value = session(); const agent = { id: value.id, session: value }
+    const explode = () => { throw new Error('observer exploded') }
+    const router = new AutoVerifierRouter({ begin: explode, promoted: explode, settled: explode })
+    const classified = router.reserve(agent, 'semantic', 'classify', 1, policy)!
+    expect(router.promote(agent, classified, 'track', 'resolve', 2, policy)).toBe(true)
+    expect(router.fail(agent, classified, false)).toBeUndefined()
+    // The failed cycle released the in-flight slot, so routing continues.
+    expect(router.reserve(agent, 'compare', 'next', 4, policy)).toBeDefined()
+  })
+})
+
 describe('transactional router state', () => {
   it('commits, requires final verification, and clears it only after final commit', () => {
     const value = session(); const agent = { id: value.id, session: value }; const router = new AutoVerifierRouter()

package/src/router.ts

@@ -1412,6 +1412,22 @@ export function boundDecision(decision: RouteDecision | undefined, policy: Route
   return decision
 }
 
+/**
+ * Advisory observer of granted routing cycles, used by the chat indicator.
+ *
+ * The router is the only component that knows a cycle was GRANTED and when it settled, but it must
+ * not know what the UI says about it. Every callback is optional and exception-safe: an observer is
+ * a reporting channel, and it must never be able to change routing, budgets or verdicts.
+ */
+export interface RouterCycleObserver {
+  /** A cycle was granted (the reservation now owns the agent's in-flight slot). */
+  begin?(agent: RoutedAgent, reservation: Reservation): void
+  /** A classification cycle was promoted into the decision it resolved, on the same reservation. */
+  promoted?(agent: RoutedAgent, reservation: Reservation): void
+  /** The cycle was committed (accepted) or failed (rejected / abandoned). */
+  settled?(agent: RoutedAgent, reservation: Reservation, outcome: 'committed' | 'failed'): void
+}
+
 export class AutoVerifierRouter {
   private readonly states = new Map<string, RouterState>()
   /** Agent ids that already received this task's budget-exhaustion notice. */
@@ -1420,6 +1436,17 @@ export class AutoVerifierRouter {
   /** Namespace for this router's cycle ids; unique per router and per process incarnation. */
   private readonly instance = ROUTER_EPOCH + '-' + (++routerInstanceSerial)
 
+  /**
+   * @param observer - optional reporting channel for the chat indicator.
+   */
+  constructor(private readonly observer?: RouterCycleObserver) {}
+
+  /** Report one lifecycle edge, swallowing anything the observer throws. */
+  private observe(report: (observer: RouterCycleObserver) => void): void {
+    if (this.observer === undefined) return
+    try { report(this.observer) } catch { /* an advisory UI observer must never change routing */ }
+  }
+
   private state(agent: RoutedAgent): RouterState | undefined {
     const taskStartSeq = latestDirectUserSeq(sessionEvents(agent.session))
     if (taskStartSeq === undefined) return undefined
@@ -1472,6 +1499,7 @@ export class AutoVerifierRouter {
     }
     state.taskModelCalls += expectedCalls
     state.sessionModelCalls += expectedCalls
+    this.observe(observer => observer.begin?.(agent, reservation))
     return reservation
   }
 
@@ -1519,6 +1547,7 @@ export class AutoVerifierRouter {
     reservation.expectedCalls += expectedCalls
     state.taskModelCalls += expectedCalls
     state.sessionModelCalls += expectedCalls
+    this.observe(observer => observer.promoted?.(agent, reservation))
     return true
   }
 
@@ -1531,6 +1560,7 @@ export class AutoVerifierRouter {
     // (and, in strict mode, burn an attempt and set strictBlocked on that empty review).
     if (reservation.phase !== 'semantic' && reservation.phase !== 'final' && reservation.phase !== 'plan_review') state.finalRequiredFromSeq = Math.max(state.finalRequiredFromSeq ?? 0, evidenceSeq ?? reservation.taskStartSeq)
     if (reservation.phase === 'final') { state.finalRequiredFromSeq = undefined; state.finalPreferred = false }
+    this.observe(observer => observer.settled?.(agent, reservation, 'committed'))
     return true
   }
 
@@ -1539,6 +1569,7 @@ export class AutoVerifierRouter {
     if (!state || state.inFlight?.id !== reservation.id) return
     state.inFlight = undefined; state.failed.add(reservation.fingerprint); if (strict) state.strictBlocked = true
     if (reservation.phase === 'final') state.finalPreferred = false
+    this.observe(observer => observer.settled?.(agent, reservation, 'failed'))
   }
 
   /**

package/src/statistics.test.ts

@@ -31,6 +31,22 @@ function stats(overrides: Partial<ReturnType<typeof emptyRunStats>> = {}) {
 }
 
 describe('StatisticsStore', () => {
+  it('stores a caller-supplied invocation id so the dashboard row can find its decision snapshot', async () => {
+    // The row and its snapshot must share ONE id: the "recall" button sends the id the row was
+    // listed under, and an independently generated uuid made that lookup miss every time.
+    const root = await mkdtemp(join(tmpdir(), 'dsh-verifier-statistics-'))
+    const file = join(root, 'statistics.json')
+    const store = new StatisticsStore(file, 100)
+    const stored = await store.record({ id: 'invocation-9', toolName: 'verifier_current_session', startedAt: 1, success: true, provider: 'p', model: 'm', stats: stats() })
+    expect(stored.id).toBe('invocation-9')
+    const reopened = new StatisticsStore(file, 100)
+    const overview = await reopened.overview({ fromMs: 0, toMs: 10 })
+    expect(overview.recent[0]?.id).toBe('invocation-9')
+    // An unusable id falls back to a generated one instead of producing a nameless row.
+    const fallback = await store.record({ id: '', toolName: 'verifier_track', startedAt: 2, success: true, provider: 'p', model: 'm', stats: stats() })
+    expect(fallback.id).not.toBe('')
+  })
+
   it('records and aggregates invocations by day, tool, model, and session', async () => {
     const root = await mkdtemp(join(tmpdir(), 'dsh-verifier-statistics-'))
     const file = join(root, 'statistics.json')

package/src/statistics.ts

@@ -336,6 +336,14 @@ export interface StatisticsQuery {
 
 export interface InvocationInput {
   toolName: VerifierToolName
+  /**
+   * Invocation id; a fresh uuid when omitted.
+   *
+   * Shared with the decision snapshot of the same invocation: the dashboard lists these rows and
+   * asks for "the snapshot of THIS row" by the id it was listed under, so the caller passes the
+   * id the snapshot was filed with (see `decisions.ts`).
+   */
+  id?: string
   sessionId?: string
   startedAt: number
   finishedAt?: number
@@ -581,7 +589,7 @@ export class StatisticsStore {
     const verdict = cleanVerdict(input.verdict)
     const route = cleanRoute(input.route)
     const record: InvocationRecord = {
-      id: randomUUID(),
+      id: typeof input.id === 'string' && input.id.length > 0 ? input.id : randomUUID(),
       toolName: input.toolName,
       ...(input.sessionId ? { sessionId: input.sessionId } : {}),
       startedAt: input.startedAt,