@genesislcap/ai-assistant 15.19.6 → 15.20.0-alpha.3

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

@@ -592,6 +592,72 @@ const baseStyles = css `
     opacity: 45%;
   }
 
+  /* Context-gate states on the session-menu pill (GENC-1567).
+
+     ONE accent across both levels rather than amber escalating to red. The
+     escalation is carried by things that survive without colour vision and read
+     on a screen reader: the label changes wording ("Approaching" → "At"), the
+     composer gains an outline, and the composer disables with the remedy in its
+     placeholder. A colour change would have been the one signal adding nothing
+     the others do not already say, while making the composer shout in two hues
+     at once.
+
+     Colour is never the signal on its own here either — the pill swaps ⋮ for a
+     warning triangle and grows a label, and its title and aria-label carry the
+     full reason. */
+
+  /* The pill's own label is the loudest part, so it carries the weight the glyph
+     alone would not. max-width is widened from the agent pin's 45%: this label
+     is a fixed phrase rather than a user-supplied agent name, and ellipsing
+     "Approaching context limit" to "Approaching cont…" would lose the noun that
+     makes it mean anything. */
+  .session-menu-button.context-warn,
+  .session-menu-button.context-blocked {
+    max-width: 65%;
+  }
+
+  .session-menu-button.context-warn,
+  .session-menu-button.context-warn:hover {
+    color: var(--warning-color);
+  }
+
+  .session-menu-button.context-blocked,
+  .session-menu-button.context-blocked:hover {
+    color: var(--error-color);
+  }
+
+  /* The gate disables this button during a turn like any other composer control.
+     Left at the shared 45% it reads as "inactive" at exactly the moment the
+     conversation is running away, so it keeps more of its presence — still
+     clearly not clickable, but not faded out of notice. */
+  .session-menu-button.context-warn[disabled],
+  .session-menu-button.context-blocked[disabled] {
+    opacity: 70%;
+  }
+
+  /* The composer outline (GENC-1567). Drawn from the WARNING onwards, not just at
+     the block: the composer is the control the condition is about, and a user who
+     only ever sees it appear at the moment sending stops has had no warning where
+     they were looking. It escalates amber → red with the state rather than
+     appearing from nothing.
+
+     A border-COLOUR change only: the composer already declares a transparent
+     1px border on all four sides so its box metrics are identical in both the
+     flush and floating layouts, which means this cannot reflow anything or shift
+     the composer as the state flips. */
+  .composer.context-warn,
+  .composer.context-blocked {
+    border-radius: calc(var(--control-corner-radius) * 1px);
+  }
+
+  .composer.context-warn {
+    border-color: var(--warning-color);
+  }
+
+  .composer.context-blocked {
+    border-color: var(--error-color);
+  }
+
   .composer-pill::part(control) {
     min-width: 0;
     padding: 0;
@@ -834,6 +900,26 @@ const baseStyles = css `
     border-color: var(--neutral-stroke-rest);
   }
 
