@genesislcap/ai-assistant 15.12.0 → 15.13.1

package/dist/dts/state/persistence/diagnostics.d.ts

@@ -2,18 +2,19 @@
  * Server-saved diagnostics (GENC-1351 §5.8) — the forward-only stream that lets
  * the debug log persist across a whole session lifetime, not just the current
  * page load. This module owns the *pure* pieces: the entry type and the
- * reassembly back into the `{ readme, timeline, meta }` debug-log shape. The
- * element owns capture/cadence; the provider owns storage layout.
+ * reassembly back into the `{ readme, sessionUsage, timeline, meta }` debug-log
+ * shape. The element owns capture/cadence; the provider owns storage layout.
  *
  * @packageDocumentation
  */
+import type { AggregateUsage } from '@genesislcap/foundation-ai';
 /**
  * One entry in the diagnostics stream — the debug-log timeline-entry union
  * (`message` / `turn` / `event`, as `getDebugLog()` builds) plus a point-in-time
  * **`meta-snapshot`** carrying the export-time `meta` block (agent summary,
  * context, active debug snapshot, …). Kept permissive: a provider stores and
  * returns these opaquely, and reassembly reads only `kind`, `timestamp` (for
- * ordering), and `meta` (on a snapshot).
+ * ordering), `usage` (on a turn) and `meta` (on a snapshot).
  *
  * @public
  */
