@genesislcap/ai-assistant 15.10.6 → 15.11.0

package/src/components/settings-modal/settings-modal.template.ts

@@ -217,6 +217,8 @@ const platformContextUsageTemplate = (
  */
 const platformBudgetUsageTemplate = (
   progressTag: string,
+  buttonTag: string,
+  iconTag: string,
 ): ViewTemplate<FoundationAiAssistant> => html<FoundationAiAssistant>`
   ${when(
     (x) => x.settingsBudgetUsageVisible,
@@ -237,6 +239,26 @@ const platformBudgetUsageTemplate = (
             </div>
           `,
         )}
+        <!--
+          Freshness footer (GENC-1464): the rows above update per turn and at
+          the wall, which reads as "stale" to anyone watching the modal — the
+          label says when the figures arrived, the button asks the host for new
+          ones (see FoundationAiAssistant.requestBudgetRefresh). Below the rows
+          and left-aligned, reading as a footnote to the figures it describes.
+        -->
+        <div class="settings-budget-toolbar" part="budget-toolbar">
+          <${buttonTag}
+            appearance="stealth"
+            class="settings-budget-refresh"
+            part="budget-refresh"
+            title="Refresh budget figures"
+            aria-label="Refresh budget figures"
+            @click=${(x: FoundationAiAssistant) => x.requestBudgetRefresh()}
+          >
+            <${iconTag} name="arrows-rotate"></${iconTag}>
+          </${buttonTag}>
+          <span class="settings-budget-updated">${(x) => x.settingsBudgetUpdatedLabel}</span>
+        </div>
       </div>
     `,
   )}
@@ -265,12 +287,15 @@ const platformBudgetUsageTemplate = (
  */
 export const settingsUsageMetersTemplate = (
   progressTag: string,
+  buttonTag: string,
+  iconTag: string,
 ): ViewTemplate<FoundationAiAssistant> => html<FoundationAiAssistant>`
   ${when(
     (x) => x.settingsContextUsageVisible || x.settingsBudgetUsageVisible,
     html<FoundationAiAssistant>`
       <div class="settings-usage-meters">
-        ${platformContextUsageTemplate(progressTag)} ${platformBudgetUsageTemplate(progressTag)}
+        ${platformContextUsageTemplate(progressTag)}
+        ${platformBudgetUsageTemplate(progressTag, buttonTag, iconTag)}
       </div>
     `,
   )}
@@ -735,7 +760,7 @@ export const SettingsModalTemplate = (
         </h3>
         <div class="settings-modal-section-body">
           <slot name="settings-model" ${slotted('settingsModelSlotted')}></slot>
-          ${settingsUsageMetersTemplate(progressTag)}
+          ${settingsUsageMetersTemplate(progressTag, buttonTag, iconTag)}
         </div>
       </section>
       <!--

package/src/main/blocked-state.test.ts

@@ -325,6 +325,7 @@ Suite('a wall with figures snaps the vendor meter at latch time', () => {
   reachable(el, 'anthropic', 'gemini');
   latch(el, 'budget-exhausted', { vendorLabel: 'Anthropic', budgetUsd: 20, spentUsd: 20.1 });
   assert.equal(storedBudgets(el)['anthropic'], { budgetUsd: 20, spentUsd: 20.1 });
+  assert.ok(typeof el.budgetMeterLastFedAt === 'number', 'the wall feed stamps freshness too');
 
   // A later 402 for the same (already-walled) vendor carries fresher spend —
   // the feed is deliberately outside the idempotence guard, like the sweep.

package/src/main/budget-meter.test.ts

@@ -424,4 +424,54 @@ Suite('figures alone are enough to surface the AI Model Settings section', () =>
   assert.is(el.settingsModelSectionVisible, false, 'and the config flag takes it back out');
 });
 
+// ── Freshness stamp + refresh request (GENC-1464 refresh affordance) ─────────
+
+Suite('every feed stamps budgetMeterLastFedAt — identical figures included', () => {
+  const el = element();
+  assert.is(el.budgetMeterLastFedAt, null, 'null before any feed');
+  assert.is(el.settingsBudgetUpdatedLabel, undefined, 'no label before any feed');
+
+  el.setVendorBudget('anthropic', { budgetUsd: 50, spentUsd: 10 });
+  const first = el.budgetMeterLastFedAt;
+  assert.ok(typeof first === 'number', 'stamped on feed');
+  assert.ok(el.settingsBudgetUpdatedLabel!.startsWith('Updated '), 'label renders');
+
+  // The store is idempotent by value, but a refresh that CONFIRMS the same
+  // dollars is still a refresh — the stamp must move even when the rows don't.
+  el.budgetMeterLastFedAt = first! - 5000; // age it so a same-ms re-feed still differs
+  el.setVendorBudget('anthropic', { budgetUsd: 50, spentUsd: 10 });
+  assert.ok(el.budgetMeterLastFedAt! > first! - 5000, 'identical re-feed still stamps');
+
+  // Clearing figures is not a refresh — the label describes shown figures.
+  const before = el.budgetMeterLastFedAt;
+  el.setVendorBudget('anthropic', null);
+  assert.is(el.budgetMeterLastFedAt, before, 'a clear does not stamp');
+});
+
+Suite('requestBudgetRefresh emits budget-refresh-requested, and settings open asks too', () => {
+  const el = element();
+  let fired = 0;
+  el.addEventListener('budget-refresh-requested', () => {
+    fired += 1;
+  });
+
+  el.requestBudgetRefresh();
+  assert.is(fired, 1, 'the button path emits');
+
+  // The element cannot fetch — the event is the whole contract. Hosts without
+  // a listener simply keep the per-turn cadence, so firing is unconditional.
+  //
+  // The modal stub is load-bearing: openSettingsModal's `show` closure
+  // re-queues itself via DOM.queueUpdate until `settingsModal` exists, and on
+  // an unconnected element that is never — an infinite queue that keeps the
+  // test runner alive (this file's documented hang class). `open: true` makes
+  // the first queued run return immediately.
+  (el as unknown as { settingsModal: { open: boolean; show(): void } }).settingsModal = {
+    open: true,
+    show() {},
+  };
+  el.openSettingsModal();
+  assert.is(fired, 2, 'opening settings requests fresh figures');
+});
+
 Suite.run();

package/src/main/main.ts

@@ -1023,9 +1023,52 @@ export class FoundationAiAssistant extends GenesisElement {
       figures:
         figures == null ? null : { budgetUsd: figures.budgetUsd, spentUsd: figures.spentUsd },
     });
+    if (figures != null) this.budgetMeterLastFedAt = Date.now();
     return true;
   }
 
