@genesislcap/ai-assistant 15.26.0 → 15.27.0

package/dist/esm/main/main.js

@@ -58,7 +58,7 @@ import { deleteBankedBaseline } from '../utils/banked-usage-baselines';
 import { estimateContextTokens, isContextMeasurable, } from '../utils/context-tokens';
 import { logger } from '../utils/logger';
 import { filterVisibleMessages, trailingInteractionRow } from '../utils/message-partition';
-import { resolvePreferenceBaseline } from '../utils/resolve-preference-baseline';
+import { DEFAULT_TIMESTAMP_DISPLAY, preferenceUnchanged, resolvePreferenceBaseline, } from '../utils/resolve-preference-baseline';
 import { stripAgentHandlers } from '../utils/strip-agent-handlers';
 import { emptyUsage, sumUsage, totalTokens } from '../utils/sum-usage';
 import { AttachmentController } from './attachment-controller';
@@ -114,6 +114,14 @@ const DEFAULT_PERSISTENCE_SOURCE = 'host';
  * cannot drift apart.
  */
 const BLOCKED_PLACEHOLDER = 'AI usage limit reached';
+/**
+ * How often the transcript's relative timestamps are recomputed (GENC-1257).
+ *
+ * The relative tier changes at minute granularity, so a 30s tick caps how stale a label
+ * can look at half a minute — close enough that a user watching one never sees it lag,
+ * without a per-second timer. The work per tick is one string format per visible row.
+ */
+const TIMESTAMP_CLOCK_INTERVAL_MS = 30000;
 /**
  * Budget formatting helpers, re-exported so they stay on this module's public
  * surface (`src/index.ts` does `export * from './main/main'`). They live in
@@ -276,6 +284,16 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this.persistence = {};
         /** When set, enables Redux DevTools for this instance's session store. */
         this.debugRedux = false;
+        /**
+         * Epoch ms the transcript's relative timestamps are measured against.
+         *
+         * A relative label is only correct at the instant it renders: FAST evaluates the
+         * binding once, and an idle conversation never re-renders, so "2 minutes ago" would
+         * still read "2 minutes ago" an hour later. Making the formatter read this observable
+         * instead of `Date.now()` gives every row one shared, invalidatable clock — a tick
+         * re-evaluates them all.
+         */
+        this.timestampClock = Date.now();
         // ---- Transient UI state (stays as @observable on the component) ----
         this._suggestionsGeneration = 0;
         /** Whether the loading spinner is currently visible. Controlled by the loading delay timer. */