+  /* Announced, not drawn (GENC-1567). The context gate has three visible
+     expressions already; this keeps the role=status region mounted and
+     mutating so the condition is still spoken, which nothing else can do once
+     the composer disables and drops out of the tab order.
+
+     Clipped rather than display:none or visibility:hidden — both of those
+     remove the node from the accessibility tree, which would silence the very
+     announcement this exists for. */
+  .blocked-banner.is-sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    margin: -1px;
+    padding: 0;
+    border: 0;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+  }
+
   .blocked-banner-text {
     font-size: 0.9em;
     line-height: 1.4;
@@ -868,6 +954,48 @@ const baseStyles = css `
     box-shadow: none;
   }
 
+  /* At the context limit the placeholder stops being a hint and becomes the only
+     visible statement of what is wrong and how to clear it — so it has to be
+     readable. The design system dims a disabled control's placeholder towards
+     the point of being skipped over, which is right for "Message assistant..."
+     and wrong for a sentence the user has to act on. Restored to the normal
+     foreground, and left un-dimmed by the disabled treatment. */
+  .composer.context-blocked .chat-input::part(control)::placeholder {
+    color: var(--neutral-foreground-rest);
+    opacity: 100%;
+  }
+
+  /* And tall enough to actually show it. The placeholder here is two sentences,
+     and the input's resting height clipped them — losing the end, which is the
+     half that says what to do about it.
+
+     min-height rather than height, deliberately: it outranks the inline height
+     the drag-to-resize handle writes, so a user who had shrunk the composer
+     earlier still sees the whole message.
+
+     Sized from measurement across the width range rather than from one look at
+     one panel: the wrap count changes with the container, and a value picked at
+     a comfortable width silently clips at a narrow one. Measured need is 76px
+     from 400px up to ~560px, and 56px beyond that.
+
+     **400px is taken as the narrowest supported composer.** Below it the message
+     wraps further and this floor stops being enough — it degrades to a clipped
+     sentence rather than anything broken, but it is not a width the copy is sized
+     for.
+
+     Past 600px the message fits the composer's natural resting height, so the
+     floor is simply removed rather than set to a value it already exceeds. What
+     remains is a floor either way: the input still auto-grows past it on input. */
+  .composer.context-blocked .chat-input {
+    min-height: calc(var(--design-unit) * 20px);
+  }
+
+  @container (width > 600px) {
+    .composer.context-blocked .chat-input {
+      min-height: 0;
+    }
+  }
+
   /* Full-width grab bar above the input row; drag up/down to resize the composer.
      Sits above the row so it never overlaps the send/stop controls. */
   .composer-resize-handle {

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

@@ -268,8 +268,13 @@ const restoringTemplate = html `
  */
 export const blockedBannerClasses = (x) => [
     'blocked-banner',
+    // Only a budget wall is DRAWN here. The context gate states itself through
+    // the pill label, the composer outline and the placeholder, so a strip of
+    // prose on top would be a fourth statement of one condition — but it still
+    // has to be announced, hence `is-sr-only` rather than dropping the region.
     x.bannerVisible ? 'is-visible' : '',
     x.bannerVisible && !x.blocked ? 'is-partial' : '',
+    x.composerNoticeSrOnly ? 'is-sr-only' : '',
 ]
     .filter(Boolean)
     .join(' ');
@@ -305,7 +310,7 @@ export const BLOCKED_BANNER_ID = 'blocked-banner';
  *
  * @internal
  */
-export const composerDescribedBy = (x) => x.bannerVisible ? BLOCKED_BANNER_ID : null;
+export const composerDescribedBy = (x) => x.composerNoticeVisible ? BLOCKED_BANNER_ID : null;
 /**
  * Persistent banner shown above the composer while a backend condition blocks
  * the assistant — today an exhausted AI budget (GENC-1464).
@@ -345,8 +350,8 @@ const blockedBannerTemplate = html `
     part="blocked-banner"
     role="status"
   >
-    ${when((x) => x.bannerVisible, html `
-        <span class="blocked-banner-text">${(x) => x.effectiveBlockedReason}</span>
+    ${when((x) => x.composerNoticeVisible, html `
+        <span class="blocked-banner-text">${(x) => x.composerNoticeText}</span>
       `)}
   </div>
 `;
@@ -560,23 +565,38 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
       appearance="stealth"
       title=${(x) => { var _a; return `Attach file (${(_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.acceptedFiles})`; }}
       aria-label="Attach file"
-      ?disabled=${(x) => x.busy || x.compacting || x.restoring || x.blocked}
+      ?disabled=${(x) => x.busy || x.compacting || x.restoring || x.blocked || x.contextGate === 'blocked'}
       aria-describedby=${composerDescribedBy}
       @click=${(x) => x.triggerFileInput()}
     ><${iconTag} name="paperclip"></${iconTag}></${buttonTag}>
   `;
+    // The same control carries the context-gate signal (GENC-1567): ⋮ becomes a
+    // warning triangle as the window fills, amber at the warning and red once
+    // sends are blocked. Deliberately this button and not a new one — it is
+    // already the way to reach Compact, and it stays mounted (disabled, not
+    // removed) during a turn, so the colour change is visible through exactly the
+    // runaway tool loop that causes the problem.
+    //
+    // While a turn runs the button is disabled, so the notice copy above must not
+    // point at it as if it were clickable — see `contextGateReason`.
     const sessionMenuButtonTemplate = html `
     <${buttonTag}
-      class="composer-pill session-menu-button"
+      class="${(x) => classNames('composer-pill', 'session-menu-button', 
+    // Borrows the agent pin's labelled shape only while the gate is active,
+    // so the composer's resting state is unchanged — three equal circular
+    // pills — and the label's arrival is itself part of the signal.
+    ['composer-pill-labelled', x.contextGate !== 'ok'], ['context-warn', x.contextGate === 'warn'], ['context-blocked', x.contextGate === 'blocked'])}"
       part="session-menu-button"
       appearance="stealth"
-      title="Session options"
-      aria-label="Session options"
+      title="${(x) => (x.contextGate === 'ok' ? 'Session options' : x.contextGateReason)}"
+      aria-label="${(x) => x.contextGate === 'ok' ? 'Session options' : `Session options — ${x.contextGateReason}`}"
       aria-haspopup="menu"
       aria-expanded=${(x) => (x.sessionMenuOpen ? 'true' : 'false')}
       ?disabled=${(x) => x.busy || x.compacting || x.restoring}
       @click=${(x) => x.toggleSessionMenu()}
-    ><${iconTag} name="ellipsis"></${iconTag}></${buttonTag}>
+    >${when((x) => x.contextGate === 'ok', html `<${iconTag} name="ellipsis"></${iconTag}>`)}${when((x) => x.contextGate !== 'ok', html `<span class="pill-glyph"
+          ><${iconTag} name="triangle-exclamation"></${iconTag}></span
+        ><span class="pill-label">${(x) => x.contextGateLabel}</span>`)}</${buttonTag}>
   `;
     // The agent control is LAST in the cluster because it is the only one whose
     // width changes: pinning an agent swaps `AUTO` for a name, and with it in
@@ -616,7 +636,12 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
       <${buttonTag}
         class="send-button"
         part="send-button"
-        ?disabled=${(x) => x.busy || x.compacting || x.restoring || x.blocked || (!x.inputValue.trim() && !x.attachments.length)}
+        ?disabled=${(x) => x.busy ||
+        x.compacting ||
+        x.restoring ||
+        x.blocked ||
+        x.contextGate === 'blocked' ||
+        (!x.inputValue.trim() && !x.attachments.length)}
         aria-describedby=${composerDescribedBy}
         @click=${(x) => x.handleSendClick()}
       >Send</${buttonTag}>
@@ -655,29 +680,32 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
       role="menuitem"
       type="button"
       ?disabled=${(x) => !x.compactable}
-      title=${(x) => x.compactable
-        ? 'Summarize older messages to free up context'
-        : 'Not enough conversation yet to be worth compacting'}
+      title=${(x) => x.compactHint}
       @click=${(x) => (x.confirmingCompact = true)}
     >
       <span class="menu-item-icon" aria-hidden="true"><${iconTag} name="compress"></${iconTag}></span>
       <span class="menu-item-body">
         <span class="menu-item-name">Compact</span>
-        <span class="menu-item-hint">Summarize older messages to free up context</span>
-      </span>
-    </button>
-    <button
-      class="menu-item"
-      role="menuitem"
-      type="button"
-      @click=${(x) => (x.confirmingClear = true)}
-    >
-      <span class="menu-item-icon" aria-hidden="true"><${iconTag} name="trash"></${iconTag}></span>
-      <span class="menu-item-body">
-        <span class="menu-item-name">Clear</span>
-        <span class="menu-item-hint">Start a new conversation</span>
+        <span class="menu-item-hint">${(x) => x.compactHint}</span>
       </span>
     </button>
+    ${when(
+    // Clear is withheld from a menu the context gate forced open — but only
+    // while Compact is a real escape. See `clearWithheldByContext`.
+    (x) => !x.clearWithheldByContext, html `
+        <button
+          class="menu-item"
+          role="menuitem"
+          type="button"
+          @click=${(x) => (x.confirmingClear = true)}
+        >
+          <span class="menu-item-icon" aria-hidden="true"><${iconTag} name="trash"></${iconTag}></span>
+          <span class="menu-item-body">
+            <span class="menu-item-name">Clear</span>
+            <span class="menu-item-hint">Start a new conversation</span>
+          </span>
+        </button>
+      `)}
   `;
     // The hint is not decoration. Every other row in this menu has one, and the
     // panel is anchored by its BOTTOM edge to the button: a hintless Cancel makes
@@ -891,7 +919,10 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
                 @pointercancel=${(x, c) => x.onComposerResizeEnd(c.event)}
               ></div>
             `)}
-          <div class="composer" part="composer">
+          <div
+            class="${(x) => classNames('composer', ['context-warn', x.contextGate === 'warn'], ['context-blocked', x.contextGate === 'blocked'])}"
+            part="composer"
+          >
             <${textareaTag}
               ${ref('chatInputEl')}
               class="chat-input"
@@ -899,9 +930,13 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
               style=${(x) => x.composerHeightStyle}
               placeholder=${(x) => x.effectivePlaceholder}
               :value=${(x) => x.inputValue}
-              ?disabled=${(x) => x.busy || x.compacting || x.restoring || x.blocked}
-              aria-disabled=${(x) => (x.blocked ? 'true' : null)}
-              aria-label=${(x) => (x.blocked ? x.effectiveBlockedReason : null)}
+              ?disabled=${(x) => x.busy || x.compacting || x.restoring || x.blocked || x.contextGate === 'blocked'}
+              aria-disabled=${(x) => (x.blocked || x.contextGate === 'blocked' ? 'true' : null)}
+              aria-label=${(x) => x.blocked
+        ? x.effectiveBlockedReason
+        : x.contextGate === 'blocked'
+            ? x.contextGateReason
+            : null}
               aria-describedby=${composerDescribedBy}
               @input=${(x, c) => (x.inputValue = c.event.target.value)}
               @keydown=${(x, c) => {

package/dist/esm/state/debug-event-log.js

@@ -219,7 +219,7 @@ export const DEBUG_LOG_README = [
     "kind:'turn'.`agentSnapshot` — the active agent's own view of its internal state, captured at that turn. An agent opts into this by exposing a `getDebugSnapshot()` that returns JSON-serializable per-state info; stateful/flow agents wire it automatically, so you can watch a flow advance turn-by-turn (e.g. current step, cursor, collected fields, pending changes). Absent for agents that don't expose one.",
     "kind:'event' — a meta/lifecycle event. `type` names it (see below); `detail` carries structured data. `detail.placement` is the emitting UI instance: 'bubble' (collapsed), 'panel' (popped-out), or 'standalone'.",
     "Each 'event' also has an `importance`: 'high' (failures/limits — turn.error, tool.failed, subagent.failed, file.read-failed, suggestions.failed, context.threshold-crossed), 'normal' (session flow — connects, turns, retries, handoffs, agent/provider changes, interactions, sub-agent start/complete), or 'low' (skippable UI/bookkeeping noise — panel.toggled, attachment.added, driver.wired/unwired, context.updated, context.condensed). To skim, ignore importance:'low'; to triage a failure, filter to importance:'high' then read the nearby messages and turns. A 'high' turn.error is often preceded by one or more 'normal' turn.retry events for the same reason — read them together to see how many attempts were made before bailing. 'message' and 'turn' entries carry no importance — they are the substance, always read them.",
-    'Event types: assistant.connected/disconnected (mount + placement + whether the session was created or restored), assistant.popout/popin (window placement), driver.created/wired/unwired (which driver is live and why it stops/starts responding across a popout), state.changed (idle↔loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry — detail.reason plus attempt/maxAttempts; for malformed calls also finishMessage; for empty responses also the provider finishReason + thoughtsTokens + parts breakdown), turn.error (a turn failed or hit a guardrail — detail.reason is one of exception/malformed-function-call/empty-response/unknown-tool-limit/max-iterations/response-truncated/refusal/budget-exhausted/provider-refused, plus reason-specific diagnostics: attempts (for empty-response also finishReason + thoughtsTokens + a parts breakdown, distinguishing a thinking-only STOP from a truly empty turn), finishMessage, for response-truncated the model + maxTokens + outputTokens + tools, unknownTools (split into staleTools — real earlier this activation but retired by the current state or hidden behind an open exclusive fold — and hallucinatedTools — never advertised) + availableTools, iterations + limit, for budget-exhausted the budgetUsd + spentUsd figures reported by the proxy plus the resolved vendor, for provider-refused the kind (spend|auth) plus the upstream status and error type — the vendor refusing the ACCOUNT rather than us refusing to spend, so the remedy is a top-up or a key rotation rather than a raised cap, and the kind is the only place that distinction survives because the user-facing copy is deliberately cause-free, or name + message for exceptions), tool.failed (a tool threw), tool.unresolved (the model called a tool that could not be dispatched — detail.kind is folded/fold-hidden/stale/unknown, plus tool + agent and, for the counted kinds, the consecutive streak; the recurring lead-up to an unknown-tool-limit turn.error), subagent.started/completed/failed (the lifecycle of a `requestSubAgent` delegation — detail.agent names the sub-agent; these bracket the sub-agent turns that appear as kind:turn entries with an N-M `turnIndex`; subagent.failed also carries detail.reason, one of max_iterations/malformed_tool_call/empty_response/unknown_tool_limit/timeout/response_truncated/refusal/budget_exhausted/provider_refused; budget_exhausted and provider_refused are both terminal for the PARENT turn too — the parent stops rather than calling the model again into the same wall), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), provider.selected (the resolved provider for the upcoming turns — detail.provider is the registry SLOT/tier name, detail.model the concrete model behind it and detail.vendor its vendor; emitted only when the slot CHANGES, so read the per-turn `model` for the model of any given call rather than assuming the nearest event still applies), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
+    'Event types: assistant.connected/disconnected (mount + placement + whether the session was created or restored), assistant.popout/popin (window placement), driver.created/wired/unwired (which driver is live and why it stops/starts responding across a popout), state.changed (idle↔loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry — detail.reason plus attempt/maxAttempts; for malformed calls also finishMessage; for empty responses also the provider finishReason + thoughtsTokens + parts breakdown), turn.error (a turn failed or hit a guardrail — detail.reason is one of exception/malformed-function-call/empty-response/unknown-tool-limit/max-iterations/response-truncated/refusal/budget-exhausted/provider-refused/context-exhausted, plus reason-specific diagnostics: attempts (for empty-response also finishReason + thoughtsTokens + a parts breakdown, distinguishing a thinking-only STOP from a truly empty turn), finishMessage, for response-truncated the model + maxTokens + outputTokens + tools, unknownTools (split into staleTools — real earlier this activation but retired by the current state or hidden behind an open exclusive fold — and hallucinatedTools — never advertised) + availableTools, iterations + limit, for budget-exhausted the budgetUsd + spentUsd figures reported by the proxy plus the resolved vendor, for provider-refused the kind (spend|auth) plus the upstream status and error type — the vendor refusing the ACCOUNT rather than us refusing to spend, so the remedy is a top-up or a key rotation rather than a raised cap, and the kind is the only place that distinction survives because the user-facing copy is deliberately cause-free, for context-exhausted the estimated contextTokens against the guard that stopped the turn plus the iterations reached — the driver ending a runaway tool loop at the edge of the context window rather than issuing a request the provider would reject, so the transcript survives intact and can still be compacted, or name + message for exceptions), tool.failed (a tool threw), tool.unresolved (the model called a tool that could not be dispatched — detail.kind is folded/fold-hidden/stale/unknown, plus tool + agent and, for the counted kinds, the consecutive streak; the recurring lead-up to an unknown-tool-limit turn.error), subagent.started/completed/failed (the lifecycle of a `requestSubAgent` delegation — detail.agent names the sub-agent; these bracket the sub-agent turns that appear as kind:turn entries with an N-M `turnIndex`; subagent.failed also carries detail.reason, one of max_iterations/malformed_tool_call/empty_response/unknown_tool_limit/timeout/response_truncated/refusal/budget_exhausted/provider_refused/context_exhausted; budget_exhausted, provider_refused and context_exhausted are all terminal for the PARENT turn too — the parent stops rather than calling the model again into the same wall), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), provider.selected (the resolved provider for the upcoming turns — detail.provider is the registry SLOT/tier name, detail.model the concrete model behind it and detail.vendor its vendor; emitted only when the slot CHANGES, so read the per-turn `model` for the model of any given call rather than assuming the nearest event still applies), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
     'Sub-agent meta events: a sub-agent\'s own turn.retry/turn.error/tool.failed/tool.unresolved events are merged into this same timeline, tagged with `detail.subAgent` — a `"<parent> › <sub-agent>"` breadcrumb that composes when nested (e.g. `"UI Builder › Planner › Grounding"`) — and interleaved by their original timestamps within the subagent.started→completed/failed bracket. These are the per-attempt/per-failure signals that do NOT appear among the sub-agent\'s (hoisted) messages: a malformed/empty attempt that gets retried produces no message, and the stale-vs-hallucinated split and streak counts live only on the event. A sub-agent\'s high-volume, message-derivable events (turn.start/turn.end, provider.selected, context.updated) are intentionally NOT merged — read its hoisted messages for model/tokens/cost and turn-by-turn activity, and the bracketing subagent.* events for the run\'s span.',
     "`meta` holds context captured at export time: agentSummary (full agent configs), context (active model, contextTokens/contextLimit/contextUsagePercent for the last call, and the session totals — sessionCostUsd, sessionTokensConsumed, and the four-bucket sessionUsage lifted to the top of this log), activeDebugSnapshot (the active agent's `getDebugSnapshot()` taken fresh at export — reflects state NOW, which may have advanced beyond the last turn's agentSnapshot), debug (optional host-supplied debug state), host, and the export timestamp.",
     'Note the two different scopes in `meta.context`: `contextTokens` is the prompt size of the LAST call (against `contextLimit`, the model context window), while `sessionUsage`/`sessionTokensConsumed` are cumulative BILLED throughput. Every turn resends the conversation, so the cumulative figure counts each turn’s prompt again in the next turn’s and is expected to dwarf the context size — that is not double-counting.',

package/dist/esm/state/persistence/diagnostics-cursors.js

@@ -4,7 +4,7 @@ const freshCursors = () => ({
     emittedMsgKeys: new Set(),
     emittedTurnKeys: new Set(),
     lastEventIndex: -1,
-    lastMetaJson: '',
+    lastMetaDigest: '',
 });
 /** The shared cursors for `key`, created (empty) on first access. @internal */
 export function getDiagnosticsCursors(key) {

package/dist/esm/state/persistence/diagnostics.js

@@ -7,6 +7,55 @@
  *
  * @packageDocumentation
  */
+/** FNV-1a's 32-bit offset basis — the first lane's seed, and the second lane's multiplier. */
+const FNV_OFFSET_BASIS = 0x811c9dc5;
+/** FNV-1a's 32-bit prime — the first lane's multiplier, and the second lane's seed. */
+const FNV_PRIME = 0x01000193;
+/** Base-36 renders each lane as a short alphanumeric run, so the whole token stays ~20 chars. */
+const DIGEST_RADIX = 36;
+/**
+ * Digest a meta-snapshot's config projection down to a comparison token (GENC-1566).
+ *
+ * The projection itself is unchanged and still correct — it is the near-static config with the
+ * volatile fields excluded, which is what stops a throttled flush re-appending the block every
+ * time. What changed is that the projection is no longer STORED verbatim.
+ *
+ * **Why it matters.** `dedupSignature` is only ever compared for equality
+ * (`collectDiagnosticsDelta`: `sig === cursors.lastMetaDigest`), so a 155 KB string bought nothing a
+ * 20-byte one does not. Measured on one small Create session (GENC-1566): six `meta-snapshot`
+ * entries, each carrying a 155,491-byte `meta` **and** a 155,131-char stringified copy of most of
+ * it as its own key — 832,012 bytes of signature, **21% of a 3.92 MB diagnostics stream**, to
+ * decide six comparisons. Every byte is also re-uploaded per flush, and that session flushed 86
+ * times.
+ *
+ * **FNV-1a, twice, plus the length.** Sync (the caller builds the snapshot synchronously, so
+ * `crypto.subtle.digest`'s promise is not available to it), dependency-free, and deterministic
+ * across page loads. Two lanes with different offset bases plus the input length make an
+ * accidental collision between two real configs vanishingly unlikely — and the consequence of one
+ * would be a single *skipped* re-append of a block whose reader keeps only the newest copy anyway
+ * (`withFreshMetaSnapshot` discards every stored snapshot on the download path), so this is not a
+ * correctness-critical hash and must not be treated as one.
+ *
+ * Old streams need no migration: the delta's cursor is module state seeded empty on every page
+ * load, so a stored full-JSON signature is never compared against a digest. The first flush after
+ * an upgrade appends one snapshot, as every first flush does.
+ *
+ * @internal
+ */
+export function configDigest(json) {
+    // FNV-1a 32-bit, two lanes. `>>> 0` keeps each step an unsigned 32-bit value, and
+    // `Math.imul` is the only multiply that stays exact at 32 bits in JS. The second lane
+    // swaps the seed and the multiplier so the two do not move in lockstep — a pair of
+    // 32-bit lanes plus the length is what makes an accidental collision negligible.
+    let a = FNV_OFFSET_BASIS;
+    let b = FNV_PRIME;
+    for (let i = 0; i < json.length; i += 1) {
+        const c = json.charCodeAt(i);
+        a = Math.imul(a ^ c, FNV_PRIME) >>> 0;
+        b = Math.imul(b ^ c, FNV_OFFSET_BASIS) >>> 0;
+    }
+    return [json.length, a, b].map((n) => n.toString(DIGEST_RADIX)).join('-');
+}
 /**
  * Stable identity for a message diagnostic entry — `timestamp::role::subAgentOf::category`.
  * Used by the forward-capture delta (skip already-emitted messages) and by the

package/dist/esm/state/persistence/session-persister.js

@@ -241,6 +241,28 @@ export class SessionPersister {
             }
         });
     }
+    /**
+     * The transcript to STORE, for both save paths (the resumable autosave and the non-resumable
+     * freeze, which slices this same array).
+     *
+     * `getHistoryForPersistence` in preference to `getRawHistory` (GENC-1566): the same transcript
+     * with the tool payloads the model has already stopped seeing replaced by the stubs it was sent.
+     * Storing those in full writes bytes on every autosave for content the driver has retired —
+     * 7.4% of a measured 790 KB session — and the full payloads survive in the diagnostics stream
+     * either way. A driver that does not implement tool-context condensation falls back to raw
+     * history, and a session with no driver yet falls back to the store's copy.
+     *
+     * The projection preserves message COUNT and order, which it must: `_persistedMessages`, the
+     * not-saving modal's unsaved count and the freeze boundary are all derived from lengths.
+     *
+     * Then strip the display-only restore notices (restored / couldn't-restore) so they never
+     * persist or accumulate across reload→save→reload cycles.
+     */
+    messagesToPersist(driver, storeMessages) {
+        var _a, _b, _c, _d;
+        const raw = (_d = (_b = (_a = driver === null || driver === void 0 ? void 0 : driver.getHistoryForPersistence) === null || _a === void 0 ? void 0 : _a.call(driver)) !== null && _b !== void 0 ? _b : (_c = driver === null || driver === void 0 ? void 0 : driver.getRawHistory) === null || _c === void 0 ? void 0 : _c.call(driver)) !== null && _d !== void 0 ? _d : storeMessages;
+        return raw.filter((m) => !isSessionNoticeMarker(m));
+    }
     /**
      * Capture the current session to durable storage (GENC-1351 §5.1). Reads the
      * full transcript from the driver and the restorable scalars from the store, and
@@ -248,7 +270,7 @@ export class SessionPersister {
      */
     persistSession() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
             const { provider, enabled } = this.deps.getPersistence();
             if (!enabled || !provider)
                 return;
@@ -258,9 +280,7 @@ export class SessionPersister {
             if (!ref)
                 return;
             const s = ref.store.aiAssistant;
-            // Strip the display-only restore notices (restored / couldn't-restore) so they
-            // never persist or accumulate across reload→save→reload cycles.
-            const messages = ((_b = (_a = driver === null || driver === void 0 ? void 0 : driver.getRawHistory) === null || _a === void 0 ? void 0 : _a.call(driver)) !== null && _b !== void 0 ? _b : s.messages).filter((m) => !isSessionNoticeMarker(m));
+            const messages = this.messagesToPersist(driver, s.messages);
             if (!messages.length)
                 return; // nothing worth persisting (e.g. a just-cleared session)
             // Serialize the live active agent from the DRIVER (the instance whose
@@ -268,7 +288,7 @@ export class SessionPersister {
             // mints fresh configs (the showcase) would otherwise hand us a never-activated
             // closure whose `serialize()` returns undefined.
             const liveSnapshots = {};
-            const liveActive = (_c = driver === null || driver === void 0 ? void 0 : driver.getActiveAgent) === null || _c === void 0 ? void 0 : _c.call(driver);
+            const liveActive = (_a = driver === null || driver === void 0 ? void 0 : driver.getActiveAgent) === null || _a === void 0 ? void 0 : _a.call(driver);
             if (liveActive === null || liveActive === void 0 ? void 0 : liveActive.serialize) {
                 try {
                     const snap = liveActive.serialize();
@@ -324,7 +344,7 @@ export class SessionPersister {
                     sessionKey: key,
                     host: window.location.host,
                     messages: messages.slice(0, Math.min(boundary, messages.length)),
-                    activeAgentName: (_d = s.activeAgent) === null || _d === void 0 ? void 0 : _d.name,
+                    activeAgentName: (_b = s.activeAgent) === null || _b === void 0 ? void 0 : _b.name,
                     pinnedAgentName: s.pinnedAgentName,
                     flowOwnerAgentName: null,
                     sessionCostUsd: s.sessionUsage.costUsd,
@@ -345,7 +365,7 @@ export class SessionPersister {
                     return;
                 }
                 this.logMeta('persistence.suppressed', {
-                    agent: (_e = liveActive === null || liveActive === void 0 ? void 0 : liveActive.name) !== null && _e !== void 0 ? _e : null,
+                    agent: (_c = liveActive === null || liveActive === void 0 ? void 0 : liveActive.name) !== null && _c !== void 0 ? _c : null,
                     isFlowOwner: s.flowOwnerAgentName === (liveActive === null || liveActive === void 0 ? void 0 : liveActive.name),
                     frozeAtMessages: frozen.messages.length,
                     custom: !!(liveActive === null || liveActive === void 0 ? void 0 : liveActive.notResumableMessage),
@@ -362,7 +382,7 @@ export class SessionPersister {
                     // event was added to the resumable branch — so a session that broke while an agent was
                     // mid-flow still reported nothing at all, which is precisely the blind spot the
                     // user-facing warning exists to cover.
-                    this.recordSaveOutcome(false, (_f = e === null || e === void 0 ? void 0 : e.message) !== null && _f !== void 0 ? _f : String(e));
+                    this.recordSaveOutcome(false, (_d = e === null || e === void 0 ? void 0 : e.message) !== null && _d !== void 0 ? _d : String(e));
                     // Deliberately NOT reporting from here. This is the non-resumable branch and a reload is
                     // the modal's only action, so advising one now would destroy the in-flight work the
                     // snapshot could not carry. `recordSaveOutcome` has already set `_brokenSince`, so the
@@ -375,11 +395,11 @@ export class SessionPersister {
                     this.logMeta('persistence.save-failed', {
                         messages: frozen.messages.length,
                         agents: [],
-                        active: (_g = liveActive === null || liveActive === void 0 ? void 0 : liveActive.name) !== null && _g !== void 0 ? _g : null,
+                        active: (_e = liveActive === null || liveActive === void 0 ? void 0 : liveActive.name) !== null && _e !== void 0 ? _e : null,
                         hasSerialize: !!(liveActive === null || liveActive === void 0 ? void 0 : liveActive.serialize),
                         frozen: true,
-                        error: (_h = e === null || e === void 0 ? void 0 : e.name) !== null && _h !== void 0 ? _h : typeof e,
-                        message: (_j = e === null || e === void 0 ? void 0 : e.message) !== null && _j !== void 0 ? _j : String(e),
+                        error: (_f = e === null || e === void 0 ? void 0 : e.name) !== null && _f !== void 0 ? _f : typeof e,
+                        message: (_g = e === null || e === void 0 ? void 0 : e.message) !== null && _g !== void 0 ? _g : String(e),
                     });
                     logger.error('Session save (interrupted marker) failed:', e);
                 }
@@ -391,7 +411,7 @@ export class SessionPersister {
                 sessionKey: key,
                 host: window.location.host,
                 messages: [...messages],
-                activeAgentName: (_k = s.activeAgent) === null || _k === void 0 ? void 0 : _k.name,
+                activeAgentName: (_h = s.activeAgent) === null || _h === void 0 ? void 0 : _h.name,
                 pinnedAgentName: s.pinnedAgentName,
                 flowOwnerAgentName: s.flowOwnerAgentName,
                 sessionCostUsd: s.sessionUsage.costUsd,
@@ -415,7 +435,7 @@ export class SessionPersister {
             const captured = {
                 messages: messages.length,
                 agents: Object.keys(agentSnapshots),
-                active: (_l = liveActive === null || liveActive === void 0 ? void 0 : liveActive.name) !== null && _l !== void 0 ? _l : null,
+                active: (_j = liveActive === null || liveActive === void 0 ? void 0 : liveActive.name) !== null && _j !== void 0 ? _j : null,
                 hasSerialize: !!(liveActive === null || liveActive === void 0 ? void 0 : liveActive.serialize),
                 agentSnapshots,
             };
@@ -434,7 +454,7 @@ export class SessionPersister {
                 // means the body never reached the wire at all, because a provider builds its
                 // request body inside the `fetch` init, so a throw while serialising creates no
                 // request and leaves no server-side trace.
-                this.recordSaveOutcome(false, (_m = e === null || e === void 0 ? void 0 : e.message) !== null && _m !== void 0 ? _m : String(e));
+                this.recordSaveOutcome(false, (_k = e === null || e === void 0 ? void 0 : e.message) !== null && _k !== void 0 ? _k : String(e));
                 // Report straight away rather than waiting for the next attempt: we are on the resumable
                 // path, so a reload is safe NOW, and a one-cycle delay is a second of extra exposure for
                 // no benefit.
@@ -451,8 +471,8 @@ export class SessionPersister {
                     agents: captured.agents,
                     active: captured.active,
                     hasSerialize: captured.hasSerialize,
-                    error: (_o = e === null || e === void 0 ? void 0 : e.name) !== null && _o !== void 0 ? _o : typeof e,
-                    message: (_p = e === null || e === void 0 ? void 0 : e.message) !== null && _p !== void 0 ? _p : String(e),
+                    error: (_l = e === null || e === void 0 ? void 0 : e.name) !== null && _l !== void 0 ? _l : typeof e,
+                    message: (_m = e === null || e === void 0 ? void 0 : e.message) !== null && _m !== void 0 ? _m : String(e),
                 });
                 logger.error('Session save failed:', e);
             }
@@ -825,9 +845,9 @@ export class SessionPersister {
                 const sig = typeof entry.dedupSignature === 'string'
                     ? entry.dedupSignature
                     : JSON.stringify(entry.meta);
-                if (sig === cursors.lastMetaJson)
+                if (sig === cursors.lastMetaDigest)
                     continue;
-                cursors.lastMetaJson = sig;
+                cursors.lastMetaDigest = sig;
                 delta.push(entry);
             }
         }