@genesislcap/ai-assistant 15.33.1 → 15.34.0

package/dist/esm/main/budget-controller.js

@@ -105,6 +105,165 @@ export function budgetPercentOf(figures) {
         return 100;
     return Math.round((figures.spentUsd / figures.budgetUsd) * 100);
 }
+/**
+ * How far a breakdown may add up to MORE than the spend and still count as a breakdown of it
+ * (NEW-15): half a cent per segment, plus a margin for float error.
+ *
+ * Money is shown to the cent, and the obvious host keeps its total at full precision while
+ * reporting each source rounded to the cent. Each rounded part can then be up to half a cent
+ * high, so a two-part breakdown of a $6.386 total can honestly read $4.79 + $1.60 = $6.39. A
+ * float-scale slack rejected that as "a breakdown of some other total" while the row printed
+ * $6.39 beside it; whether a host got a stacked bar at all came down to which way its rounding
+ * went. Scaled by the segment count because the rounding error accumulates per part.
+ */
+const SEGMENT_HALF_CENT_USD = 0.005;
+const SEGMENT_FLOAT_MARGIN_USD = 1e-9;
+/**
+ * The narrowest remainder worth drawing, as a percentage of the track: about 2-3px at the
+ * settings modal's widths.
+ *
+ * Whether a remainder "exists" is a drawing decision, so it is made on what can be seen, not
+ * on dollars. Adjacent pieces are separated by a 1px hairline that comes out of each piece's
+ * own width, so anything narrower than a couple of pixels renders as nothing but that hairline.
+ * A dollar threshold gets this wrong at every scale: $0.004 on a $6 bar and $0.01 on a $1000 bar
+ * are both invisible, yet either one would pull the whole bar a tone paler (the named segments
+ * give up full strength to a remainder) because of a piece nobody can see.
+ */
+const REMAINDER_MIN_VISIBLE_PERCENT = 0.5;
+/**
+ * The id the meter gives unattributed spend. Reserved: a host segment may not use it, so the
+ * remainder can never be mistaken for, or collide with, a source the host named.
+ */
+const REMAINDER_SEGMENT_ID = '__remainder__';
+/**
+ * The segments of a host's figures, if they hold up — `undefined` when there are none, or
+ * when they are not a breakdown of the spend beside them.
+ *
+ * Dropped rather than rejected: the dollars are still true, so the meter falls back to the
+ * single bar rather than losing the vendor's row over a bad breakdown. Logged at debug, not
+ * warn, because the figures the user sees remain correct — this is a host-side wiring
+ * detail, and the meter is re-fed after every turn.
+ *
+ * Exported for the unit test that pins the rules; not element API.
+ *
+ * @internal
+ */
+export function validSegments(figures) {
+    const { segments } = figures;
+    if (segments == null)
+        return undefined;
+    if (!Array.isArray(segments) || segments.length === 0) {
+        logger.debug('setVendorBudget: segments is not a non-empty array — drawing the single bar.');
+        return undefined;
+    }
+    const malformed = segments.find((s) => !s ||
+        typeof s.id !== 'string' ||
+        !s.id ||
+        typeof s.label !== 'string' ||
+        typeof s.spentUsd !== 'number' ||
+        !Number.isFinite(s.spentUsd) ||
+        s.spentUsd < 0);
+    if (malformed !== undefined) {
+        logger.debug('setVendorBudget: a segment needs an id, a label and a finite spentUsd >= 0 ' +
+            `(got ${JSON.stringify(malformed)}) — drawing the single bar.`);
+        return undefined;
+    }
+    // Ids identify sources, so two sources cannot share one, and none may take the remainder's.
+    const ids = segments.map((s) => s.id);
+    if (new Set(ids).size !== ids.length || ids.includes(REMAINDER_SEGMENT_ID)) {
+        logger.debug(`setVendorBudget: segment ids must be unique and not "${REMAINDER_SEGMENT_ID}" ` +
+            `(got ${JSON.stringify(ids)}) — drawing the single bar.`);
+        return undefined;
+    }
+    const sum = segments.reduce((total, s) => total + s.spentUsd, 0);
+    const slackUsd = SEGMENT_HALF_CENT_USD * segments.length + SEGMENT_FLOAT_MARGIN_USD;
+    if (sum > figures.spentUsd + slackUsd) {
+        // A breakdown that adds up to more than the total is a breakdown of some OTHER total,
+        // and drawing it would put a bar on screen that disagrees with the text beside it.
+        logger.debug(`setVendorBudget: segments total ${sum}, which is more than spentUsd ${figures.spentUsd} ` +
+            '— drawing the single bar.');
+        return undefined;
+    }
+    return { segments: segments.map((s) => ({ id: s.id, label: s.label, spentUsd: s.spentUsd })) };
+}
+/**
+ * Tone (alpha) per segment, applied to the design system's accent so a stacked bar reads as
+ * one measure split into parts rather than a chart of unrelated colours — and so it needs no
+ * palette of its own, in a component that is themed by whatever design system hosts it.
+ *
+ * Positional, and paired with a legend, because tone alone is not a label.
+ *
+ * Exactly ONE piece is drawn at full strength, and which one depends on the breakdown:
+ *
+ * - With an unattributed remainder, it goes to the remainder, the plain spend colour, and the
+ *   named segments start one step down. Otherwise the first segment and the remainder would be
+ *   indistinguishable, its legend swatch would appear to describe both, and a half-attributed
+ *   bar would read as wholly that one source.
+ * - With the whole spend attributed there is no remainder to reserve it for, so it goes to the
+ *   first segment. Without that, a fully attributed bar — the normal case for a host that splits
+ *   all of its spend — would read paler than the same spend drawn as a plain bar.
+ */
+const SEGMENT_TONE_RATIO = 0.62;
+const SEGMENT_TONE_FLOOR = 0.18;
+const FULL_TONE = 1;
+/**
+ * The stacked bar's parts, pre-computed like the row text around them.
+ *
+ * Widths are shares of the TRACK, scaled from the unrounded, clamped spend ratio rather than
+ * the whole-percent `barValue` the plain bar uses. Scaling from the rounded figure left a $4
+ * spend on a $1000 cap with zero-width pieces under a legend reading $3.00 and $1.00, and drifted
+ * the bar up to half a point from its own text everywhere else. When spend overshoots the cap the
+ * ratio clamps at 100, so the pieces still add up to exactly the track.
+ *
+ * A remainder — spend the host did not attribute — takes the leftover width unlabelled, but only
+ * when it is wide enough to see (see {@link REMAINDER_MIN_VISIBLE_PERCENT}). When it is not, the
+ * named segments are stretched to fill the whole bar instead, so the bar's length always matches
+ * the figure beside it.
+ *
+ * Exported for the unit test that pins the arithmetic; not element API.
+ *
+ * @internal
+ */
+export function budgetSegmentRows(figures) {
+    const segments = figures.segments;
+    if (!(segments === null || segments === void 0 ? void 0 : segments.length))
+        return undefined;
+    const { budgetUsd, spentUsd } = figures;
+    // Same rule as the plain bar: a $0 cap has no headroom by definition, so it reads full.
+    const ratio = budgetUsd <= 0 ? 100 : Math.min(100, (spentUsd / budgetUsd) * 100);
+    const attributedUsd = segments.reduce((total, s) => total + s.spentUsd, 0);
+    // With nothing spent there is nothing to attribute, but a $0 cap still draws a full bar — so
+    // the whole of it is unattributed. Otherwise adding a breakdown of nothing would empty a bar
+    // that the same figures draw full without one.
+    const remainderWidth = spentUsd > 0 ? (Math.max(0, spentUsd - attributedUsd) / spentUsd) * ratio : ratio;
+    // Decided ONCE and used for both the tones and whether the remainder is drawn, so the two
+    // can never disagree about whether there is a remainder.
+    const hasRemainder = remainderWidth >= REMAINDER_MIN_VISIBLE_PERCENT;
+    const namedWidth = hasRemainder ? ratio - remainderWidth : ratio;
+    // Every segment is 0 wide when nothing has been attributed, which is the honest drawing of a
+    // breakdown of $0.00 — the legend still says which sources are being watched.
+    const perUsd = attributedUsd > 0 ? namedWidth / attributedUsd : 0;
+    const firstTone = hasRemainder ? SEGMENT_TONE_RATIO : FULL_TONE;
+    const rows = segments.map((segment, i) => ({
+        id: segment.id,
+        label: segment.label,
+        figures: formatUsd(segment.spentUsd),
+        widthPercent: segment.spentUsd * perUsd,
+        tone: Math.max(SEGMENT_TONE_FLOOR, firstTone * Math.pow(SEGMENT_TONE_RATIO, i)),
+        legend: true,
+    }));
+    if (hasRemainder) {
+        rows.push({
+            id: REMAINDER_SEGMENT_ID,
+            label: '',
+            figures: '',
+            widthPercent: remainderWidth,
+            tone: FULL_TONE,
+            legend: false,
+        });
+    }
+    return rows;
+}
 /**
  * The AI-spend budget: which vendors are walled, whether that locks the composer,
  * the banner copy that explains it, and the settings-modal meter (GENC-1464).
@@ -302,7 +461,9 @@ export class BudgetController {
             vendor: vendor,
             // A fresh literal, never the caller's object — see the reducer, which
             // must not adopt (and potentially freeze) state the host still owns.
-            figures: figures == null ? null : { budgetUsd: figures.budgetUsd, spentUsd: figures.spentUsd },
+            figures: figures == null
+                ? null
+                : Object.assign({ budgetUsd: figures.budgetUsd, spentUsd: figures.spentUsd }, validSegments(figures)),
         });
         if (figures != null)
             this.meterLastFedAt = Date.now();
@@ -495,7 +656,7 @@ export class BudgetController {
      *   when the budget payload names none.
      */
     latchFrom(reason, ref = this.deps.sessionRef(), budget, vendorHint) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         if (reason !== 'budget-exhausted')
             return;
         const vendor = (_b = (_a = vendorTypeOfLabel(budget === null || budget === void 0 ? void 0 : budget.vendorLabel)) !== null && _a !== void 0 ? _a : budget === null || budget === void 0 ? void 0 : budget.vendor) !== null && _b !== void 0 ? _b : vendorHint;