@@ -23,6 +24,16 @@ export interface DiagnosticEntry {
     timestamp?: string;
     /** Present on `meta-snapshot` entries: the export-time `meta` block. */
     meta?: unknown;
+    /**
+     * Present on a `turn` entry once its model call has returned and reported usage —
+     * the four token buckets plus USD for that one call (`TurnSnapshot.usage`).
+     *
+     * Read by the forward-capture delta as well as by readers: the turn entry is
+     * created *before* the call, so a flush that lands mid-call persists it without
+     * usage, and the delta re-emits it once (see `collectDiagnosticsDelta`) so the
+     * priced copy reaches the stream. {@link assembleDebugLog} then collapses the pair.
+     */
+    usage?: AggregateUsage;
     /**
      * Present on `meta-snapshot` entries: a stable signature of the near-static config
      * (excludes volatile timestamp/context/debug-snapshot), used by the forward-capture
@@ -35,6 +46,27 @@ export interface DiagnosticEntry {
 /** The reassembled debug log — the exact shape `getDebugLog()` returns. @public */
 export interface DebugLog {
     readme: readonly string[];
+    /**
+     * Session usage — the four token buckets plus USD cost — lifted out of the newest
+     * `meta-snapshot`'s `meta.context.sessionUsage` so the headline spend figures sit at
+     * the top of an exported log rather than buried under the (large) `meta` block. The
+     * same object, not a second derivation.
+     *
+     * `undefined` when the stream carries no `meta-snapshot`, or one written before the
+     * field existed. Never re-derived from the timeline: the per-request costs the
+     * transports stamped are authoritative, and a ring-buffered timeline can have lost
+     * entries the total still legitimately counts.
+     *
+     * **As current as the snapshot it came from, which is not automatically "now".** The
+     * forward-capture delta only re-appends a `meta-snapshot` when the near-static config
+     * signature changes, so the newest STORED snapshot of a session whose config never
+     * changed is its first — with the totals frozen there. A caller reassembling a stored
+     * stream on its own therefore gets stale figures unless it appends an export-time
+     * snapshot first: see {@link withFreshMetaSnapshot}, which is what the assistant's own
+     * download path does. `meta.timestamp` against the newest timeline entry tells you
+     * which case you are holding.
+     */
+    sessionUsage?: AggregateUsage;
     timeline: DiagnosticEntry[];
     meta: unknown;
 }
@@ -58,16 +90,41 @@ export interface DebugLog {
  */
 export declare function diagnosticsMessageKey(entry: DiagnosticEntry): string | null;
 /**
- * Reassemble diagnostic entries into the `{ readme, timeline, meta }` debug-log
- * shape (GENC-1351 §5.8). `timeline` = the `message`/`turn`/`event` entries sorted
+ * Reassemble diagnostic entries into the `{ readme, sessionUsage, timeline, meta }`
+ * debug-log shape (GENC-1351 §5.8). `timeline` = the `message`/`turn`/`event` entries sorted
  * by ISO `timestamp` (kind-rank tie-break). `meta` = the **newest** `meta-snapshot`'s
  * block only — a "state at export" photo, matching the single-page log. The older
  * snapshots are intentionally dropped: the per-turn evolution they would show is
  * already in the timeline (`turn.agentSnapshot` + `context.updated` events), so
  * keeping them would just repeat the bulky, near-static `agentSummary`. `readme` =
- * the passed (current) constant. Pure — reused for both the live current-page log
- * and the reassembled lifetime log stitched from the persisted stream, so both
- * come out shape-identical.
+ * the passed (current) constant. `sessionUsage` = that same newest snapshot's
+ * `meta.context.sessionUsage`, lifted to the top level. Pure — reused for both the
+ * live current-page log and the reassembled lifetime log stitched from the persisted
+ * stream, so both come out shape-identical.
+ *
+ * NOTE for a caller stitching a STORED stream (a headless consumer harvesting its own
+ * lifetime log, say): the newest stored `meta-snapshot` is frozen at the last
+ * config-signature change, so `meta` and `sessionUsage` are as old as that unless you
+ * pass a fresh snapshot of your own — {@link withFreshMetaSnapshot} does exactly that,
+ * and the element's download path goes through it.
  */
 export declare function assembleDebugLog(entries: DiagnosticEntry[], readme: readonly string[]): DebugLog;
+/**
+ * A stored diagnostics stream with its `meta-snapshot`s replaced by `fresh` — what to
+ * pass {@link assembleDebugLog} when reassembling a persisted stream for export.
+ *
+ * The stored snapshots are dropped rather than out-timestamped. `assembleDebugLog` keeps
+ * whichever claims the later time, and a stream written on another machine can carry a
+ * skewed clock; `fresh` is built from live state and so is the more current by
+ * construction. Only one snapshot ever survives reassembly, so the count is unchanged —
+ * though a snapshot taken while the driver is unwired (mid-popout) can leave
+ * `activeFoldStack`/`activeDebugSnapshot` unset where a stored one had them. The figures
+ * this exists for — the context block and `sessionUsage` — read the session store and
+ * element props, which survive an unwire.
+ *
+ * Pure, and separate from the element for that reason: the swap it performs is the fix
+ * for a silent bug (a lifetime log reporting near-zero spend against a transcript full of
+ * priced messages), so it needs to be testable without mounting anything.
+ */
+export declare function withFreshMetaSnapshot(stored: readonly DiagnosticEntry[], fresh: DiagnosticEntry): DiagnosticEntry[];
 //# sourceMappingURL=diagnostics.d.ts.map

package/dist/dts/state/persistence/diagnostics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/diagnostics.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,eAAe,CAAC;IACrD,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,mFAAmF;AACnF,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAI3E;AASD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,QAAQ,CA+BhG"}
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/diagnostics.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,eAAe,CAAC;IACrD,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,mFAAmF;AACnF,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,YAAY,CAAC,EAAE,cAAc,CAAC;IAC9B,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAI3E;AA+BD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,QAAQ,CA+ChG;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,SAAS,eAAe,EAAE,EAClC,KAAK,EAAE,eAAe,GACrB,eAAe,EAAE,CAEnB"}

package/dist/dts/state/persistence/index.d.ts

@@ -2,6 +2,6 @@ export { PERSISTED_SESSION_VERSION } from './session-snapshot';
 export type { PersistedSession } from './session-snapshot';
 export { WebStorageSessionProvider } from './session-persistence-provider';
 export type { SessionPersistenceProvider, SessionPersistenceConfig, SessionPreferences, } from './session-persistence-provider';
-export { assembleDebugLog } from './diagnostics';
+export { assembleDebugLog, withFreshMetaSnapshot } from './diagnostics';
 export type { DiagnosticEntry, DebugLog } from './diagnostics';
 //# sourceMappingURL=index.d.ts.map

package/dist/dts/state/persistence/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,YAAY,EACV,0BAA0B,EAC1B,wBAAwB,EACxB,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,YAAY,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,YAAY,EACV,0BAA0B,EAC1B,wBAAwB,EACxB,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACxE,YAAY,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC"}

package/dist/dts/state/persistence/session-persister.d.ts

@@ -162,9 +162,10 @@ export declare class SessionPersister {
     flushDiagnostics(): Promise<void>;
     /**
      * The diagnostic entries not yet appended this load — the forward-capture delta
-     * (§5.8). Skips messages present at restore or already appended; emits each turn
-     * (by turn-index) and meta-event (by index) once; appends a `meta-snapshot` only
-     * when the block changed. Advances the shared per-session cursors as it goes.
+     * (§5.8). Skips messages present at restore or already appended; emits each meta-event
+     * (by index) once and each turn (by turn-index) once unpriced plus once more when its
+     * per-call `usage` lands; appends a `meta-snapshot` only when the block changed.
+     * Advances the shared per-session cursors as it goes.
      *
      * TODO(GENC-1461, longer-term): this whole delta step exists only because the element *pulls* the
      * ENTIRE debug log on every throttled flush (`getDiagnosticEntries()` returns the full timeline),

package/dist/dts/state/persistence/session-persister.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-persister.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/session-persister.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sCAAsC,CAAC;AAWrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAsCnG;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,cAAc,EAAE,MAAM,wBAAwB,CAAC;IAC/C,+EAA+E;IAC/E,aAAa,EAAE,MAAM,MAAM,EAAE,CAAC;IAC9B,oEAAoE;IACpE,SAAS,EAAE,MAAM,QAAQ,GAAG,SAAS,CAAC;IACtC,mEAAmE;IACnE,QAAQ,EAAE,MAAM,kBAAkB,GAAG,SAAS,CAAC;IAC/C;;;;OAIG;IACH,oBAAoB,EAAE,MAAM,eAAe,EAAE,CAAC;CAC/C;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,gBAAgB;IA0Bf,OAAO,CAAC,IAAI;IAzBxB,OAAO,CAAC,UAAU,CAAC,CAAgC;IACnD,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,iBAAiB,CAAC,CAAgC;IAC1D,OAAO,CAAC,kBAAkB,CAAK;IAC/B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAA+B;IAC7C;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB,CAAmC;IAC7D;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB,CAAS;gBAEpB,IAAI,EAAE,oBAAoB;IAE9C;;;;;;;;;;OAUG;IACH,UAAU,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI;IAI5C,0FAA0F;IAC1F,IAAI,iBAAiB,IAAI,kBAAkB,GAAG,IAAI,CAEjD;IAED,uFAAuF;IACvF,IAAI,sBAAsB,IAAI,OAAO,CAEpC;IAED,OAAO,KAAK,QAAQ,GAEnB;IAED,OAAO,CAAC,OAAO;IAIf;;;;;OAKG;IACH,YAAY,IAAI,IAAI;IAapB;;;;;OAKG;IACH,iBAAiB,IAAI,IAAI;IAOzB;;;;OAIG;YACW,cAAc;IAsJ5B;;;;;;OAMG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoK9B;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;IAU/B;;;;OAIG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBvC;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAatC;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAchD;;;;;;OAMG;IACH,mBAAmB,IAAI,IAAI;IAiB3B;;;;;;OAMG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAYvC;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,uBAAuB;IAwC/B,sEAAsE;IACtE,OAAO,IAAI,IAAI;CAMhB"}
+{"version":3,"file":"session-persister.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/session-persister.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sCAAsC,CAAC;AAWrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAsCnG;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,cAAc,EAAE,MAAM,wBAAwB,CAAC;IAC/C,+EAA+E;IAC/E,aAAa,EAAE,MAAM,MAAM,EAAE,CAAC;IAC9B,oEAAoE;IACpE,SAAS,EAAE,MAAM,QAAQ,GAAG,SAAS,CAAC;IACtC,mEAAmE;IACnE,QAAQ,EAAE,MAAM,kBAAkB,GAAG,SAAS,CAAC;IAC/C;;;;OAIG;IACH,oBAAoB,EAAE,MAAM,eAAe,EAAE,CAAC;CAC/C;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,gBAAgB;IA0Bf,OAAO,CAAC,IAAI;IAzBxB,OAAO,CAAC,UAAU,CAAC,CAAgC;IACnD,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,iBAAiB,CAAC,CAAgC;IAC1D,OAAO,CAAC,kBAAkB,CAAK;IAC/B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAA+B;IAC7C;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB,CAAmC;IAC7D;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB,CAAS;gBAEpB,IAAI,EAAE,oBAAoB;IAE9C;;;;;;;;;;OAUG;IACH,UAAU,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI;IAI5C,0FAA0F;IAC1F,IAAI,iBAAiB,IAAI,kBAAkB,GAAG,IAAI,CAEjD;IAED,uFAAuF;IACvF,IAAI,sBAAsB,IAAI,OAAO,CAEpC;IAED,OAAO,KAAK,QAAQ,GAEnB;IAED,OAAO,CAAC,OAAO;IAIf;;;;;OAKG;IACH,YAAY,IAAI,IAAI;IAapB;;;;;OAKG;IACH,iBAAiB,IAAI,IAAI;IAOzB;;;;OAIG;YACW,cAAc;IAsJ5B;;;;;;OAMG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoK9B;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;IAU/B;;;;OAIG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBvC;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAatC;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAchD;;;;;;OAMG;IACH,mBAAmB,IAAI,IAAI;IAiB3B;;;;;;OAMG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAYvC;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,uBAAuB;IA+C/B,sEAAsE;IACtE,OAAO,IAAI,IAAI;CAMhB"}

package/dist/dts/utils/sum-usage.d.ts

@@ -29,6 +29,26 @@ export declare function totalTokens(usage: AggregateUsage): number;
  * @beta
  */
 export declare function addUsage(a: AggregateUsage, b: AggregateUsage): AggregateUsage;
+/**
+ * The four buckets plus USD for ONE message — the per-message fields projected into
+ * the disjoint, addable shape, or `undefined` when the message reports no usage at
+ * all (a user turn, a display-only reasoning/narration split, a provider that
+ * reports none).
+ *
+ * Shallow by design: it does NOT recurse into `toolCalls[].subAgentTrace` and does
+ * NOT count `compaction.rolledUpUsage`, so it answers "what did this one request
+ * cost" rather than "what did this message and everything under it cost". Use
+ * {@link sumUsage} for the latter — passing a whole transcript through this one
+ * message at a time would silently drop both.
+ *
+ * `costUsd` folds in `externalCostUsd` (non-LLM spend a widget reported), matching
+ * `sumUsage`. It is `0` when the provider priced nothing, which is NOT a claim that
+ * the call was free — see {@link AggregateUsage}; `UsageRow.costUsd` is the
+ * shape that keeps unpriced distinguishable, and is the right tool for a ledger.
+ *
+ * @beta
+ */
+export declare function messageUsage(m: ChatMessage): AggregateUsage | undefined;
 /**
  * Sum cost and per-bucket token usage across a message list.
  *

package/dist/dts/utils/sum-usage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sum-usage.d.ts","sourceRoot":"","sources":["../../../src/utils/sum-usage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9E;;;;;GAKG;AACH,wBAAgB,UAAU,IAAI,cAAc,CAQ3C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAIzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,cAAc,GAAG,cAAc,CAQ7E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,cAAc,CAIzE"}
+{"version":3,"file":"sum-usage.d.ts","sourceRoot":"","sources":["../../../src/utils/sum-usage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9E;;;;;GAKG;AACH,wBAAgB,UAAU,IAAI,cAAc,CAQ3C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAIzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,cAAc,GAAG,cAAc,CAQ7E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS,CAwBvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,cAAc,CAIzE"}

package/dist/esm/chat-driver-node.js

@@ -62,7 +62,13 @@ vendorOfModel, } from '@genesislcap/foundation-ai';
 // `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
 // unpriced. `usageRows` is guaranteed to reconcile with `sumUsage` — including spend a
@@ -80,4 +86,8 @@ export { usageRows } from './utils/usage-rows';
 // All three modules are DOM-clean, so the node entry stays Node-loadable.
 export { clearSession, getMetaEvents } from './state/debug-event-log';
 export { buildTimelineEntries } 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';

package/dist/esm/components/chat-driver/chat-driver.js

@@ -7,7 +7,7 @@ import { createInteractionContext, } from '../../state/interaction-context';
 import { applyCondensation } from '../../utils/condense-history';
 import { applyHistoryCap, buildCompactionSummaryPrompt, findCompactionCut, 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 } from '../../utils/tool-fold';
 /**
  * Lift the reportable facts off a {@link BudgetExhaustedError}, or `undefined`
@@ -683,7 +683,14 @@ export class ChatDriver extends EventTarget {
             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(new CustomEvent('provider-changed', { detail: { name: resolvedName } }));
@@ -841,6 +848,10 @@ export class ChatDriver extends EventTarget {
      * 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.
      */
     recordTurnSnapshot(resolvedSystemPrompt, temperature, toolChoice, tailContext) {
         let agentSnapshot;
@@ -857,7 +868,7 @@ export class ChatDriver extends EventTarget {
         }
         const turnIndex = String(this.globalTurnIndex);
         this.globalTurnIndex += 1;
-        this.turnSnapshots.push({
+        const snapshot = {
             turnIndex,
             timestamp: new Date().toISOString(),
             agentName: this.activeAgentName,
@@ -868,10 +879,12 @@ export class ChatDriver extends EventTarget {
             temperature,
             toolChoice,
             agentSnapshot,
-        });
+        };
+        this.turnSnapshots.push(snapshot);
         if (this.turnSnapshots.length > this.maxTurnSnapshots) {
             this.turnSnapshots.shift();
         }
+        return snapshot;
     }
     /**
      * Optional transform applied to conversation history immediately before each LLM request.
@@ -2134,7 +2147,7 @@ export class ChatDriver extends EventTarget {
                 // on a free-text answer; top-level agents stay 'auto'. (Transports no-op a
                 // force when no tools are advertised.)
                 const effectiveToolChoice = resolvedToolChoice !== null && resolvedToolChoice !== void 0 ? 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`,
                 // so on retries (empty / malformed) we must rely on history alone —
@@ -2180,6 +2193,20 @@ export class ChatDriver extends EventTarget {
                 // here and cached for the agent's lifetime.
                 // oxlint-disable-next-line no-await-in-loop
                 const activeProvider = yield 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;
                 try {
                     // oxlint-disable-next-line no-await-in-loop
@@ -2359,6 +2386,19 @@ export class ChatDriver extends EventTarget {
                 if (this.lastResolvedProviderName !== undefined) {
                     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 && ((_f = response.toolCalls) === null || _f === void 0 ? void 0 : _f.length);
                 const isEmptyResponse = !((_g = response.content) === null || _g === void 0 ? void 0 : _g.trim()) && !((_h = response.toolCalls) === null || _h === void 0 ? void 0 : _h.length);
                 // A pre-output refusal (safety-classifier decline, e.g. Fable 5 `stop_reason: 'refusal'`)
@@ -2405,8 +2445,23 @@ export class ChatDriver extends EventTarget {
                     // `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 } = response, rest = __rest(response, ["reasoning"]);
-                    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(Object.assign(Object.assign(Object.assign({}, rest), displayOnly), { content: reasoning, toolCalls: undefined, category: 'reasoning' }));
                     }

package/dist/esm/components/chat-driver/chat-driver.turn-usage.test.js

@@ -0,0 +1,268 @@
+import { __awaiter } from "tslib";
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+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) => ({
+    get: () => provider,
+    default: () => provider,
+    defaultName: () => 'test',
+    names: () => ['test'],
+    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
+});
+/** Answers from a queue, then ends the turn with a plain unpriced reply. */
+const scriptedProvider = (responses) => {
+    const queue = [...responses];
+    return {
+        chat: () => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = queue.shift()) !== null && _a !== void 0 ? _a : { role: 'assistant', content: 'done' }; }),
+    };
+};
+const agent = (overrides) => (Object.assign({ description: 'test agent' }, overrides));
+const makeDriver = (config, provider) => {
+    const driver = new ChatDriver(makeRegistry(provider), {
+        maxToolIterations: 50,
+        maxFoldOperations: 5,
+        sessionKey: '',
+    });
+    driver.applyAgent(config);
+    return driver;
+};
+const def = (name) => ({
+    name,
+    description: `${name} tool`,
+    parameters: { type: 'object', properties: {} },
+});
+/** One priced response: a 1000-token prompt that was mostly a cache hit. */
+const priced = (over = {}) => (Object.assign({ 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', () => __awaiter(void 0, void 0, void 0, function* () {
+    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([priced()]));
+    yield 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', () => __awaiter(void 0, void 0, void 0, function* () {
+    const driver = makeDriver(agent({
+        name: 'a',
+        toolDefinitions: [def('work')],
+        toolHandlers: { work: () => __awaiter(void 0, void 0, void 0, function* () { return 'worked'; }) },
+    }), scriptedProvider([
+        priced({ content: '', cost: 0.02, toolCalls: [{ id: 'w1', name: 'work', args: {} }] }),
+        priced({ cost: 0.03 }),
+    ]));
+    yield 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) => { var _a; return (_a = s.usage) === null || _a === void 0 ? void 0 : _a.costUsd; }), [0.02, 0.03]);
+}));
+suite('prices a blank response that produced no message', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    // 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 }),
+    ]));
+    yield driver.sendMessage('go');
+    const snapshots = driver.getTurnSnapshots();
+    assert.is(snapshots.length, 2, 'the retried attempt has its own snapshot');
+    assert.is((_a = snapshots[0].usage) === null || _a === void 0 ? void 0 : _a.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', () => __awaiter(void 0, void 0, void 0, function* () {
+    // 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([]));
+    yield 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', () => __awaiter(void 0, void 0, void 0, function* () {
+    const response = priced({ reasoning: 'thinking…' });
+    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([response]));
+    yield 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', () => __awaiter(void 0, void 0, void 0, function* () {
+    // 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: () => __awaiter(void 0, void 0, void 0, function* () { return 'worked'; }) },
+    }), scriptedProvider([first, priced({ cost: 0.03 })]));
+    yield 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, defaultName) => ({
+    get: (name) => slots[name],
+    default: () => slots[defaultName],
+    defaultName: () => defaultName,
+    names: () => Object.keys(slots),
+    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
+});
+const tierProvider = (model, responses) => {
+    const queue = [...responses];
+    return {
+        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ model, provider: 'anthropic' }); }),
+        chat: () => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = queue.shift()) !== null && _a !== void 0 ? _a : { role: 'assistant', content: 'done' }; }),
+    };
+};
+tiers('attributes each step to the tier that ran it when the agent switches mid-flow', () => __awaiter(void 0, void 0, void 0, function* () {
+    // 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: () => __awaiter(void 0, void 0, void 0, function* () {
+                planning = false;
+                return 'planned';
+            }),
+        },
+    }));
+    yield driver.sendMessage('book me a trade');
+    const snapshots = driver.getTurnSnapshots();
+    assert.equal(snapshots.map((s) => { var _a; return [s.providerName, s.model, (_a = s.usage) === null || _a === void 0 ? void 0 : _a.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', () => __awaiter(void 0, void 0, void 0, function* () {
+    // 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' }));
+    yield 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', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    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' }));
+    yield driver.sendMessage('go');
+    const selected = getMetaEvents('selected').find((e) => e.type === 'provider.selected');
+    assert.ok(selected, 'a provider.selected event is recorded');
+    assert.is((_a = selected.detail) === null || _a === void 0 ? void 0 : _a.provider, 'high', 'the registry slot');
+    assert.is((_b = selected.detail) === null || _b === void 0 ? void 0 : _b.model, 'claude-sonnet-4-6', 'and the model behind it');
+    assert.is((_c = selected.detail) === null || _c === void 0 ? void 0 : _c.vendor, 'anthropic');
+}));
+tiers.run();