@genesislcap/ai-assistant 15.4.1 → 15.5.0

package/dist/dts/state/session-store.d.ts

@@ -11,8 +11,7 @@ declare function makeStore(devTools: boolean | undefined): import("@genesislcap/
     setSuggestionsState(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<import("..").SuggestionsState>): void;
     setContextTokens(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<number | undefined>): void;
     setContextLimit(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<number | undefined>): void;
-    setSessionCostUsd(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<number>): void;
-    setSessionTokensConsumed(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<number>): void;
+    setSessionUsage(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<import("@genesislcap/foundation-ai").AggregateUsage>): void;
     setActiveModel(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<string | undefined>): void;
     setActiveProviderName(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<string | undefined>): void;
     setProviderStatuses(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<import("@genesislcap/foundation-ai").AIProviderRegistryStatusEntry[]>): void;

package/dist/dts/state/session-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../../src/state/session-store.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAC;AAE9B,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC;AAIvD,iBAAS,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAM/C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,kBAAkB,CAMnF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED,YAAY,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,CAAC"}
+{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../../src/state/session-store.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAC;AAE9B,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC;AAIvD,iBAAS,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAM/C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,kBAAkB,CAMnF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED,YAAY,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/dts/styles/settings-section.d.ts

@@ -0,0 +1,29 @@
+import { type ElementStyles } from '@genesislcap/web-core';
+/**
+ * Heading style for a settings-modal section, published so a host can title its own section.
+ *
+ * The assistant renders no heading for the `settings-app` slot — no text and no icon — because
+ * only the host knows what that section is. The consequence is that a host supplying one has to
+ * reproduce the styling of the built-in headings beside it, and a copied rule drifts the moment
+ * either side changes. So the declarations live here, are applied by the assistant's own
+ * headings, and are exported for the host to apply to its.
+ *
+ * Compose it into a component's styles and put `ai-settings-section-title` on the heading:
+ *
+ * ```ts
+ * import { assistantSettingsSectionTitleStyles } from '@genesislcap/ai-assistant';
+ *
+ * const styles = css`
+ *   ${assistantSettingsSectionTitleStyles}
+ *   :host { display: block; }
+ * `;
+ * ```
+ *
+ * Carries no margin on purpose: spacing belongs to the surrounding layout, which differs
+ * between the assistant's own sections and a slotted one, and is the single declaration hosts
+ * had to diverge on when they copied this rule.
+ *
+ * @beta
+ */
+export declare const assistantSettingsSectionTitleStyles: ElementStyles;
+//# sourceMappingURL=settings-section.d.ts.map

package/dist/dts/styles/settings-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-section.d.ts","sourceRoot":"","sources":["../../../src/styles/settings-section.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,mCAAmC,EAAE,aAWjD,CAAC"}

package/dist/dts/utils/cost-session-history.d.ts

@@ -1,32 +1,123 @@
-import type { AIProviderType } from '@genesislcap/foundation-ai';
-/** A model used during a finalized cost session. */
+import type { AggregateUsage, AIProviderType } from '@genesislcap/foundation-ai';
+/** A model used during a recorded cost session. */
 export interface CostSessionModelEntry {
     model: string;
     /** Vendor id from `getStatus()` (e.g. `'anthropic'`, `'gemini'`). */
     provider?: AIProviderType;
 }
-/** Persisted snapshot of a completed assistant cost session. */
+/** Persisted usage record for one project's assistant work. */
 export interface CostSessionRecord {
     id: string;
+    /**
+     * Stable identity of the work this row stands for — the assistant's session key
+     * (a project id, for hosts that key sessions per project). The upsert key: a row
+     * is one project's lifetime usage, so re-reporting the same key REPLACES the row
+     * rather than adding another.
+     */
+    projectKey: string;
     title: string;
-    /** ISO-8601 timestamp when the session was finalized. */
-    endedAt: string;
-    costUsd: number;
-    tokensConsumed: number;
+    /**
+     * ISO-8601 timestamp of the most recent usage recorded for this row.
+     *
+     * Named for what it is: the row is upserted as spend accrues, so this moves. It is
+     * NOT an end time — a row has no terminal state, because a project can always be
+     * worked on again.
+     */
+    updatedAt: string;
+    /**
+     * Cost plus the four token buckets — the same shape the live session tile renders, so
+     * a history row can show the identical breakdown instead of a lone merged total that
+     * cannot explain a large token count at a small cost.
+     *
+     * This is the project's **lifetime** usage: `banked` plus whatever the live transcript
+     * currently proves.
+     */
+    usage: AggregateUsage;
+    /**
+     * Spend that predates the current transcript, and so cannot be re-derived from it.
+     *
+     * Without this a row could only ever report what the open transcript proves. That is
+     * fine when the transcript is restored on load (it *is* the project's history), but
+     * where it starts empty every refresh the row would be rewritten downwards on the next
+     * turn and the project's earlier spend lost. Banking it keeps `usage` a lifetime figure
+     * in both cases.
+     *
+     * Deliberately part of the row rather than element state: two assistant instances (a
+     * docked bubble and a popped-out panel) share one session, and both write this row. A
+     * value derived from the row keeps every write idempotent, whereas an element-held
+     * accumulator would be applied once per instance.
+     *
+     * Optional: rows written before this existed have none, which reads as "nothing banked".
+     */
+    banked?: AggregateUsage;
     models: CostSessionModelEntry[];
 }
 /** localStorage key for a host-scoped cost history list. */
 export declare function costHistoryStorageKey(scope: string): string;
-/** Load persisted cost sessions for a scope (newest first). */
+/**
+ * Load persisted cost sessions for a scope, in whatever order they were stored — this applies no
+ * ordering of its own. Display order is the caller's business; see `sortRecordsByRecency`.
+ */
 export declare function loadCostSessionHistory(scope: string): CostSessionRecord[];
 /** Replace the persisted list for a scope. */
 export declare function saveCostSessionHistory(scope: string, records: CostSessionRecord[]): void;
-/** Prepend a record and persist. Returns the updated list. */
-export declare function appendCostSessionRecord(scope: string, record: CostSessionRecord): CostSessionRecord[];
-/** Remove one record by id. Returns the updated list. */
-export declare function removeCostSessionRecord(scope: string, id: string): CostSessionRecord[];
+/**
+ * Pure upsert — `records` with `record` replacing any row sharing its `projectKey`, or
+ * prepended when there is none.
+ *
+ * An upsert, not an append, because a row stands for a **project's lifetime usage** rather
+ * than a visit to it. Appending cut a fresh row per page-hide, so one project accumulated
+ * a stack of near-identical rows and its spend was counted once per refresh by anything
+ * summing the list.
+ *
+ * The resulting array order is incidental — it is insertion order, so a project returned to
+ * stays where it first landed. Do not read it as recency; `sortRecordsByRecency` is what the
+ * Usage tab renders through.
+ *
+ * Storage-agnostic on purpose: the same merge serves the synchronous `localStorage` path
+ * and the async provider-backed one, so the two can never drift on what "upsert" means.
+ * The caller owns persistence — see the assistant's `persistCostHistory`.
+ */
+export declare function upsertRecord(records: readonly CostSessionRecord[], record: CostSessionRecord): CostSessionRecord[];
+/**
+ * Rows most-recently-worked-on first, as a new array.
+ *
+ * Applied at read time rather than baked into the stored order, so it covers rows that came from
+ * a host provider as well as from `localStorage`, and so no write path has to maintain it.
+ *
+ * `updatedAt` is ISO-8601, which sorts lexicographically — no date parsing, and no dependence on
+ * the strings being valid dates. Sorting by it rather than by insertion order is what makes the
+ * list track use: the active project moves to the top on its first upsert and stays there, since
+ * its row is rewritten on every transcript change.
+ */
+export declare function sortRecordsByRecency(records: readonly CostSessionRecord[]): CostSessionRecord[];
+/**
+ * The spend a project's next row must carry over from before its current transcript.
+ *
+ * `transcriptIsAuthoritative` means the open transcript already accounts for this project's
+ * history — true exactly when a session snapshot is restored on load. The two branches are
+ * not interchangeable, and picking the wrong one is silently destructive:
+ *
+ * - Authoritative: carry the previous row's own `banked` forward. Taking `usage` instead would
+ *   re-add the restored history on every reload, the compounding double-count this replaced.
+ * - Not authoritative: the whole previous total becomes banked, because nothing in the fresh
+ *   transcript accounts for it. Taking `banked` instead would rewrite the row down to the
+ *   current page-load and drop the project's earlier spend.
+ *
+ * Note both branches are idempotent — the result never includes the current transcript — which
+ * is what lets two assistant instances sharing a session write the same row.
+ */
+export declare function resolveBankedUsage(existing: CostSessionRecord | undefined, transcriptIsAuthoritative: boolean): AggregateUsage;
 /** Clear all persisted records for a scope. */
 export declare function clearCostSessionHistory(scope: string): void;
 /** Display date for a history row (e.g. "Jun 14, 2026"). */
 export declare function formatCostSessionDate(iso: string): string;
+/**
+ * Whether a value is a usable row. Exported because rows arrive by two routes and BOTH need it:
+ * `loadCostSessionHistory` filters the `localStorage` path here, and the assistant filters what a
+ * host provider returns. A row that skips this check is not merely ignored downstream — a
+ * half-shaped `usage` sums to `NaN` through every total, and a missing `updatedAt` throws inside
+ * the sort that orders the list, during render.
+ */
+export declare function isCostSessionRecord(value: unknown): value is CostSessionRecord;
 //# sourceMappingURL=cost-session-history.d.ts.map

package/dist/dts/utils/cost-session-history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cost-session-history.d.ts","sourceRoot":"","sources":["../../../src/utils/cost-session-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE,oDAAoD;AACpD,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,gEAAgE;AAChE,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,qBAAqB,EAAE,CAAC;CACjC;AAID,4DAA4D;AAC5D,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,+DAA+D;AAC/D,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAWzE;AAED,8CAA8C;AAC9C,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,GAAG,IAAI,CAOxF;AAED,8DAA8D;AAC9D,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,iBAAiB,GACxB,iBAAiB,EAAE,CAIrB;AAED,yDAAyD;AACzD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAItF;AAED,+CAA+C;AAC/C,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAO3D;AAED,4DAA4D;AAC5D,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMzD"}
+{"version":3,"file":"cost-session-history.d.ts","sourceRoot":"","sources":["../../../src/utils/cost-session-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAGjF,mDAAmD;AACnD,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;OAOG;IACH,KAAK,EAAE,cAAc,CAAC;IACtB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,MAAM,EAAE,qBAAqB,EAAE,CAAC;CACjC;AAqBD,4DAA4D;AAC5D,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAWzE;AAED,8CAA8C;AAC9C,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,GAAG,IAAI,CAOxF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,SAAS,iBAAiB,EAAE,EACrC,MAAM,EAAE,iBAAiB,GACxB,iBAAiB,EAAE,CAGrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,GAAG,iBAAiB,EAAE,CAE/F;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,iBAAiB,GAAG,SAAS,EACvC,yBAAyB,EAAE,OAAO,GACjC,cAAc,CAIhB;AAED,+CAA+C;AAC/C,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAO3D;AAED,4DAA4D;AAC5D,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAiB9E"}

package/dist/dts/utils/resolve-cost-history-config.d.ts

@@ -7,12 +7,18 @@ export interface ResolvedCostHistoryConfig {
     title?: string;
     /** `localStorage` scope key; falls back to element `id` then `'default'`. */
     scope?: string;
-    /** Show running session USD on the Cost tab. Default: `true`. */
+    /** Show running session USD on the Usage tab. Default: `true`. */
     showCost: boolean;
-    /** Show cumulative session tokens on the Cost tab. Default: `true`. */
+    /** Show cumulative session tokens on the Usage tab. Default: `true`. */
     showTokens: boolean;
-    /** Live-session badge label on the Cost tab summary. */
+    /** Live-session badge label on the Usage tab summary. */
     badgeLabel: string;
+    /**
+     * Host-supplied disclosure line for the Usage tab. Stays optional — unlike
+     * `badgeLabel` there is no default, because only the host knows what its `scope`
+     * spans, and the library must not assert it.
+     */
+    summaryHint?: string;
 }
 /** Resolve `chatConfig.costHistory` with defaults applied. */
 export declare function resolveCostHistoryConfig(chatConfig: ChatConfig): ResolvedCostHistoryConfig;

package/dist/dts/utils/resolve-cost-history-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-cost-history-config.d.ts","sourceRoot":"","sources":["../../../src/utils/resolve-cost-history-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7D,oEAAoE;AACpE,MAAM,WAAW,yBAAyB;IACxC,8EAA8E;IAC9E,OAAO,EAAE,OAAO,CAAC;IACjB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iEAAiE;IACjE,QAAQ,EAAE,OAAO,CAAC;IAClB,uEAAuE;IACvE,UAAU,EAAE,OAAO,CAAC;IACpB,wDAAwD;IACxD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,8DAA8D;AAC9D,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,UAAU,GAAG,yBAAyB,CAW1F"}
+{"version":3,"file":"resolve-cost-history-config.d.ts","sourceRoot":"","sources":["../../../src/utils/resolve-cost-history-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7D,oEAAoE;AACpE,MAAM,WAAW,yBAAyB;IACxC,8EAA8E;IAC9E,OAAO,EAAE,OAAO,CAAC;IACjB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,QAAQ,EAAE,OAAO,CAAC;IAClB,wEAAwE;IACxE,UAAU,EAAE,OAAO,CAAC;IACpB,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,8DAA8D;AAC9D,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,UAAU,GAAG,yBAAyB,CAY1F"}

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

@@ -1 +1 @@
-{"version":3,"file":"sum-costs.d.ts","sourceRoot":"","sources":["../../../src/utils/sum-costs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAUjE"}
+{"version":3,"file":"sum-costs.d.ts","sourceRoot":"","sources":["../../../src/utils/sum-costs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAG9D;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAEjE"}

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

@@ -1,19 +1,19 @@
 import type { ChatMessage } from '@genesislcap/foundation-ai';
 /**
- * Sum input + output tokens across a message list, recursing into each tool
- * call's `subAgentTrace` so sub-agent LLM usage contributes to the total.
+ * Total tokens across a message list — the headline figure, with the per-bucket
+ * split available from {@link sumUsage} for anything that needs to show *why* a
+ * large token count cost little.
+ *
+ * Identical arithmetic to the old per-message `inputTokens + outputTokens` sum:
+ * the three input buckets partition `inputTokens`, so they re-add to it exactly.
+ * It does now additionally count usage banked by a compaction, which is the point
+ * — that spend used to vanish when the summarised turns left the transcript.
  *
  * Returns 0 when no message carries token metadata.
  *
  * @internal
  */
 export declare function sumTokens(messages: readonly ChatMessage[]): number;
-/**
- * Compact plain-text token count (e.g. 1_400_000 → "1.4M").
- *
- * @internal
- */
-export declare function formatCompactTokenCountPlain(tokens: number): string;
 /**
  * Compact display for large token counts (e.g. 1_400_000 → value "1.4" + suffix "M").
  * Returns HTML markup so the suffix can be styled separately in the settings modal.

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

@@ -1 +1 @@
-{"version":3,"file":"sum-tokens.d.ts","sourceRoot":"","sources":["../../../src/utils/sum-tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAM9D;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CASlE;AAgCD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAMnE;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAI9D;AAED,0FAA0F;AAC1F,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAElE"}
+{"version":3,"file":"sum-tokens.d.ts","sourceRoot":"","sources":["../../../src/utils/sum-tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAI9D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAElE;AAgCD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAI9D;AAED,0FAA0F;AAC1F,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAElE"}

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

@@ -0,0 +1,59 @@
+import type { AggregateUsage, ChatMessage } from '@genesislcap/foundation-ai';
+/**
+ * Zeroed {@link AggregateUsage}. A factory, not a shared const, because callers
+ * accumulate into the returned object.
+ *
+ * @internal
+ */
+export declare function emptyUsage(): AggregateUsage;
+/**
+ * Total tokens processed — the four buckets added up. Safe to sum because the
+ * buckets are disjoint (see {@link AggregateUsage}); the equivalent sum over
+ * per-message fields would double-count the prompt.
+ *
+ * Bear in mind what this number is: because every turn resends the conversation,
+ * a turn's prompt is counted again in the next turn's. It is billed throughput,
+ * NOT the count of distinct tokens in the conversation, so it grows
+ * super-linearly with turn count and is expected to dwarf the context size.
+ *
+ * @internal
+ */
+export declare function totalTokens(usage: AggregateUsage): number;
+/**
+ * `a + b`, per bucket, as a new object.
+ *
+ * Used to lay a row's banked (pre-transcript) spend over what the live transcript
+ * proves. Pure rather than in-place because both operands are live state a caller
+ * must not mutate.
+ *
+ * @internal
+ */
+export declare function addUsage(a: AggregateUsage, b: AggregateUsage): AggregateUsage;
+/**
+ * Sum cost and per-bucket token usage across a message list.
+ *
+ * One walk produces everything a usage display needs, replacing separate cost and
+ * token passes over the same (potentially deep) transcript. Recurses into each
+ * tool call's `subAgentTrace`, so LLM work a sub-agent did — possibly on another
+ * provider at other rates — lands in the total; the driver embeds a whole
+ * sub-agent conversation in the parent's tool result, so this is the only place
+ * that spend is visible.
+ *
+ * Splitting the prompt into buckets is the point: `cost` already has the cache
+ * discount applied, but a single token total cannot show that a session was cheap
+ * because most of its prompt was a cache hit. The three input buckets are derived
+ * from the per-message fields, where `inputTokens` is the whole prompt and the
+ * cache fields break it down — so uncached input is the remainder, never an
+ * addition.
+ *
+ * Also counts `compaction.rolledUpUsage`: compaction destroys the messages it
+ * summarises, and without their banked usage every total re-derived from the
+ * transcript would drop by whatever those turns had already spent.
+ *
+ * Returns a zeroed total when no message carries usage — providers that report
+ * none (e.g. Chrome built-in) are skipped silently rather than guessed at.
+ *
+ * @internal
+ */
+export declare function sumUsage(messages: readonly ChatMessage[]): AggregateUsage;
+//# sourceMappingURL=sum-usage.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,cAAc,CAIzE"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sum-usage.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sum-usage.test.d.ts","sourceRoot":"","sources":["../../../src/utils/sum-usage.test.ts"],"names":[],"mappings":""}

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

@@ -7,6 +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 { TOOL_FOLD_SYMBOL } from '../../utils/tool-fold';
 const DEFAULT_MAX_TOOL_ITERATIONS = 50;
 const DEFAULT_MAX_FOLD_OPERATIONS = 5;
@@ -907,6 +908,11 @@ export class ChatDriver extends EventTarget {
                     tokensBefore,
                     model: status === null || status === void 0 ? void 0 : status.model,
                     createdAt,
+                    // Bank what the replaced turns spent. `toCompact` is dropped from history
+                    // below, taking its per-message cost/token fields with it — so a host total
+                    // re-derived from the transcript would otherwise fall by exactly this much
+                    // on every compaction. Summarising a turn does not refund what it cost.
+                    rolledUpUsage: sumUsage(toCompact),
                 },
             };
             this.loadHistory([summaryMessage, ...tail]);