@@ -622,12 +640,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     set showToolCalls(value) {
         var _a;
-        // Idempotent: a same-value set is a no-op. The design-system switch fires
-        // `@change` when its `:checked` binding is applied on render (not just on user
-        // interaction), which would otherwise spuriously mark prefs "user-changed" and
-        // save config defaults — freezing the reconciler so real stored prefs never apply
-        // on reload (GENC-1351 #1).
-        if (this.showToolCalls === value)
+        if (preferenceUnchanged(this.showToolCalls, value))
             return;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setShowToolCalls(value);
         this.persistPreferences();
@@ -639,8 +652,8 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     set showThinkingSteps(value) {
         var _a;
-        if (this.showThinkingSteps === value)
-            return; // idempotent — see showToolCalls
+        if (preferenceUnchanged(this.showThinkingSteps, value))
+            return;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setShowThinkingSteps(value);
         this.persistPreferences();
     }
@@ -651,8 +664,8 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     set showNarration(value) {
         var _a;
-        if (this.showNarration === value)
-            return; // idempotent — see showToolCalls
+        if (preferenceUnchanged(this.showNarration, value))
+            return;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setShowNarration(value);
         this.persistPreferences();
     }
@@ -663,11 +676,55 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     set showAgentSwitchIndicator(value) {
         var _a;
-        if (this.showAgentSwitchIndicator === value)
-            return; // idempotent — see showToolCalls
+        if (preferenceUnchanged(this.showAgentSwitchIndicator, value))
+            return;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setShowAgentSwitchIndicator(value);
         this.persistPreferences();
     }
+    /**
+     * When each message shows its timestamp — `'off'`, `'hover'` (default) or `'always'`.
+     *
+     * Falls back to `DEFAULT_TIMESTAMP_DISPLAY` rather than `'off'` when there is no
+     * store yet: this preference defaults ON, so the pre-store render must match the state
+     * the baseline is about to resolve to, or timestamps would visibly pop in on connect.
+     */
+    get timestampDisplay() {
+        var _a, _b;
+        return (_b = (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.store.aiAssistant.timestampDisplay) !== null && _b !== void 0 ? _b : DEFAULT_TIMESTAMP_DISPLAY;
+    }
+    set timestampDisplay(value) {
+        var _a;
+        if (preferenceUnchanged(this.timestampDisplay, value))
+            return;
+        (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setTimestampDisplay(value);
+        this.persistPreferences();
+        // The mode decides whether the clock needs to run at all.
+        this.syncTimestampClock();
+    }
+    /**
+     * Start or stop the timestamp clock to match the current mode and connection state.
+     *
+     * Idempotent, and safe to call from either lifecycle end — it is driven from
+     * `connectedCallback`, `disconnectedCallback` and the `timestampDisplay` setter, which
+     * can fire in any order. Nothing runs while the mode is `'off'` (no binding reads the
+     * clock) or while disconnected (a timer outliving its element is a leak, and a
+     * popped-out view disconnects without the session ending).
+     */
+    syncTimestampClock() {
+        const wanted = this._sessionActive && this.timestampDisplay !== 'off';
+        if (wanted === !!this._timestampClockTimer)
+            return;
+        if (!wanted) {
+            clearInterval(this._timestampClockTimer);
+            this._timestampClockTimer = undefined;
+            return;
+        }
+        // Re-sync immediately: the element may have sat disconnected across several ticks.
+        this.timestampClock = Date.now();
+        this._timestampClockTimer = setInterval(() => {
+            this.timestampClock = Date.now();
+        }, TIMESTAMP_CLOCK_INTERVAL_MS);
+    }
     /** Currently enabled animations. */
     get enabledAnimations() {
         var _a, _b;
@@ -675,10 +732,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     set enabledAnimations(value) {
         var _a;
-        // Idempotent (order-insensitive) — see showToolCalls: the per-animation switches
-        // fire the same spurious render-time `@change`.
-        const current = this.enabledAnimations;
-        if (current.length === value.length && current.every((a) => value.includes(a)))
+        if (preferenceUnchanged(this.enabledAnimations, value))
             return;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setEnabledAnimations(value);
         this.persistPreferences();
@@ -2062,6 +2116,8 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         window.addEventListener('pagehide', this._handlePageHide);
         logger.debug('FoundationAiAssistant connected');
         this._sessionActive = true;
+        // After `_sessionActive`, which `syncTimestampClock` reads as "connected".
+        this.syncTimestampClock();
     }
     /**
      * Switch this element to a different session **in place**, without a page reload
@@ -2151,6 +2207,8 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this.costLedger.flush();
         super.disconnectedCallback();
         this._sessionActive = false;
+        // After `_sessionActive` is cleared, so the sync sees "disconnected" and stops.
+        this.syncTimestampClock();
         this.stopLoadingTimer();
         this.state = 'idle';
         // Note: `compacting`/`restoring` are NOT cleared here. They're written through the
@@ -2740,6 +2798,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             showThinkingSteps: this.showThinkingSteps,
             showNarration: this.showNarration,
             showAgentSwitchIndicator: this.showAgentSwitchIndicator,
+            timestampDisplay: this.timestampDisplay,
             animations: [...this.enabledAnimations],
         };
     }
@@ -2800,6 +2859,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             this.showThinkingSteps = resolved.showThinkingSteps;
             this.showNarration = resolved.showNarration;
             this.showAgentSwitchIndicator = resolved.showAgentSwitchIndicator;
+            this.timestampDisplay = resolved.timestampDisplay;
             this.enabledAnimations = resolved.enabledAnimations;
         }
         finally {
@@ -3896,6 +3956,9 @@ __decorate([
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "busy", null);
+__decorate([
+    observable
+], FoundationAiAssistant.prototype, "timestampClock", void 0);
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "effectiveChatInputDuringExecution", null);

package/dist/esm/main/main.styles.js

@@ -354,11 +354,86 @@ const baseStyles = css `
   }
 
   .sender {
+    /* Flex so the timestamp sits on the sender's baseline with a real gap, rather than
+       butting against the name or needing a margin that a missing timestamp would leave
+       behind. Wraps, so a narrow bubble drops the timestamp to its own line instead of
+       stretching the bubble to fit both. */
+    display: flex;
+    align-items: baseline;
+    flex-wrap: wrap;
+    gap: 2px 8px;
     font-weight: bold;
     font-size: 0.9em;
     margin-bottom: 4px;
   }
 
+  /* Recessive against the name it sits beside: lighter, smaller and dimmed. Deliberately
+     not a colour of its own — it inherits the bubble's foreground, so it stays legible on
+     the accent-filled user bubble and the neutral assistant one without a token per
+     variant. */
+  .message-timestamp {
+    font-weight: normal;
+    font-size: 0.85em;
+    opacity: 60%;
+    white-space: nowrap;
+
+    /* Chrome, not message content. Without this, opacity 0 still leaves the text
+       selectable, so dragging across the transcript and copying picks up a timestamp on
+       every message — including the ones the reader never hovered and never saw. */
+    user-select: none;
+  }
+
+  /* Removed from paint and from flow, but kept in the accessibility tree — the standard
+     clip-rect idiom rather than display:none or visibility:hidden, both of which would
+     take it out of the tree and defeat the point. Carries the absolute time behind the
+     relative text; see messageTimestampTemplate. */
+  .visually-hidden {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    margin: -1px;
+    padding: 0;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border: 0;
+  }
+
+  /* 'hover' — the default. Space is RESERVED at all times (opacity, not display) so
+     revealing the timestamp cannot reflow the bubble under the pointer; only the paint
+     changes. The sender line is rarely the widest line in a bubble, so this costs no
+     width except on very short messages. */
+  .messages-content.timestamps-hover .message-timestamp {
+    opacity: 0%;
+    transition: opacity 0.12s ease-out;
+  }
+
+  .messages-content.timestamps-hover .message-row:hover .message-timestamp {
+    opacity: 60%;
+  }
+
+  /* Keyboard and touch reach the same reveal: neither produces a hover. The
+     focus-within rule costs nothing today (message rows are not focusable) and starts
+     working the moment anything inside one is. */
+  .messages-content.timestamps-hover .message-row:focus-within .message-timestamp {
+    opacity: 60%;
+  }
+
+  /* A pointer that cannot hover (touch) would otherwise never see a timestamp, and
+     hover on touch is sticky and unpredictable where it fires at all. Show them. */
+  @media (hover: none) {
+    .messages-content.timestamps-hover .message-timestamp {
+      opacity: 60%;
+    }
+  }
+
+  /* Respect a reduced-motion preference: the fade is decorative, the reveal is not. */
+  @media (prefers-reduced-motion: reduce) {
+    .messages-content.timestamps-hover .message-timestamp {
+      transition: none;
+    }
+  }
+
   .payload {
     font-family: monospace;
     white-space: pre-wrap;

package/dist/esm/main/main.template.js

@@ -17,6 +17,7 @@
 import { isChatToolCallUnknown } from '@genesislcap/foundation-ai';
 import { classNames, html, ref, repeat, when } from '@genesislcap/web-core';
 import { SettingsModalTemplate } from '../components/settings-modal';
+import { formatAbsoluteTimestamp, formatMessageTimestamp, messageTimestampDateTime, } from '../utils/format-message-timestamp';
 import { compactionDividerLabel } from '../utils/history-transform';
 import { LOADING_STYLE_ANIMATIONS } from './main.types';
 function unknownToolPayload(tc) {
@@ -126,6 +127,35 @@ const messageParts = (m) => {
         ? `message message-interaction message-interaction-${interactionPresentation(m)}`
         : `message message-${type}`;
 };
+/**
+ * The timestamp shown beside the sender name (GENC-1257).
+ *
+ * Two strings, not one. A screen reader announces a `<time>` element's TEXT — it has no
+ * implicit ARIA role, and the `datetime` attribute is never surfaced to the user — so the
+ * relative text is hidden from assistive tech and paired with a visually-hidden absolute
+ * string. Otherwise AT would hear "5 minutes ago" with nothing to anchor it, and in
+ * `'hover'` mode would hear it for a timestamp sighted users never asked to see.
+ * `datetime` stays because it is correct HTML and useful to tooling, not for a11y.
+ *
+ * Only the VISUAL reveal is hover-gated, in CSS — see `.message-timestamp`. `opacity: 0`
+ * leaves the element in the accessibility tree, so AT gets a time in both visible modes;
+ * `'off'` is the only mode that removes it.
+ *
+ * Reads `timestampClock` rather than `Date.now()` so every row shares one invalidatable
+ * clock and a tick re-evaluates them all; see `FoundationAiAssistant.timestampClock`.
+ */
+export const messageTimestampTemplate = html `
+  <time
+    class="message-timestamp"
+    part="message-timestamp"
+    datetime="${(m) => messageTimestampDateTime(m.timestamp)}"
+  >
+    <span aria-hidden="true">
+      ${(m, c) => formatMessageTimestamp(m.timestamp, c.parent.timestampClock)}
+    </span>
+    <span class="visually-hidden">${(m) => formatAbsoluteTimestamp(m.timestamp)}</span>
+  </time>
+`;
 // ─── Sub-agent trace fragments ────────────────────────────────────────────────
 const subAgentAssistantTemplate = html `
   <div class="sub-agent-message sub-agent-assistant">${(m) => m.content}</div>
@@ -499,7 +529,8 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
     // host sender label. Every other message keeps it.
     (m) => !(m.interaction && interactionPresentation(m) === 'bare'), html `
                 <div class="sender">
-                  ${(m, c) => {
+                  <span class="sender-label">
+                    ${(m, c) => {
         var _a;
         return messageType(m) === 'ai-function' &&
             m.agentName &&
@@ -507,6 +538,13 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
             ? `Tool Call · ${(_a = m.agentLabel) !== null && _a !== void 0 ? _a : m.agentName}`
             : senderLabelFor(m);
     }}
+                  </span>
+                  ${when(
+    // Guarded on the stamp too: a session persisted before timestamp
+    // support restores without one, and an empty <time> would still
+    // draw the gap the flex row reserves for it.
+    (m, c) => !!m.timestamp &&
+        c.parent.timestampDisplay !== 'off', messageTimestampTemplate)}
                 </div>
               `)}
             <div class="content">
@@ -826,7 +864,10 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
       </div>
 
       <div class="messages" part="messages" ${ref('messagesEl')}>
-        <div class="messages-content" part="messages-content">
+        <div
+          class="messages-content ${(x) => `timestamps-${x.timestampDisplay}`}"
+          part="messages-content"
+        >
           ${when((x) => x.compacting, compactingTemplate)}
           ${when((x) => x.restoring, restoringTemplate)}
           ${repeat((x) => (x.compacting || x.restoring ? [] : x.visibleMessages), messageRowTemplate)}

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

@@ -13,6 +13,7 @@ export function createDefaultSessionState() {
         showThinkingSteps: false,
         showNarration: false,
         showAgentSwitchIndicator: false,
+        timestampDisplay: 'hover',
         enabledAnimations: [],
         suggestionsState: { status: 'idle' },
         contextTokens: undefined,
@@ -64,6 +65,9 @@ export const aiAssistantSlice = createSlice({
         setShowAgentSwitchIndicator(state, action) {
             state.showAgentSwitchIndicator = action.payload;
         },
+        setTimestampDisplay(state, action) {
+            state.timestampDisplay = action.payload;
+        },
         setEnabledAnimations(state, action) {
             state.enabledAnimations = action.payload;
         },
@@ -322,6 +326,7 @@ export const aiAssistantSlice = createSlice({
                 showThinkingSteps: state.showThinkingSteps,
                 showNarration: state.showNarration,
                 showAgentSwitchIndicator: state.showAgentSwitchIndicator,
+                timestampDisplay: state.timestampDisplay,
                 enabledAnimations: state.enabledAnimations,
                 providerStatuses: state.providerStatuses,
                 blocked: state.blocked,

package/dist/esm/utils/format-message-timestamp.js

@@ -0,0 +1,126 @@
+/**
+ * The ONE place this package turns a message's `timestamp` into display text
+ * (GENC-1257).
+ *
+ * Three tiers, deliberately coarse — the transcript shows this beside the sender
+ * name, where a long string competes with the name itself:
+ *
+ * | Age            | Reads                                                               |
+ * | -------------- | ------------------------------------------------------------------- |
+ * | under a minute | `Now`                                                                 |
+ * | under an hour  | `12 minutes ago`                                                      |
+ * | anything older | an absolute date+time in the user's locale, e.g. `Sep 10, 2026, 14:18` |
+ *
+ * The absolute tier is deliberately locale-driven, so its exact rendering is the
+ * runtime's to choose — `en-US` gives `Sep 10, 2026, 14:18` and `en-GB` gives
+ * `10 Sept 2026, 14:18`. Only the FIELDS are ours; see {@link ABSOLUTE_FORMAT_OPTIONS}.
+ *
+ * Split out as a pure function (as `format-usd.ts` was) so the tier boundaries are
+ * testable without a clock, an element or a render: every entry point takes `now`
+ * rather than reading `Date.now()` itself.
+ *
+ * @internal
+ */
+/** Milliseconds in a minute. */
+const MS_PER_MINUTE = 60000;
+/** Minutes in an hour. Named for the lint rule that forbids a bare literal in an expression. */
+const MINUTES_PER_HOUR = 60;
+/** Milliseconds in an hour — the boundary between the relative and absolute tiers. */
+const MS_PER_HOUR = MINUTES_PER_HOUR * MS_PER_MINUTE;
+/**
+ * Field selection for the absolute tier.
+ *
+ * Exported so tests can build their expectation from the same options rather than from a
+ * literal: every field below renders differently per locale and time zone, so asserting
+ * `"Sep"` or `"10"` only asserts the machine the test happened to run on.
+ *
+ * Locale is left undefined so it follows the user's, and `hourCycle: 'h23'` pins the clock
+ * to 24-hour regardless — a locale-chosen 12-hour clock would add "am"/"pm" and widen the
+ * string next to the sender name.
+ */
+export const ABSOLUTE_FORMAT_OPTIONS = {
+    day: 'numeric',
+    month: 'short',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    hourCycle: 'h23',
+};
+/**
+ * Built once at module load rather than per message: a transcript re-renders on every
+ * store change, and `Intl.DateTimeFormat` construction is the expensive half of the API
+ * (formatting against an existing instance is cheap).
+ */
+const absoluteFormatter = new Intl.DateTimeFormat(undefined, ABSOLUTE_FORMAT_OPTIONS);
+/**
+ * Display text for a message timestamp, per the tiers above.
+ *
+ * A timestamp slightly in the future (clock skew between a server-stamped message and the
+ * browser) reads `Now` rather than a negative count — "-3 minutes ago" looks broken and
+ * tells the user nothing. That indulgence is bounded at an hour: beyond it the stamp is
+ * not skew but bad data (a machine with a badly wrong clock, a hand-edited session), and
+ * showing `Now` forever on every message would hide that. Past the bound it falls through
+ * to the absolute tier, which shows the user what the data actually says.
+ *
+ * @param iso - ISO-8601 timestamp, as stamped by the driver on append.
+ * @param now - Current epoch ms. Passed in rather than read, so tests pin the clock.
+ * @returns Display text, or `''` when there is nothing sensible to show.
+ */
+export function formatMessageTimestamp(iso, now) {
+    const ms = toEpochMs(iso);
+    if (ms === undefined)
+        return '';
+    const age = now - ms;
+    if (age < MS_PER_MINUTE && age > -MS_PER_HOUR)
+        return 'Now';
+    if (age >= MS_PER_MINUTE && age < MS_PER_HOUR) {
+        const minutes = Math.floor(age / MS_PER_MINUTE);
+        return `${minutes} ${minutes === 1 ? 'minute' : 'minutes'} ago`;
+    }
+    return absoluteFormatter.format(ms);
+}
+/**
+ * The absolute rendering of a stamp, whatever its age — the accessible text behind a
+ * message timestamp.
+ *
+ * Exists because the visible text is relative and a screen reader announces the element's
+ * TEXT, not its `datetime` attribute: `<time>` carries no implicit ARIA role, so the
+ * machine-readable value reaches tooling and nobody else. The template pairs this with
+ * `aria-hidden` on the relative string so assistive tech hears one unambiguous time
+ * instead of "5 minutes ago" with no anchor.
+ *
+ * @param iso - ISO-8601 timestamp, as stamped by the driver on append.
+ * @returns The absolute string, or `''` when there is nothing sensible to show.
+ */
+export function formatAbsoluteTimestamp(iso) {
+    const ms = toEpochMs(iso);
+    return ms === undefined ? '' : absoluteFormatter.format(ms);
+}
+/**
+ * The `datetime` attribute value for the rendered `<time>` element — the raw ISO string,
+ * which is what the HTML spec wants and what date-aware tooling reads. It is NOT an
+ * accessibility affordance: screen readers announce the element's text content instead.
+ *
+ * Returns `null`, not `''`, for a missing or unparseable stamp: FAST removes an attribute
+ * only for `null`/`undefined` (see `DOM.setAttribute`), so an empty string would emit
+ * `datetime=""`, which is invalid per spec and flagged by HTML validators.
+ *
+ * @param iso - ISO-8601 timestamp, as stamped by the driver on append.
+ */
+export function messageTimestampDateTime(iso) {
+    return toEpochMs(iso) === undefined ? null : iso;
+}
+/**
+ * Parse a stamp to epoch ms, rejecting both absence and garbage.
+ *
+ * `timestamp` is optional on {@link ChatMessage} for one real reason — sessions persisted
+ * before timestamp support restore without it — and a persisted blob is host-supplied data
+ * that can also be malformed. `new Date(junk).getTime()` is `NaN`, which would otherwise
+ * flow into the arithmetic and render "NaN minutes ago".
+ */
+function toEpochMs(iso) {
+    if (!iso)
+        return undefined;
+    const ms = new Date(iso).getTime();
+    return Number.isNaN(ms) ? undefined : ms;
+}

package/dist/esm/utils/resolve-preference-baseline.js

@@ -1,5 +1,48 @@
 import { DEFAULT_ANIMATIONS } from '../main/main.types';
 import { resolveExclusiveLoadingStyle } from './animation-exclusivity';
+/**
+ * Whether a preference write is a no-op, so a setter can bail before touching the store.
+ *
+ * Load-bearing rather than an optimisation. The design-system `switch` fires `@change` when its
+ * `:checked` binding is applied on render, not only on user interaction — so an unguarded setter
+ * marks preferences "user-changed" on every render and saves config defaults, which freezes the
+ * reconciler so real stored prefs never apply on reload (GENC-1351 #1).
+ *
+ * List preferences compare order-insensitively: the per-animation switches fire the same spurious
+ * render-time `@change`, and `enabledAnimations` is a set rather than a sequence.
+ *
+ * @internal
+ */
+export function preferenceUnchanged(current, value) {
+    if (Array.isArray(current) && Array.isArray(value)) {
+        return current.length === value.length && current.every((item) => value.includes(item));
+    }
+    return current === value;
+}
+/** The mode used when neither the host config nor stored prefs name a valid one. */
+export const DEFAULT_TIMESTAMP_DISPLAY = 'hover';
+/**
+ * Every valid {@link TimestampDisplay}, for narrowing untrusted input.
+ *
+ * Keyed by the union rather than typed `readonly string[]`, so adding a mode is a compile
+ * error here. A plain string array severs the link: the new mode would type-check
+ * everywhere, then be rejected at runtime as junk and silently fall back to `'hover'` —
+ * surfacing as "my new mode doesn't stick" rather than as a type error.
+ */
+const TIMESTAMP_DISPLAY_MODES = {
+    off: true,
+    hover: true,
+    always: true,
+};
+/**
+ * Narrow an untrusted value to a {@link TimestampDisplay}, or `undefined` if it is not one.
+ *
+ * Both inputs need this: the config field is typed but comes from plain JS hosts, and the
+ * stored field is a bare `string` read back out of a persistence blob.
+ */
+const asTimestampDisplay = (value) => typeof value === 'string' && value in TIMESTAMP_DISPLAY_MODES
+    ? value
+    : undefined;
 /**
  * Resolve the effective preference baseline for a fresh store, applying the
  * precedence (lowest → highest):
@@ -20,7 +63,7 @@ import { resolveExclusiveLoadingStyle } from './animation-exclusivity';
  * @internal
  */
 export function resolvePreferenceBaseline(ui, stored) {
-    var _a, _b;
+    var _a, _b, _c;
     const u = ui !== null && ui !== void 0 ? ui : {};
     // Layer 1 — chatConfig.ui defaults.
     const baseline = {
@@ -28,7 +71,10 @@ export function resolvePreferenceBaseline(ui, stored) {
         showThinkingSteps: u.showThinkingSteps === true,
         showNarration: u.showNarration === true,
         showAgentSwitchIndicator: u.showAgentSwitchIndicator === true,
-        enabledAnimations: resolveExclusiveLoadingStyle((_b = (_a = u.animations) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : (u.animations ? [...DEFAULT_ANIMATIONS] : [])),
+        // Defaults ON, unlike the booleans above — so this reads the config value when it is
+        // a valid mode and falls back to `'hover'`, rather than testing `=== true`.
+        timestampDisplay: (_a = asTimestampDisplay(u.showTimestamps)) !== null && _a !== void 0 ? _a : DEFAULT_TIMESTAMP_DISPLAY,
+        enabledAnimations: resolveExclusiveLoadingStyle((_c = (_b = u.animations) === null || _b === void 0 ? void 0 : _b.enabled) !== null && _c !== void 0 ? _c : (u.animations ? [...DEFAULT_ANIMATIONS] : [])),
     };
     // Layer 2 — stored user preferences override the fields they carry.
     if (stored) {
@@ -43,6 +89,12 @@ export function resolvePreferenceBaseline(ui, stored) {
         if (stored.showAgentSwitchIndicator !== undefined) {
             baseline.showAgentSwitchIndicator = stored.showAgentSwitchIndicator;
         }
+        // Validated, not just presence-checked: `SessionPreferences.timestampDisplay` is a
+        // plain `string` off a host-supplied blob, so a stale or hand-edited value must fall
+        // through to the config layer instead of poking a junk mode into the store.
+        const storedMode = asTimestampDisplay(stored.timestampDisplay);
+        if (storedMode)
+            baseline.timestampDisplay = storedMode;
         if (Array.isArray(stored.animations)) {
             // De-dupe defensively — historical blobs may hold duplicates from the old
             // settings-modal append bug (now fixed at the `setEnabledAnimations` source).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "15.26.0",
+  "version": "15.27.0",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
   "types": "dist/ai-assistant.d.ts",
@@ -74,26 +74,26 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "15.26.0",
-    "@genesislcap/genx": "15.26.0",
-    "@genesislcap/rollup-builder": "15.26.0",
-    "@genesislcap/ts-builder": "15.26.0",
-    "@genesislcap/uvu-playwright-builder": "15.26.0",
-    "@genesislcap/vite-builder": "15.26.0",
-    "@genesislcap/webpack-builder": "15.26.0",
+    "@genesislcap/foundation-testing": "15.27.0",
+    "@genesislcap/genx": "15.27.0",
+    "@genesislcap/rollup-builder": "15.27.0",
+    "@genesislcap/ts-builder": "15.27.0",
+    "@genesislcap/uvu-playwright-builder": "15.27.0",
+    "@genesislcap/vite-builder": "15.27.0",
+    "@genesislcap/webpack-builder": "15.27.0",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2",
     "esbuild": "0.25.12"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "15.26.0",
-    "@genesislcap/foundation-logger": "15.26.0",
-    "@genesislcap/foundation-notifications": "15.26.0",
-    "@genesislcap/foundation-redux": "15.26.0",
-    "@genesislcap/foundation-ui": "15.26.0",
-    "@genesislcap/foundation-utils": "15.26.0",
-    "@genesislcap/rapid-design-system": "15.26.0",
-    "@genesislcap/web-core": "15.26.0",
+    "@genesislcap/foundation-ai": "15.27.0",
+    "@genesislcap/foundation-logger": "15.27.0",
+    "@genesislcap/foundation-notifications": "15.27.0",
+    "@genesislcap/foundation-redux": "15.27.0",
+    "@genesislcap/foundation-ui": "15.27.0",
+    "@genesislcap/foundation-utils": "15.27.0",
+    "@genesislcap/rapid-design-system": "15.27.0",
+    "@genesislcap/web-core": "15.27.0",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },