@genesislcap/ai-assistant 15.12.0 → 15.13.0

package/src/chat-driver-node.ts

@@ -105,7 +105,13 @@ export type {
 // `addUsage`/`emptyUsage` are the composition primitives for a conversation that CONTINUES across
 // rounds — see the guidance on `sumUsage` itself. `totalTokens` exists because the four buckets of
 // an `AggregateUsage` are disjoint and safe to add, which the per-message fields are NOT.
-export { addUsage, emptyUsage, sumUsage, totalTokens } from './utils/sum-usage';
+//
+// `messageUsage` is the single-message projection of the same arithmetic — what ONE request
+// cost, in the same four-bucket shape. It is what prices a turn snapshot (see
+// `TurnSnapshot.usage`), and the reason a consumer needs it separately is that the response
+// to a *failed* attempt never reaches history, so `sumUsage` over the transcript cannot see
+// that spend at all.
+export { addUsage, emptyUsage, messageUsage, sumUsage, totalTokens } from './utils/sum-usage';
 
 // Per-call projection, for the cases an aggregate cannot serve: usage rows for
 // per-project attribution, a cost dashboard, or auditing which turns came back
@@ -128,5 +134,9 @@ export { clearSession, getMetaEvents } from './state/debug-event-log';
 export type { MetaEvent } from './state/debug-event-log';
 export { buildTimelineEntries } from './state/persistence/build-timeline-entries';
 export type { TurnSnapshotLike } from './state/persistence/build-timeline-entries';
-export { assembleDebugLog } from './state/persistence/diagnostics';
+// `withFreshMetaSnapshot` matters to a headless consumer that stitches a STORED stream: the
+// newest stored `meta-snapshot` is frozen at the last config-signature change, so its context
+// and cost figures are as old as that. Pass a fresh snapshot of your own through this before
+// `assembleDebugLog`, or state in your own output that the totals are historical.
+export { assembleDebugLog, withFreshMetaSnapshot } from './state/persistence/diagnostics';
 export type { DebugLog, DiagnosticEntry } from './state/persistence/diagnostics';

package/src/components/chat-driver/chat-driver.ts

@@ -1,4 +1,5 @@
 import type {
+  AggregateUsage,
   AIProvider,
   AIProviderRegistry,
   AIProviderType,
@@ -70,7 +71,7 @@ import {
   normalizeForProvider,
 } from '../../utils/history-transform';
 import { logger } from '../../utils/logger';
-import { sumUsage } from '../../utils/sum-usage';
+import { messageUsage, sumUsage } from '../../utils/sum-usage';
 import { TOOL_FOLD_SYMBOL, type ToolFold } from '../../utils/tool-fold';
 import type { AiDriver, AllAgentSummary } from '../ai-driver/ai-driver';
 
@@ -241,6 +242,46 @@ export interface TurnSnapshot {
   agentLabel?: string;
   /** Agent-supplied snapshot — machine state/context for stateful agents, undefined otherwise. */
   agentSnapshot?: unknown;
+  /**
+   * Concrete model that ran this call (e.g. `'claude-sonnet-4-6'`) — the serving model
+   * where the provider reports one, else the model the resolved tier was configured
+   * with. Undefined when the provider exposes no `getStatus` and the transport stamped
+   * nothing.
+   *
+   * Recorded per call, so an agent whose `provider` selector varies by state (a tier
+   * switch between steps of a flow) has each step attributed to the model that actually
+   * ran it — without the reader having to join the turn to the message after it, which
+   * is impossible for a call that produced no message.
+   */
+  model?: string;
+  /**
+   * Registry slot the provider resolved under for this call — a tier name like
+   * `'high'`/`'low'`, or the registry default's name. Kept alongside {@link
+   * TurnSnapshot.model} because they answer different questions: the slot is what the
+   * agent asked for, the model is what served it, and repointing a slot at a new model
+   * mid-session is only visible when both are recorded.
+   */
+  providerName?: string;
+  /** Vendor behind the resolved slot (`'anthropic'`, `'gemini'`, …), when the provider reports it. */
+  provider?: AIProviderType;
+  /**
+   * What this one LLM call cost — the four disjoint token buckets plus USD, derived
+   * from the response's usage by `messageUsage`. Back-filled when the response lands
+   * (the rest of the snapshot is captured *before* the call), so it is `undefined`
+   * while the call is in flight, on providers that report no usage, and on a call that
+   * threw rather than returning — a malformed-call/truncation/402 error carries no usage
+   * block, so any tokens the provider billed for it are not recoverable here.
+   *
+   * A snapshot is one **model call**, not one user turn: every tool-loop iteration and
+   * every retried attempt records its own. That makes this the only record of spend on
+   * an attempt that produced no message — a blank or refused response is billed and
+   * then discarded (see the empty-response retries), so summing the transcript alone
+   * under-reports the turn.
+   *
+   * For a call that DID produce a message, this is the same money as that message's
+   * `cost`/token fields, not additional money — never add turn usage to message usage.
+   */
+  usage?: AggregateUsage;
 }
 
 interface FoldStackFrame {
@@ -1140,7 +1181,14 @@ export class ChatDriver extends EventTarget implements AiDriver {
     if (resolvedName !== this.lastDispatchedProviderName) {
       this.lastDispatchedProviderName = resolvedName;
       recordMetaEvent(this.sessionKey, 'provider.selected', {
+        // `provider` is the registry SLOT (a tier name like 'high'), kept under that key
+        // for compatibility; `model` and `vendor` are what it resolved to. Recording all
+        // three is the difference between "the agent switched to its high tier" and
+        // knowing which model that actually was — a tier can be repointed mid-session,
+        // and a slot name alone cannot distinguish anthropic from gemini.
         provider: resolvedName,
+        model: status.model,
+        vendor: status.provider,
         agent: this.activeAgentName,
       });
       this.dispatchEvent(
@@ -1304,13 +1352,17 @@ export class ChatDriver extends EventTarget implements AiDriver {
    * Push one snapshot to the ring buffer. Called inside `runToolLoop` just
    * before each LLM call — that's the latest point where the prompt, tool
    * surface, and agent state line up with what the model is about to see.
+   *
+   * Returns the pushed object so the caller can back-fill what only the response
+   * knows (`usage`). Mutating it after the fact is safe whether or not the ring
+   * buffer has since evicted it — an evicted snapshot is simply no longer exported.
    */
   private recordTurnSnapshot(
     resolvedSystemPrompt: string | undefined,
     temperature: number | undefined,
     toolChoice: ChatToolChoice | undefined,
     tailContext: string | undefined,
-  ): void {
+  ): TurnSnapshot {
     let agentSnapshot: unknown;
     if (this.debugSnapshotter) {
       try {
@@ -1324,7 +1376,7 @@ export class ChatDriver extends EventTarget implements AiDriver {
     }
     const turnIndex = String(this.globalTurnIndex);
     this.globalTurnIndex += 1;
-    this.turnSnapshots.push({
+    const snapshot: TurnSnapshot = {
       turnIndex,
       timestamp: new Date().toISOString(),
       agentName: this.activeAgentName,
@@ -1335,10 +1387,12 @@ export class ChatDriver extends EventTarget implements AiDriver {
       temperature,
       toolChoice,
       agentSnapshot,
-    });
+    };
+    this.turnSnapshots.push(snapshot);
     if (this.turnSnapshots.length > this.maxTurnSnapshots) {
       this.turnSnapshots.shift();
     }
+    return snapshot;
   }
 
   /**
@@ -2759,7 +2813,12 @@ export class ChatDriver extends EventTarget implements AiDriver {
       // force when no tools are advertised.)
       const effectiveToolChoice = resolvedToolChoice ?? (this.isSubAgent ? 'required' : undefined);
 
-      this.recordTurnSnapshot(systemPrompt, resolvedTemperature, effectiveToolChoice, tailContext);
+      const turnSnapshot = this.recordTurnSnapshot(
+        systemPrompt,
+        resolvedTemperature,
+        effectiveToolChoice,
+        tailContext,
+      );
 
       // Capture the pending user input, then clear the slots BEFORE the chat
       // call. `sendMessage` already appended the user message to `this.history`,
@@ -2809,6 +2868,20 @@ export class ChatDriver extends EventTarget implements AiDriver {
       // oxlint-disable-next-line no-await-in-loop
       const activeProvider = await this.resolveProviderForTurn(promptCtx);
 
+      // Attribute the turn to the tier/model it resolved. Stamped HERE, not inside
+      // `recordTurnSnapshot`: the snapshot is taken before this line runs, so reading
+      // `lastResolved*` there yields the PREVIOUS call's model — wrong on precisely the
+      // turn where an agent's per-state `provider` selector switches tier, which is the
+      // turn a reader is looking for. `model` is refined to the serving model once the
+      // response lands (see below); until then — and on a call that throws — it is the
+      // model we ASKED for, which is the only thing knowable at that point.
+      if (this.lastResolvedProviderName !== undefined) {
+        turnSnapshot.providerName = this.lastResolvedProviderName;
+      }
+      if (this.lastResolvedProvider !== undefined)
+        turnSnapshot.provider = this.lastResolvedProvider;
+      if (this.lastResolvedModel !== undefined) turnSnapshot.model = this.lastResolvedModel;
+
       let response: ChatMessage;
       try {
         // oxlint-disable-next-line no-await-in-loop
@@ -2995,6 +3068,19 @@ export class ChatDriver extends EventTarget implements AiDriver {
         response.providerName = this.lastResolvedProviderName;
       }
 
+      // Back-fill what this call cost onto the snapshot taken just before it, so the
+      // exported debug log prices each model call next to the prompt/tools/state that
+      // produced it (GENC-1480 follow-up). Stamped BEFORE the empty-response branch
+      // below deliberately: a blank or refused response is billed and then thrown away,
+      // so the snapshot is the only place that spend is ever recorded.
+      turnSnapshot.usage = messageUsage(response);
+      // Take the SERVING model over the requested one, now that it is known. `response.model`
+      // was just filled from `lastResolvedModel` if the transport left it unset, so this is
+      // the same rule the message gets — which is the point: a turn and the message it
+      // produced must never disagree about which model ran, including when a server-side
+      // fallback chain answered on a different model than the one we asked for.
+      if (response.model !== undefined) turnSnapshot.model = response.model;
+
       const isThinkingStep = response.content && response.toolCalls?.length;
       const isEmptyResponse = !response.content?.trim() && !response.toolCalls?.length;
       // A pre-output refusal (safety-classifier decline, e.g. Fable 5 `stop_reason: 'refusal'`)
@@ -3060,8 +3146,23 @@ export class ChatDriver extends EventTarget implements AiDriver {
         // `sumCosts`/`sumTokens` don't double-count and `contextTokens` reads it. Reasoning/narration are
         // display-only (usage undefined) and are skipped when building the provider request. `model` /
         // `provider` / `providerName` stay on every split message so each is still attributed.
+        //
+        // EVERY usage field has to be cleared here, not just the three the invariant was
+        // originally written against — keep this list in step with the usage fields on
+        // `ChatMessage`. The cache buckets arrived later (GENC-1475) and were left riding
+        // along on the copies, so a response carrying reasoning AND narration counted its
+        // cache read/write volume three times in `sumUsage`/`usageRows` — invisible in the
+        // cost total (which comes from `cost`) but wrong in every bucket display and in the
+        // exported log.
         const { reasoning, ...rest } = response;
-        const displayOnly = { cost: undefined, inputTokens: undefined, outputTokens: undefined };
+        const displayOnly = {
+          cost: undefined,
+          externalCostUsd: undefined,
+          inputTokens: undefined,
+          outputTokens: undefined,
+          cacheReadTokens: undefined,
+          cacheWriteTokens: undefined,
+        };
         if (reasoning) {
           this.appendToHistory({
             ...rest,

package/src/components/chat-driver/chat-driver.turn-usage.test.ts

@@ -0,0 +1,362 @@
+import type {
+  AIProvider,
+  AIProviderRegistry,
+  ChatMessage,
+  ChatToolDefinition,
+} from '@genesislcap/foundation-ai';
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import type { AgentConfig } from '../../config/config';
+import { clearMetaEventRegistry, getMetaEvents } from '../../state/debug-event-log';
+import { messageUsage, sumUsage } from '../../utils/sum-usage';
+// Side-effect import — MUST come before `./chat-driver` so the driver subclasses
+// jsdom's EventTarget rather than Node's native one. Mirrors chat-driver.test.ts.
+import './align-event-globals';
+import { ChatDriver } from './chat-driver';
+
+// ---------------------------------------------------------------------------
+// Per-call usage on the turn snapshots — the four token buckets plus USD priced
+// onto each `kind: 'turn'` entry of the exported debug log.
+//
+// The snapshot is captured BEFORE the model call (that is where the prompt, tool
+// surface and agent state line up with what the model saw), so usage has to be
+// back-filled when the response lands. Two things follow, and both are asserted
+// here: a completed call's turn agrees with the message it produced, and a call
+// that produced NO message (a blank response, retried) is still priced — that
+// spend appears nowhere in the transcript.
+// ---------------------------------------------------------------------------
+
+const makeRegistry = (provider: AIProvider): AIProviderRegistry => ({
+  get: () => provider,
+  default: () => provider,
+  defaultName: () => 'test',
+  names: () => ['test'],
+  getStatus: async () => null,
+  listStatuses: async () => [],
+});
+
+/** Answers from a queue, then ends the turn with a plain unpriced reply. */
+const scriptedProvider = (responses: ChatMessage[]): AIProvider => {
+  const queue = [...responses];
+  return {
+    chat: async (): Promise<ChatMessage> => queue.shift() ?? { role: 'assistant', content: 'done' },
+  };
+};
+
+const agent = (overrides: Partial<AgentConfig> & { name: string }): AgentConfig =>
+  ({ description: 'test agent', ...overrides }) as AgentConfig;
+
+const makeDriver = (config: AgentConfig, provider: AIProvider): ChatDriver => {
+  const driver = new ChatDriver(makeRegistry(provider), {
+    maxToolIterations: 50,
+    maxFoldOperations: 5,
+    sessionKey: '',
+  });
+  driver.applyAgent(config);
+  return driver;
+};
+
+const def = (name: string): ChatToolDefinition => ({
+  name,
+  description: `${name} tool`,
+  parameters: { type: 'object', properties: {} },
+});
+
+/** One priced response: a 1000-token prompt that was mostly a cache hit. */
+const priced = (over: Partial<ChatMessage> = {}): ChatMessage => ({
+  role: 'assistant',
+  content: 'answer',
+  cost: 0.1,
+  inputTokens: 1000,
+  cacheReadTokens: 900,
+  cacheWriteTokens: 50,
+  outputTokens: 20,
+  ...over,
+});
+
+const suite = createLogicSuite('ChatDriver per-turn usage');
+
+suite('prices each turn snapshot with the four buckets and USD of its own call', async () => {
+  const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([priced()]));
+  await driver.sendMessage('go');
+
+  const [turn] = driver.getTurnSnapshots();
+  assert.equal(
+    turn.usage,
+    {
+      costUsd: 0.1,
+      // The prompt split into disjoint buckets: 1000 total, 900 read + 50 written,
+      // so 50 uncached. A reader of the log gets this without re-deriving it.
+      uncachedInputTokens: 50,
+      cacheReadTokens: 900,
+      cacheWriteTokens: 50,
+      outputTokens: 20,
+    },
+    'the turn carries its own call’s usage',
+  );
+  // The turn and the message it produced are the SAME charge, so they must agree
+  // exactly — a log whose two views of one call disagree is worse than one view.
+  assert.equal(turn.usage, sumUsage(driver.getHistory()), 'turn agrees with the transcript total');
+});
+
+suite('prices every model call in a tool loop separately', async () => {
+  const driver = makeDriver(
+    agent({
+      name: 'a',
+      toolDefinitions: [def('work')],
+      toolHandlers: { work: async () => 'worked' },
+    }),
+    scriptedProvider([
+      priced({ content: '', cost: 0.02, toolCalls: [{ id: 'w1', name: 'work', args: {} }] }),
+      priced({ cost: 0.03 }),
+    ]),
+  );
+  await driver.sendMessage('go');
+
+  const snapshots = driver.getTurnSnapshots();
+  assert.is(snapshots.length, 2, 'one snapshot per model call, not per user turn');
+  assert.equal(
+    snapshots.map((s) => s.usage?.costUsd),
+    [0.02, 0.03],
+  );
+});
+
+suite('prices a blank response that produced no message', async () => {
+  // A blank turn is billed and then discarded before the retry, so the transcript can
+  // never account for it. The snapshot is the only record — which is the whole reason
+  // usage is stamped before the empty-response branch runs.
+  const driver = makeDriver(
+    agent({ name: 'a' }),
+    scriptedProvider([
+      priced({ content: '', cost: 0.07, outputTokens: 0 }),
+      priced({ cost: 0.03 }),
+    ]),
+  );
+  await driver.sendMessage('go');
+
+  const snapshots = driver.getTurnSnapshots();
+  assert.is(snapshots.length, 2, 'the retried attempt has its own snapshot');
+  assert.is(snapshots[0].usage?.costUsd, 0.07, 'the discarded attempt is still priced');
+  assert.is(
+    sumUsage(driver.getHistory()).costUsd,
+    0.03,
+    'and is genuinely absent from the transcript — that is the gap the snapshot fills',
+  );
+});
+
+suite('leaves usage undefined when the provider reports none', async () => {
+  // Absent, not zeroed: "this provider reports no usage" (e.g. Chrome's built-in model)
+  // must not read as a free call.
+  const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
+  await driver.sendMessage('go');
+  assert.is(driver.getTurnSnapshots()[0].usage, undefined);
+});
+
+suite.run();
+
+// ---------------------------------------------------------------------------
+// The reasoning/narration/answer split must not multiply the cache buckets.
+//
+// One model response becomes up to three messages; only the last carries usage.
+// The clearing list was written when usage meant cost + input + output, so when the
+// cache buckets arrived they kept riding along on the display-only copies — and every
+// bucket aggregate (session totals, usage rows, the exported log) counted a split
+// turn's cache volume two or three times. The cost total hid it, since that comes
+// from `cost`, which WAS cleared.
+// ---------------------------------------------------------------------------
+
+const split = createLogicSuite('ChatDriver response split usage');
+
+split('counts a reasoning + answer split once, not twice', async () => {
+  const response = priced({ reasoning: 'thinking…' });
+  const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([response]));
+  await driver.sendMessage('go');
+
+  const history = driver.getHistory();
+  assert.is(
+    history.filter((m) => m.role === 'assistant').length,
+    2,
+    'the response did split into a reasoning message and an answer',
+  );
+  assert.equal(
+    sumUsage(history),
+    messageUsage(response),
+    'the split totals exactly one call’s usage',
+  );
+  const reasoning = history.find((m) => m.category === 'reasoning')!;
+  assert.is(reasoning.cacheReadTokens, undefined, 'the display-only copy carries no cache volume');
+  assert.is(reasoning.cacheWriteTokens, undefined);
+});
+
+split('counts a reasoning + narration + answer split once', async () => {
+  // The three-way case: content alongside a tool call is interstitial narration, so this
+  // response produces reasoning + narration + the tool-call message. Worst case for the
+  // old behaviour — cache volume counted three times.
+  const first = priced({
+    content: 'let me look that up',
+    reasoning: 'thinking…',
+    cost: 0.02,
+    toolCalls: [{ id: 'w1', name: 'work', args: {} }],
+  });
+  const driver = makeDriver(
+    agent({
+      name: 'a',
+      toolDefinitions: [def('work')],
+      toolHandlers: { work: async () => 'worked' },
+    }),
+    scriptedProvider([first, priced({ cost: 0.03 })]),
+  );
+  await driver.sendMessage('go');
+
+  const total = sumUsage(driver.getHistory());
+  assert.is(total.costUsd, 0.05, 'two calls, each counted once');
+  assert.is(total.cacheReadTokens, 1800, '900 per call — not 2700 with the narration copies');
+  assert.is(total.cacheWriteTokens, 100);
+  assert.is(total.uncachedInputTokens, 100);
+});
+
+split.run();
+
+// ---------------------------------------------------------------------------
+// Per-turn model attribution across a tier switch.
+//
+// The shape this exists for is an agent whose `provider` selector varies by state —
+// e.g. the showcase trade-operations agent: `({state}) => isPlanning(state) ? High : Low`,
+// planning on sonnet and executing on haiku. Each call has to name the model that ran
+// it, on the turn itself: joining a turn to the message after it works for a normal
+// step but not for a call that produced no message, and `provider.selected` fires only
+// when the slot CHANGES, so the nearest event can be many turns back.
+//
+// The ordering trap: the snapshot is recorded BEFORE the provider is resolved for that
+// call, so stamping `lastResolvedModel` at creation time yields the previous call's
+// model — wrong on exactly the turn the tier changes.
+// ---------------------------------------------------------------------------
+
+const tiers = createLogicSuite('ChatDriver per-turn model attribution');
+
+/** A tiered registry: named slots, each reporting its own model via `getStatus`. */
+const tieredRegistry = (
+  slots: Record<string, AIProvider>,
+  defaultName: string,
+): AIProviderRegistry =>
+  ({
+    get: (name: string) => slots[name],
+    default: () => slots[defaultName],
+    defaultName: () => defaultName,
+    names: () => Object.keys(slots),
+    getStatus: async () => null,
+    listStatuses: async () => [],
+  }) as AIProviderRegistry;
+
+const tierProvider = (model: string, responses: ChatMessage[]): AIProvider => {
+  const queue = [...responses];
+  return {
+    getStatus: async () => ({ model, provider: 'anthropic' }) as never,
+    chat: async () => queue.shift() ?? { role: 'assistant', content: 'done' },
+  };
+};
+
+tiers('attributes each step to the tier that ran it when the agent switches mid-flow', async () => {
+  // Responses deliberately carry NO `model` of their own — the common case for a
+  // transport that leaves attribution to the driver, and the one where a stale
+  // `lastResolved*` read would go unnoticed.
+  const slots = {
+    high: tierProvider('claude-sonnet-4-6', [
+      priced({
+        content: '',
+        cost: 0.05,
+        toolCalls: [{ id: 'p1', name: 'finish_planning', args: {} }],
+      }),
+    ]),
+    low: tierProvider('claude-haiku-4-5-20251001', [priced({ content: 'Booked.', cost: 0.001 })]),
+  };
+  // The "state" the selector reads, advanced by the tool — as a flow agent's machine does.
+  let planning = true;
+  const driver = new ChatDriver(tieredRegistry(slots, 'low'), {
+    maxToolIterations: 20,
+    maxFoldOperations: 5,
+    sessionKey: 'tiers',
+  });
+  driver.applyAgent(
+    agent({
+      name: 'Trade Operations',
+      provider: () => (planning ? 'high' : 'low'),
+      toolDefinitions: [def('finish_planning')],
+      toolHandlers: {
+        finish_planning: async () => {
+          planning = false;
+          return 'planned';
+        },
+      },
+    }),
+  );
+  await driver.sendMessage('book me a trade');
+
+  const snapshots = driver.getTurnSnapshots();
+  assert.equal(
+    snapshots.map((s) => [s.providerName, s.model, s.usage?.costUsd]),
+    [
+      ['high', 'claude-sonnet-4-6', 0.05],
+      ['low', 'claude-haiku-4-5-20251001', 0.001],
+    ],
+    'the planning call is attributed to the high tier and the execution call to the low one',
+  );
+  assert.equal(
+    snapshots.map((s) => s.provider),
+    ['anthropic', 'anthropic'],
+    'the vendor behind each slot is recorded too',
+  );
+
+  // A turn and the message it produced must never disagree about which model ran.
+  const assistantModels = driver
+    .getHistory()
+    .filter((m) => m.role === 'assistant' && m.cost != null)
+    .map((m) => m.model);
+  assert.equal(
+    assistantModels,
+    snapshots.map((s) => s.model),
+  );
+});
+
+tiers('records the SERVING model when a fallback answers on another model', async () => {
+  // A server-side fallback chain answers on a different model than the one requested.
+  // The transport stamps the real one; the turn must follow it rather than relabel the
+  // call as the tier's configured model — that would misattribute the spend.
+  const slots = {
+    high: tierProvider('claude-fable-5', [
+      priced({ content: 'answered by the fallback', model: 'claude-opus-4-8' }),
+    ]),
+  };
+  const driver = new ChatDriver(tieredRegistry(slots, 'high'), {
+    maxToolIterations: 20,
+    maxFoldOperations: 5,
+    sessionKey: 'fallback',
+  });
+  driver.applyAgent(agent({ name: 'a', provider: 'high' }));
+  await driver.sendMessage('go');
+
+  const [turn] = driver.getTurnSnapshots();
+  assert.is(turn.model, 'claude-opus-4-8', 'the model that answered, not the one asked for');
+  assert.is(turn.providerName, 'high', 'the slot asked for is still recorded');
+});
+
+tiers('names the model and vendor on the provider.selected event, not just the slot', async () => {
+  clearMetaEventRegistry();
+  const slots = {
+    high: tierProvider('claude-sonnet-4-6', [priced({ content: 'hi' })]),
+  };
+  const driver = new ChatDriver(tieredRegistry(slots, 'high'), {
+    maxToolIterations: 20,
+    maxFoldOperations: 5,
+    sessionKey: 'selected',
+  });
+  driver.applyAgent(agent({ name: 'a', provider: 'high' }));
+  await driver.sendMessage('go');
+
+  const selected = getMetaEvents('selected').find((e) => e.type === 'provider.selected');
+  assert.ok(selected, 'a provider.selected event is recorded');
+  assert.is(selected!.detail?.provider, 'high', 'the registry slot');
+  assert.is(selected!.detail?.model, 'claude-sonnet-4-6', 'and the model behind it');
+  assert.is(selected!.detail?.vendor, 'anthropic');
+});
+
+tiers.run();