+  /**
+   * When budget figures last arrived — from the host's {@link FoundationAiAssistant.setVendorBudget}
+   * or the wall latch's own feed — as epoch ms; `null` until the first feed.
+   *
+   * ELEMENT state, not slice state, on purpose: the reducer is idempotent by
+   * value (an unchanged re-feed must not re-render the meter rows), but "when
+   * was this fetched" must move on every feed, changed figures or not — a
+   * refresh that confirms the same dollars is still a refresh. Only the
+   * toolbar label observes this, so a stamp re-renders one span, not the rows.
+   */
+  @observable budgetMeterLastFedAt: number | null = null;
+
+  /** "Updated HH:MM:SS" for the meter toolbar, or `undefined` before any feed. */
+  @volatile
+  get settingsBudgetUpdatedLabel(): string | undefined {
+    if (this.budgetMeterLastFedAt == null) return undefined;
+    return `Updated ${new Date(this.budgetMeterLastFedAt).toLocaleTimeString()}`;
+  }
+
+  /**
+   * Ask the host to re-fetch budget figures now (GENC-1464 refresh affordance).
+   *
+   * The element cannot fetch — the meter is host-fed by design — so this emits
+   * `budget-refresh-requested` and the host answers with the same fetch that
+   * already feeds {@link FoundationAiAssistant.setVendorBudget} (Create's handler coalesces in-flight
+   * fetches, so a spammed button costs one request). Fired by the meter's
+   * refresh button and on settings-modal open, so the figures are fresh exactly
+   * when someone is looking at them. Fires unconditionally: a host without a
+   * listener simply keeps the per-turn cadence.
+   */
+  requestBudgetRefresh(): void {
+    // Plain dispatchEvent, not FAST's $emit: $emit silently no-ops while the
+    // element is disconnected, and this must stay observable in headless/test
+    // harnesses that never connect (and in any odd pop-out lifecycle moment).
+    // bubbles + composed, matching this class's other events (SessionCleared
+    // et al): the element lives inside host shadow roots (Create nests it in
+    // gc-assistant's), and a delegation-based host must still see the request.
+    this.dispatchEvent(
+      new CustomEvent('budget-refresh-requested', { bubbles: true, composed: true }),
+    );
+  }
+
   /** Whether this vendor's wall came from the sweep alone — see the slice's `sweptVendors`. */
   private isVendorSwept(vendor: AIProviderType): boolean {
     return (this._sessionRef?.store.aiAssistant.sweptVendors ?? []).includes(vendor);
@@ -1248,6 +1291,7 @@ export class FoundationAiAssistant extends GenesisElement {
         vendor,
         figures: { budgetUsd: budget.budgetUsd, spentUsd: budget.spentUsd },
       });
+      this.budgetMeterLastFedAt = Date.now();
     }
     if (!vendor || vendor === 'none') {
       if (!this.blocked) {
@@ -3789,6 +3833,9 @@ export class FoundationAiAssistant extends GenesisElement {
 
   openSettingsModal(): void {
     this.logMeta('panel.toggled', { panel: 'settings', open: true });
+    // The meter refreshes per turn, which a user staring at the modal cannot
+    // see — ask the host for fresh figures at the moment they start looking.
+    this.requestBudgetRefresh();
     this.settingsModalTab = 'settings';
     this.settingsOpen = true;
     const show = (): void => {