@@ -512,9 +673,16 @@ export class BudgetController {
         // so a teardown race cannot land it in a new session's store.
         let metered = false;
         if (vendor && vendor !== 'none' && (budget === null || budget === void 0 ? void 0 : budget.budgetUsd) != null && (budget === null || budget === void 0 ? void 0 : budget.spentUsd) != null) {
+            const fresh = { budgetUsd: budget.budgetUsd, spentUsd: budget.spentUsd };
+            // A 402 reports totals, never the host's breakdown — so writing these figures alone
+            // would collapse a stacked bar to a single one at the exact moment the user is looking
+            // at it, until the next host feed. The stored segments are carried over while they
+            // still hold against the new spend (they normally do: spend only grows), and the host's
+            // own re-feed replaces them with fresher ones a moment later.
+            const stored = (_d = (_c = ref === null || ref === void 0 ? void 0 : ref.store.aiAssistant.vendorBudgets) === null || _c === void 0 ? void 0 : _c[vendor]) === null || _d === void 0 ? void 0 : _d.segments;
             ref === null || ref === void 0 ? void 0 : ref.actions.aiAssistant.setVendorBudget({
                 vendor,
-                figures: { budgetUsd: budget.budgetUsd, spentUsd: budget.spentUsd },
+                figures: Object.assign(Object.assign({}, fresh), validSegments(Object.assign(Object.assign({}, fresh), { segments: stored }))),
             });
             this.meterLastFedAt = Date.now();
             metered = true;
@@ -698,13 +866,17 @@ export class BudgetController {
             if (!figures)
                 continue;
             const percent = budgetPercentOf(figures);
+            // The same clamp the context indicator applies to its bar. No lower
+            // clamp needed: the boundary refuses negative figures.
+            const barValue = Math.min(100, percent);
             rows.push({
                 vendor,
                 label: vendorDisplayName(vendor),
                 figures: `${formatUsd(figures.spentUsd)} / ${formatUsd(figures.budgetUsd)} (${percent}%)`,
-                // The same clamp the context indicator applies to its bar. No lower
-                // clamp needed: the boundary refuses negative figures.
-                barValue: Math.min(100, percent),
+                barValue,
+                // Absent unless the host broke the spend down, which is what keeps the unsegmented
+                // row on the design system's own progress element rather than a lookalike.
+                segments: budgetSegmentRows(figures),
             });
         }
         return rows;

package/dist/esm/main/main.js

@@ -1018,6 +1018,26 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
      * }
      * ```
      *
+     * A host that meters its spend by source can pass an optional `segments` breakdown, and
+     * the vendor's bar is drawn stacked with a legend naming each one (NEW-15):
+     *
+     * ```ts
+     * assistantEl.setVendorBudget('anthropic', {
+     *   budgetUsd: 50,
+     *   spentUsd: 12.5,
+     *   segments: [
+     *     { id: 'app', label: 'App', spentUsd: 9 },
+     *     { id: 'batch', label: 'Batch jobs', spentUsd: 3.5 },
+     *   ],
+     * });
+     * ```
+     *
+     * The labels are yours — the assistant has no vocabulary for what a host spends money on.
+     * Segments may add up to less than `spentUsd` (the remainder draws unlabelled) but never
+     * to more; a breakdown that does, or that is otherwise malformed, is dropped with a debug
+     * log and the single bar renders. Omit `segments` entirely and nothing about the meter
+     * changes.
+     *
      * Re-run it on mount and after each turn. Scope and lifetime follow the rest
      * of the session slice (per `stateKey`, survives pop-in/out and "Clear" /
      * "New chat") — except that the figures are NOT persisted to the session

package/dist/esm/provider/tiered-provider-switcher.js

@@ -0,0 +1,142 @@
+import { AI_TIER_VENDORS, buildTierProviders, registerAIProviders, } from '@genesislcap/foundation-ai';
+import { Registration } from '@genesislcap/web-core';
+import { AIProviderSwitcher } from './ai-provider-switcher';
+/**
+ * Which cloud vendor backs the tier-shaped provider registry, plus the means to move it at
+ * runtime (GENC-1610).
+ *
+ * @remarks
+ * Upstreamed from Genesis Create, which has run this shape in production: a registry keyed by
+ * tier (`low` / `high` / `reasoning`), a vendor switch that rebuilds it in place, and the other
+ * vendor kept alive as a standby entry. Agents keep resolving tier names, so a switch never
+ * touches agent config.
+ *
+ * Register it on the {@link (AIProviderSwitcher:interface)} DI token — via
+ * {@link registerTieredAIProviders} — and the settings modal's vendor UI (or an app's own
+ * control) drives it.
+ *
+ * @beta
+ */
+export class TieredAIProviderSwitcher {
+    constructor(options) {
+        var _a, _b;
+        this.listeners = new Set();
+        // The type already says so; this is for untyped JS hosts, which would otherwise find out
+        // one turn at a time, on the vendor they did not boot on.
+        if (typeof options.serverEndpoint !== 'function') {
+            throw new Error('TieredAIProviderSwitcher: serverEndpoint must be a function of the vendor, e.g. ' +
+                '(vendor) => `/gwf/ai-service/${vendor}/chat`. A plain string would route every ' +
+                "vendor's requests to one vendor's proxy.");
+        }
+        this.options = options;
+        this.vendors = (_a = options.vendors) !== null && _a !== void 0 ? _a : AI_TIER_VENDORS;
+        // Same reasoning as the endpoint check: fail here, not a turn at a time later. Booting on a
+        // vendor outside `vendors` serves one the app has just declared it cannot reach, and is a
+        // one-way door — `switchTo` refuses to go back to it once anything switches away. An empty
+        // list yields a switcher that can never switch at all. The realistic way in is an
+        // `initialVendor` read from the environment while `vendors` is narrowed per environment.
+        if (this.vendors.length === 0) {
+            throw new Error('TieredAIProviderSwitcher: `vendors` is empty — there is nothing to switch.');
+        }
+        if (!this.vendors.includes(options.initialVendor)) {
+            throw new Error(`TieredAIProviderSwitcher: initialVendor '${options.initialVendor}' is not one of ` +
+                `vendors [${this.vendors.join(', ')}]. The app would boot on a vendor it cannot ` +
+                'switch back to.');
+        }
+        this.defaultTier = (_b = options.defaultTier) !== null && _b !== void 0 ? _b : 'high';
+        this._vendor = options.initialVendor;
+        this.registry = registerAIProviders(options.container, this.build(this._vendor), {
+            default: this.defaultTier,
+        });
+    }
+    get vendor() {
+        return this._vendor;
+    }
+    /**
+     * A user-driven switch: move the registry, then tell the app so it can persist the choice.
+     * An unknown vendor is ignored.
+     */
+    switchTo(vendor) {
+        var _a, _b;
+        if (!this.isKnownVendor(vendor))
+            return;
+        this.apply(vendor);
+        (_b = (_a = this.options).onSwitch) === null || _b === void 0 ? void 0 : _b.call(_a, vendor);
+    }
+    /**
+     * Adopt a vendor the app read back from its own store — the same registry move as
+     * {@link TieredAIProviderSwitcher.switchTo}, without the `onSwitch` callback, because this
+     * value came FROM the store and writing it back would be a pointless round-trip on load.
+     *
+     * Exists because registration has to stay synchronous: an element that connects before the
+     * token is registered caches the platform's no-op fallback, so an app cannot await its
+     * stored preference before constructing this. It boots on `initialVendor` and adopts the
+     * stored one a moment later, through a registry that is mutable and held by reference.
+     */
+    adoptPersistedVendor(vendor) {
+        if (!this.isKnownVendor(vendor))
+            return;
+        this.apply(vendor);
+    }
+    subscribe(listener) {
+        const wrapped = (vendor) => listener(vendor);
+        this.listeners.add(wrapped);
+        return () => {
+            this.listeners.delete(wrapped);
+        };
+    }
+    /** The registry move both entry points share, and nothing else. */
+    apply(vendor) {
+        if (vendor === this._vendor)
+            return;
+        this.registry.update(this.build(vendor), { default: this.defaultTier });
+        this._vendor = vendor;
+        for (const listener of Array.from(this.listeners))
+            listener(vendor);
+    }
+    build(vendor) {
+        const { serverEndpoint, tiers } = this.options;
+        const providers = Object.assign({}, buildTierProviders({ vendor, serverEndpoint, tiers }));
+        // Every OTHER vendor rides along as a standby entry, so all of them report a status at
+        // once. The assistant's `reachableVendors` — and with it the whole partial-wall UX — is
+        // fed by registry statuses: with one vendor registered at a time, a budget wall always
+        // locks the composer outright and the banner can never honestly offer the switch that
+        // the settings modal is about to perform.
+        //
+        // Agents resolve tier names, so a standby never serves a turn until it becomes the
+        // active vendor, and as a status source it makes no network calls. Which tier backs it
+        // is arbitrary — `low` simply builds the cheapest object; nothing reads the difference.
+        for (const other of this.vendors) {
+            if (other === vendor)
+                continue;
+            providers[`standby-${other}`] = buildTierProviders({
+                vendor: other,
+                serverEndpoint,
+                tiers,
+            }).low;
+        }
+        return providers;
+    }
+    isKnownVendor(vendor) {
+        return this.vendors.includes(vendor);
+    }
+}
+/**
+ * Build a {@link TieredAIProviderSwitcher} — which registers the tier-shaped provider
+ * registry — and put it on the {@link (AIProviderSwitcher:variable)} token. Call once at app
+ * bootstrap.
+ *
+ * @remarks
+ * Everything here is synchronous and has to stay that way. `foundation-ai-assistant` resolves
+ * the switcher and registry tokens as it connects, and an element that connects first caches
+ * the no-op fallback — so an `await` above this call costs the whole page load its providers.
+ * Load a stored vendor preference AFTER it, through
+ * {@link TieredAIProviderSwitcher.adoptPersistedVendor}.
+ *
+ * @beta
+ */
+export function registerTieredAIProviders(container, options) {
+    const switcher = new TieredAIProviderSwitcher(Object.assign(Object.assign({}, options), { container }));
+    container.register(Registration.instance(AIProviderSwitcher, switcher));
+    return switcher;
+}

package/dist/esm/state/ai-assistant-slice.js

@@ -44,6 +44,18 @@ export function createDefaultSessionState() {
     };
 }
 export const defaultSessionState = createDefaultSessionState();
+/**
+ * Whether two segment lists say the same thing — the segment half of `setVendorBudget`'s
+ * by-value idempotence. Hosts re-feed the meter after every turn, so a fresh array holding
+ * identical figures must not publish a new store reference and re-render an unchanged bar.
+ */
+function sameSegments(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b || a.length !== b.length)
+        return false;
+    return a.every((segment, i) => segment.id === b[i].id && segment.label === b[i].label && segment.spentUsd === b[i].spentUsd);
+}
 export const aiAssistantSlice = createSlice({
     name: 'aiAssistant',
     initialState: defaultSessionState,
@@ -231,13 +243,15 @@ export const aiAssistantSlice = createSlice({
             const existing = state.vendorBudgets[vendor];
             if (existing &&
                 existing.budgetUsd === figures.budgetUsd &&
-                existing.spentUsd === figures.spentUsd) {
+                existing.spentUsd === figures.spentUsd &&
+                sameSegments(existing.segments, figures.segments)) {
                 return;
             }
             // A fresh object rather than the caller's: the store may freeze what it
             // holds, and adopting the host's object would freeze state the host still
-            // owns (and let later host mutations bypass the store).
-            state.vendorBudgets[vendor] = { budgetUsd: figures.budgetUsd, spentUsd: figures.spentUsd };
+            // owns (and let later host mutations bypass the store). Same for the
+            // segment array and each segment in it.
+            state.vendorBudgets[vendor] = Object.assign({ budgetUsd: figures.budgetUsd, spentUsd: figures.spentUsd }, (figures.segments ? { segments: figures.segments.map((s) => (Object.assign({}, s))) } : {}));
         },
         setInputValue(state, action) {
             state.inputValue = action.payload;

package/docs/styling.md

@@ -134,6 +134,22 @@ The per-vendor AI budget meter (GENC-1464) renders in the settings modal's
 | --- | --- |
 | `budget-usage` | The meter's container (all vendor rows) |
 | `budget-progress` | One vendor's budget bar (repeats per rendered row) |
+| `budget-segment` | Every slice of a stacked bar, when the host fed `segments` |
+| `budget-segment-<n>` | The slice for `segments[n]` (0-based, the host's own order) |
+| `budget-segment-remainder` | The unattributed remainder, when one is drawn |
+| `budget-swatch` / `budget-swatch-<n>` | The legend swatch(es), numbered to match their slice |
+| `budget-legend` | The legend under a stacked bar |
+| `budget-legend-item` | One legend entry (swatch, label, amount) |
+
+`budget-progress` is the design system's progress element for a vendor fed plain
+figures, and the stacked track for a vendor fed `segments` — so a rule that sets
+the bar's height applies to both. The other parts exist only on a segmented row.
+The unattributed remainder is a `budget-segment` with no legend entry, so it has
+no swatch.
+
+To style one slice, use its numbered part. Structural pseudo-classes such as
+`:nth-child()` never match after `::part()`, so
+`::part(budget-segment):nth-child(2)` silently does nothing.
 
 ```css
 /* Tighten the meter's row spacing */
@@ -145,6 +161,14 @@ foundation-ai-assistant::part(budget-usage) {
 foundation-ai-assistant::part(budget-progress) {
   height: 6px;
 }
+
+/* Colour the second source's slice and its legend swatch (they default to
+   tones of the accent, so drop the tone as well) */
+foundation-ai-assistant::part(budget-segment-1),
+foundation-ai-assistant::part(budget-swatch-1) {
+  background: var(--warning-color);
+  opacity: 1;
+}
 ```
 
 ### The conversation column (`messages-content`)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "15.33.1",
+  "version": "15.34.0",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
   "types": "dist/ai-assistant.d.ts",
@@ -50,8 +50,9 @@
     }
   },
   "scripts": {
-    "build": "genx build -b ts && node ./scripts/build-chat-driver-node.mjs",
+    "build": "genx build -b ts && node ./scripts/build-chat-driver-node.mjs && npm run smoke:chat-driver",
     "build:chat-driver": "node ./scripts/build-chat-driver-node.mjs",
+    "smoke:chat-driver": "node ./scripts/smoke-chat-driver-node.mjs",
     "build:webpack": "genx build",
     "build:webpack:stats": "genx analyze",
     "circular": "npx -y madge --extensions ts --circular ./src",
@@ -74,26 +75,26 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "15.33.1",
-    "@genesislcap/genx": "15.33.1",
-    "@genesislcap/rollup-builder": "15.33.1",
-    "@genesislcap/ts-builder": "15.33.1",
-    "@genesislcap/uvu-playwright-builder": "15.33.1",
-    "@genesislcap/vite-builder": "15.33.1",
-    "@genesislcap/webpack-builder": "15.33.1",
+    "@genesislcap/foundation-testing": "15.34.0",
+    "@genesislcap/genx": "15.34.0",
+    "@genesislcap/rollup-builder": "15.34.0",
+    "@genesislcap/ts-builder": "15.34.0",
+    "@genesislcap/uvu-playwright-builder": "15.34.0",
+    "@genesislcap/vite-builder": "15.34.0",
+    "@genesislcap/webpack-builder": "15.34.0",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2",
     "esbuild": "0.25.12"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "15.33.1",
-    "@genesislcap/foundation-logger": "15.33.1",
-    "@genesislcap/foundation-notifications": "15.33.1",
-    "@genesislcap/foundation-redux": "15.33.1",
-    "@genesislcap/foundation-ui": "15.33.1",
-    "@genesislcap/foundation-utils": "15.33.1",
-    "@genesislcap/rapid-design-system": "15.33.1",
-    "@genesislcap/web-core": "15.33.1",
+    "@genesislcap/foundation-ai": "15.34.0",
+    "@genesislcap/foundation-logger": "15.34.0",
+    "@genesislcap/foundation-notifications": "15.34.0",
+    "@genesislcap/foundation-redux": "15.34.0",
+    "@genesislcap/foundation-ui": "15.34.0",
+    "@genesislcap/foundation-utils": "15.34.0",
+    "@genesislcap/rapid-design-system": "15.34.0",
+    "@genesislcap/web-core": "15.34.0",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },

package/sandbox/sandbox.ts

@@ -146,6 +146,8 @@ interface SandboxState {
   reserveTokens: number;
   warnMultiplier: number;
   flowInProgress: boolean;
+  // Budget meter (GENC-1464, NEW-15)
+  budgetMeter: 'off' | 'single' | 'segmented' | 'segmented-remainder';
   // Simulated runtime
   runtime: 'idle' | 'loading' | 'cancelling' | 'blocked' | 'compacting' | 'restoring';
   transcript: TranscriptName;
@@ -192,6 +194,7 @@ const DEFAULT_STATE: SandboxState = {
   reserveTokens: 8_000,
   warnMultiplier: 2,
   flowInProgress: false,
+  budgetMeter: 'off',
   runtime: 'idle',
   transcript: 'rich',
   transcriptAge: 'fresh',
@@ -485,6 +488,35 @@ const applyContext = (s: SandboxState): void => {
   assistant.flowOwnerAgentName = s.flowInProgress ? 'Reconciliation' : null;
 };
 
+/**
+ * Feeds the cog's per-vendor budget meter, including the optional per-source breakdown
+ * (NEW-15) — the one part of the meter that cannot be judged from a unit test, since what is
+ * being checked is whether two tones and a legend read as one measure at meter size.
+ *
+ * Anthropic carries the breakdown and Gemini never does, so both drawings are on screen at
+ * once: the point of the feature is that a host feeding plain figures sees no change.
+ */
+const applyBudgetMeter = (s: SandboxState): void => {
+  if (s.budgetMeter === 'off') {
+    assistant.setVendorBudget('anthropic', null);
+    assistant.setVendorBudget('gemini', null);
+    return;
+  }
+  assistant.setVendorBudget('gemini', { budgetUsd: 200, spentUsd: 30.5 });
+  const segments =
+    s.budgetMeter === 'single'
+      ? undefined
+      : s.budgetMeter === 'segmented'
+        ? [
+            { id: 'app', label: 'App', spentUsd: 32 },
+            { id: 'batch', label: 'Batch jobs', spentUsd: 13 },
+          ]
+        : // Only part of the spend attributed: the rest draws unlabelled, which is the case
+          // worth looking at because nothing in the legend explains it.
+          [{ id: 'app', label: 'App', spentUsd: 27 }];
+  assistant.setVendorBudget('anthropic', { budgetUsd: 50, spentUsd: 45, segments });
+};
+
 const applyRuntime = (s: SandboxState): void => {
   assistant.compacting = s.runtime === 'compacting';
   assistant.restoring = s.runtime === 'restoring';
@@ -552,6 +584,7 @@ function apply(): void {
     : {};
   bindHistoryListener();
   applyContext(state);
+  applyBudgetMeter(state);
   applyRuntime(state);
   applyGradientSend(state.gradientSend);
   applyDivider(state.showDivider);
@@ -815,6 +848,25 @@ const GROUPS: ReadonlyArray<ControlGroup<SandboxState>> = [
       },
     ],
   },
+  {
+    title: 'Budget meter',
+    controls: [
+      {
+        kind: 'select',
+        key: 'budgetMeter',
+        label: 'Figures fed',
+        featured: true,
+        hint: 'Open the cog to see it. Gemini always gets plain figures, so the unsegmented bar is beside the segmented one.',
+        options: [
+          { value: 'off', label: 'None (no meter)' },
+          { value: 'single', label: 'Plain figures' },
+          { value: 'segmented', label: 'Breakdown (fully attributed)' },
+          { value: 'segmented-remainder', label: 'Breakdown + unattributed spend' },
+        ],
+      },
+      { kind: 'action', label: 'Open settings', run: () => assistant.openSettingsModal() },
+    ],
+  },
   {
     title: 'Simulated state',
     controls: [