synabun 2.1.0 → 2.2.0

package/neural-interface/public/shared/assistant/asst-limit-wait.js

@@ -6,10 +6,15 @@
 // mascot dozes inside a gold ring that fills toward the reset, a live
 // hh:mm:ss countdown and the local reset time beside it. At zero it wakes
 // ("Usage limit restored") and offers Retry now. With no reset time known it
-// waits with "Reset time unknown" and offers the retry at once. The clock is
-// the shared ticker at 1 fps, only while it counts and only while the card is
-// on the page; under prefers-reduced-motion the mascot is a still and nothing
-// eases. Its sheet is its own (injectLimitWaitStyles), like the rack's.
+// waits with "Reset time unknown" and offers the retry at once. While it
+// blocks, a host that passes onSwitchProvider also offers "Continue with
+// another provider" (the host owns the picker and what a pick does); a host
+// that passes onClose always offers Close, which only dismisses the card —
+// the limit itself is untouched — and Esc does the same while focus is
+// inside. The clock is the shared ticker at 1 fps, only while it counts and
+// only while the card is on the page; under prefers-reduced-motion the mascot
+// is a still and nothing eases. Its sheet is its own (injectLimitWaitStyles),
+// like the rack's.
 
 import * as mascotLib from '../synabun-mascot.js';
 import { isReducedMotion, subscribe } from '../synabun-ticker.js';
@@ -37,10 +42,12 @@ function localTime(ms, now) {
 }
 
 /**
- * createLimitWait({ t, resetsAt, since, provider, onRetry, retryLabel, announce(text) })
+ * createLimitWait({ t, resetsAt, since, provider, onRetry, retryLabel, onSwitchProvider, onClose, announce(text) })
  * → { el, get state(), update({ resetsAt, since }), retried(), stale(), destroy() }
  * `resetsAt`: epoch ms / s or ISO, or null (unknown). `since`: when the wait began (the ring's start).
  * `provider`: the name in the meta line ("Codex"). `onRetry()`: Retry now; null: no button.
+ * `onSwitchProvider(anchorEl)`: Continue with another provider, while blocking; null: no button.
+ * `onClose()`: Close (and Esc, while focus is inside); null: no button.
  */
 export function createLimitWait(opts = {}) {
   injectLimitWaitStyles();
@@ -84,6 +91,16 @@ export function createLimitWait(opts = {}) {
   const actions = $('.asst-limit-wait-actions');
   const live = $('.asst-limit-wait-live');
 
+  // Continue with another provider: only while actively blocking (waiting / unknown). Opens the
+  // host's own provider picker (never a native select); the host decides what happens on a pick.
+  let switchBtn = null;
+  if (typeof opts.onSwitchProvider === 'function') {
+    switchBtn = el('button', 'asst-btn asst-btn-secondary asst-limit-wait-switch', t('assistant.limitWait.switchProvider', 'Continue with another provider'));
+    switchBtn.type = 'button';
+    switchBtn.addEventListener('click', () => { if (!destroyed) opts.onSwitchProvider(switchBtn); });
+    actions.appendChild(switchBtn);
+  }
+
   let retryBtn = null;
   if (typeof opts.onRetry === 'function') {
     retryBtn = el('button', 'asst-btn asst-btn-primary asst-limit-wait-retry');
@@ -96,6 +113,21 @@ export function createLimitWait(opts = {}) {
     actions.appendChild(retryBtn);
   }
 
+  // Dismisses the card only; the limit itself is untouched (the host decides how it resurfaces).
+  let closeBtn = null;
+  if (typeof opts.onClose === 'function') {
+    closeBtn = el('button', 'asst-btn asst-btn-secondary asst-limit-wait-close', t('common.close', 'Close'));
+    closeBtn.type = 'button';
+    closeBtn.addEventListener('click', () => { if (!destroyed) opts.onClose(); });
+    actions.appendChild(closeBtn);
+    // Not a dialog (role="group"): Esc closes it only while focus is inside.
+    card.addEventListener('keydown', (e) => {
+      if (e.key !== 'Escape' || destroyed) return;
+      e.stopPropagation();
+      opts.onClose();
+    });
+  }
+
   function setPose(next) {
     if (pose === next || destroyed) return;
     pose = next;
@@ -146,6 +178,7 @@ export function createLimitWait(opts = {}) {
           : (opts.retryLabel || t('assistant.limitWait.retry', 'Retry now'));
       retryBtn.textContent = label;
     }
+    if (switchBtn) switchBtn.hidden = !(next === 'waiting' || next === 'unknown');
     if (next === 'waiting') { setPose('sleep'); setRing(limitCountdown({ resetsAt, since }, now).progress || 0); }
     else if (next === 'unknown') { setPose('wait'); setRing(0.18, true); }
     else if (next === 'restored') { setPose(was === 'waiting' ? 'success' : 'idle'); setRing(1); }

package/neural-interface/public/shared/assistant/asst-panel.js

@@ -35,7 +35,6 @@ import { t } from '../i18n.js';
 import '../account-i18n.js';
 import { forgetGreeting, mountGreeting } from '../greeting/greeting-card.js';
 import { notify, NOTIF_TYPE } from '../ui-notifications.js';
-import { getProviderMeta } from '../provider-icons.js';
 import { isGuest, hasPermission } from '../ui-sync.js';
 import { getWhiteboardElementById } from '../ui-whiteboard.js';
 import { focusNativeLoopRun } from '../ui-native-loop-router.js';
@@ -51,7 +50,7 @@ import { buildPromptText, createComposer } from './asst-composer.js';
 import { buildDispatchSpec, parseSlashCommand, slashHelpMarkdown } from './asst-slash.js';
 import { resolveStopTarget } from './asst-stop.js';
 import { plural } from './asst-tool-kinds.js';
-import { cachedProjects, createBrainPicker, testDensityLabel } from './asst-brain-picker.js';
+import { cachedProjects, createBrainPicker, openModelMenu, testDensityLabel } from './asst-brain-picker.js';
 import { createRovingToolbar } from './asst-roving.js';
 import { openAccountsManager } from './asst-accounts.js';
 import { createAgentsDock } from './asst-agents-dock.js';
@@ -62,8 +61,8 @@ import { createRouteModeControl, openModelsManager, openRoutesEditor, refreshMod
 import { budgetChipText, budgetSpendText, budgetTone, closeBudgetEditor, createBudgetController, mountBudgetChip, openBudgetEditor } from './asst-budget.js';
 import { computerRemoteView, createComputerPanel, createComputerToggle, normalizeComputerRemote, openFrameLightbox, closeFrameLightbox, requestDesktopStop } from './asst-computer.js';
 import {
-  applyLimit, applyLimitPacket, applyUsagePacket, brainLabel, createRenameWriter, createTabState, DEFAULT_ROUTE_MODE, deserializeTabState, fmtCost, fmtRunLine, limitExpiresIn, limitNoticeText, modelShortName,
-  brainModePatch, normalizeBrain, normalizeComputerMode, permissionModeLabel, normalizeRouteMode, normalizeTestDensity, projectLabel, providerShortLabel, readStoredBrain, runFromPayload,
+  applyLimit, applyLimitPacket, applyUsagePacket, BRAIN_PROVIDERS, brainLabel, createRenameWriter, createTabState, DEFAULT_ROUTE_MODE, deserializeTabState, fmtCost, fmtRunLine, limitExpiresIn, limitNoticeText, modelShortName,
+  brainModePatch, isBrainProvider, normalizeBrain, normalizeComputerMode, permissionModeLabel, normalizeRouteMode, normalizeTestDensity, projectLabel, providerMeta, providerShortLabel, readStoredBrain, runFromPayload,
   serializeTabState, sessionStatus, tabStorageKey, userSessionTitle,
 } from './asst-state.js';
 import {
@@ -244,8 +243,9 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
   if (host.toolbarSlot) host.toolbarSlot.appendChild(barEl);
 
   // ── Helpers ──
-  const providerIcon = (p) => getProviderMeta(p).icon;
-  const providerColor = (p) => getProviderMeta(p).color;
+  // A worker-only provider provider-icons.js does not know yet keeps its own name (asst-state.js providerMeta).
+  const providerIcon = (p) => providerMeta(p).icon;
+  const providerColor = (p) => providerMeta(p).color;
   const visible = () => { try { return host.isVisible ? !!host.isVisible() : true; } catch { return true; } };
 
   // ── Just-in-time tips (../tour/tour-tips.js): once each, ever; never in a replay or while the tour runs ──
@@ -537,6 +537,7 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     onFollowup: (text) => { submit(clickPayload(text)); },
     onFollowupOther: () => composer.focus(),
     onLimitRetry: (text) => { submit(clickPayload(text)); },
+    onSwitchProvider: (anchor, meta) => continueOnAnotherProvider(anchor, meta),
     limitInfo: () => st.limit,
     brainProvider: () => st.brain.provider,
     heroOrigin: () => { try { return host.takeHeroOrigin?.() || null; } catch { return null; } },
@@ -1480,6 +1481,7 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
         compact();
         return true;
       case 'new':
+        if (parsed.error === 'not_brain') { toast(notBrainText(parsed.provider)); return false; }
         newSession(parsed.provider || null);
         return true;
       case 'resume':
@@ -1507,6 +1509,7 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
         if (parsed.error) { toast(tt('assistant.slash.needsText', 'Usage: /remember <text>')); return false; }
         return queueOrSend({ ...payload, display: payload.text, text: tt('assistant.prompts.remember', 'Store this in SynaBun memory with the remember tool (pick a fitting category, project, tags and importance): {text}', { text: parsed.text }) });
       case 'model': {
+        if (parsed.error === 'not_brain') { toast(notBrainText(parsed.provider)); return false; }
         if (!parsed.model && !parsed.provider) { picker.openField('model'); return true; }
         const next = { ...st.brain };
         let requiresSwitch = false;
@@ -1555,10 +1558,15 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     }
   }
 
+  /** /model or /new naming a provider that runs dispatched work only (none today: all four can be the brain). */
+  function notBrainText(provider) {
+    return tt('assistant.slash.notBrain', '{provider} runs dispatched work only, never the Assistant itself. Send it a task with /dispatch {id} <task>.', { provider: providerShortLabel(provider), id: provider });
+  }
+
   function dispatchErrorText(parsed) {
     switch (parsed.error) {
-      case 'missing_provider': return tt('assistant.slash.dispatchProvider', 'Usage: /dispatch <claude|codex|opencode> [flags] <task>');
-      case 'invalid_provider': return tt('assistant.slash.dispatchInvalidProvider', 'Unknown provider "{provider}". Use claude, codex or opencode.', { provider: parsed.provider });
+      case 'missing_provider': return tt('assistant.slash.dispatchProvider', 'Usage: /dispatch <claude|codex|opencode|antigravity> [flags] <task>');
+      case 'invalid_provider': return tt('assistant.slash.dispatchInvalidProvider', 'Unknown provider "{provider}". Use claude, codex, opencode or antigravity.', { provider: parsed.provider });
       case 'unknown_flag': return tt('assistant.slash.dispatchUnknownFlag', 'Unknown flag --{flag}', { flag: parsed.flag });
       case 'missing_flag_value': return tt('assistant.slash.dispatchFlagValue', 'Flag --{flag} needs a value', { flag: parsed.flag });
       case 'missing_task': return tt('assistant.slash.dispatchTask', 'Add the task text after the flags');
@@ -1607,6 +1615,8 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
   }
 
   function newSession(provider) {
+    // Only a brain provider names a new session's brain (Claude Code, Codex, OpenCode or Antigravity).
+    if (provider && !isBrainProvider(provider)) provider = null;
     const b = provider ? normalizeBrain({ ...st.brain, provider, model: '', effort: null, agent: null, accountId: null }) : st.brain;
     // This one is still empty: it is the new session (the server keeps one draft, not a pile of them).
     // /new <provider> switches its brain as the picker does; what only this page showed (/help) is cleared.
@@ -1663,6 +1673,33 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     });
   }
 
+  // "Continue with another provider" on the Assistant's own limit-wait card: the same model menu
+  // the toolbar's model field opens (never a native select), minus the limited provider, then the
+  // existing switch (applyBrain → switch_brain) and, where the blocked prompt is known, Retry now's
+  // own resend (submit) — in that order, so the server sees the switch before the retried prompt.
+  function continueOnAnotherProvider(anchor, { excludeProvider = '', retryText = '' } = {}) {
+    if (!anchor) return;
+    const providers = BRAIN_PROVIDERS.filter((p) => p !== excludeProvider);
+    if (!providers.length) return;
+    openModelMenu(anchor, {
+      brain: st.brain,
+      t,
+      providers,
+      title: tt('assistant.limitWait.switchProvider', 'Continue with another provider'),
+      warnSwitch: true,
+      allowCustom: false, // a custom id here would resolve to the (still limited) current provider
+      onToast: toast,
+      onManageModels: () => openModels(),
+      onSelect: async (target) => {
+        if (!target?.provider) return;
+        await picker.switchProvider(target.provider, target.model || '');
+        if (destroyed) return;
+        renderer.clearLimitWait();
+        if (retryText) submit(clickPayload(retryText));
+      },
+    }).catch(() => {});
+  }
+
   // ── Runs ──
   async function focusRun(runId) {
     if (!runId) return;

package/neural-interface/public/shared/assistant/asst-render.js

@@ -50,13 +50,14 @@ import { closeMenu, isMenuOpen } from './asst-menu.js';
 import { computerToolName, describeComputerAction, frameUrls, markerPercent, openFrameLightbox, parseComputerResult, swapImage } from './asst-computer.js';
 import * as mascotLib from '../synabun-mascot.js';
 import { isReducedMotion, subscribe } from '../synabun-ticker.js';
-import { KIND_SPECS, callOutcome, commandOf, editDiff, editPaths, fmtDuration, groupSubject, headEllipsis, kindOf, maskEcho, mcpServerOf, middleEllipsis, planState, plural, prettyServer, receiptSentence, redactInput, resultDetail, sayCall, shouldFoldNarration, stationAggregate, stationKey, targetKey, toolWords, verbText, wrapRuns } from './asst-tool-kinds.js';
+import { KIND_SPECS, callOutcome, canonicalToolInput, commandOf, editDiff, editPaths, fmtDuration, groupSubject, headEllipsis, kindOf, maskEcho, mcpServerOf, middleEllipsis, planState, plural, prettyServer, receiptSentence, redactInput, resultDetail, sayCall, shouldFoldNarration, stationAggregate, stationKey, targetKey, toolWords, verbText, wrapRuns } from './asst-tool-kinds.js';
 import { injectRackStyles } from './asst-rack-styles.js';
 import { injectSceneStyles } from './asst-scene-styles.js';
 import { activityScene, compactActivity, isLivePhase, runChip, sceneOfClass, sceneSvg, stagePhase } from './asst-scenes.js';
 import { STAGE_TIMING, createWorkerStage } from './asst-run-stage.js';
 import { formatRunTokens } from './asst-usage.js';
 import { sanitizeHtmlString, sanitizeInto } from './asst-sanitize.js';
+import { renderStreamingMarkdown } from '../streaming-markdown.js';
 import { automationView } from './asst-automation.js';
 import { guessFollowups, splitFollowups } from './asst-followups.js';
 import { createFollowupsCard } from './asst-followups-card.js';
@@ -502,7 +503,9 @@ const SUGGESTION_KINDS = { computer: 'computer', web: 'web', fix: 'edit', skill:
  *          onFollowup(text, { set, indices }) (a follow-up was clicked: send `text` as the user's message),
  *          onFollowupOther() ("Something else…": the composer), limitInfo() → the session's limit notice
  *          ({ status, resetsAt } | null), brainProvider() → the brain's provider id, onLimitRetry(text)
- *          (Retry now on the Assistant's own limit card: send `text`) }
+ *          (Retry now on the Assistant's own limit card: send `text`), onSwitchProvider(anchorEl, { excludeProvider, retryText })
+ *          (Continue with another provider on the Assistant's own limit card: the host opens its own
+ *          provider picker anchored on anchorEl and decides what a pick does) }
  */
 export function createRenderer(transcriptEl, hooks = {}) {
   loadMarked();
@@ -522,6 +525,7 @@ export function createRenderer(transcriptEl, hooks = {}) {
   // there, above the "Working…" row, until it is answered; rows appended meanwhile go above it.
   const askTail = createAskTail($msgs, { anchor: () => (working?.parentNode === $msgs ? working : null) });
   let followTail = true;
+  let scrollFrame = 0;
   let emptyEl = null;
   let hero = null; // the empty state's character: { rig, el, box, parked, leaving, held, dock, egg, target }
   const mcpWarned = new Set();
@@ -637,7 +641,8 @@ export function createRenderer(transcriptEl, hooks = {}) {
 
   function scrollEnd(force = false) {
     if (!force && !followTail) return;
-    requestAnimationFrame(() => { $msgs.scrollTop = $msgs.scrollHeight; });
+    if (scrollFrame) return;
+    scrollFrame = requestAnimationFrame(() => { scrollFrame = 0; $msgs.scrollTop = $msgs.scrollHeight; });
   }
 
   function root() { return { container: $msgs, stream: null, key: null, msgId: null, lastAt: 0 }; }
@@ -948,7 +953,7 @@ export function createRenderer(transcriptEl, hooks = {}) {
    */
   function paintMessage(row, body, text, { streaming = false, scope = rootScope } = {}) {
     const split = splitFollowups(text, { streaming });
-    renderMarkdownInto(body, split.body);
+    renderStreamingMarkdown(body, split.body, renderMarkdownInto, { streaming });
     if (!streaming && split.block && scope === rootScope) attachFollowups(row, split.block);
     return split;
   }
@@ -963,6 +968,10 @@ export function createRenderer(transcriptEl, hooks = {}) {
   function attachFollowups(row, set) {
     if (!row || !set?.items?.length) return null;
     if (row._followups?.el.isConnected) return row._followups;
+    // One turn, one card: a set offered earlier in this turn (another text segment between tool calls, a
+    // streamed row the final message replaced) is superseded by this one. `offers` holds only this turn's:
+    // the user's prompt and a new turn settle and drop the earlier ones (settleOffers), which stay as history.
+    supersedeFollowups(row);
     const card = createFollowupsCard(set, {
       t,
       // A card drawn from the journal comes in quietly; a live one with a nod.
@@ -972,6 +981,7 @@ export function createRenderer(transcriptEl, hooks = {}) {
       onFocusComposer: () => hooks.onFollowupOther?.(),
     });
     row._followups = card;
+    card._row = row;
     (row.querySelector('.asst-msg-content') || row).appendChild(card.el);
     offers.add(card);
     registerAsk(card);
@@ -980,6 +990,19 @@ export function createRenderer(transcriptEl, hooks = {}) {
     return card;
   }
 
+  /** Take out this turn's open follow-ups cards that belong to a row other than `row`. */
+  function supersedeFollowups(row) {
+    for (const offer of [...offers]) {
+      if (!offer._row || offer._row === row) continue;
+      offers.delete(offer);
+      askCards.delete(offer);
+      try { offer.presenter?.destroy?.(); } catch { /* gone */ }
+      if (offer._row._followups === offer) offer._row._followups = null;
+      offer.el?.remove();
+    }
+    askTail.sync();
+  }
+
   /**
    * A finished turn whose last message still ends in a list of options or an "I can X, or Y" offer,
    * with no block: best-effort items read from the prose. Once per message.
@@ -987,6 +1010,8 @@ export function createRenderer(transcriptEl, hooks = {}) {
   function guessOffer() {
     const row = lastTextRow;
     if (!row?.isConnected || row._followups || row._guessed || row.classList.contains('asst-msg-error')) return;
+    // The turn already offered a set from its block: a guess from the prose would be a second card.
+    for (const offer of offers) if (offer._row && offer.el?.isConnected) return;
     row._guessed = true;
     const set = guessFollowups(row._text || '');
     if (set) attachFollowups(row, set);
@@ -1023,9 +1048,17 @@ export function createRenderer(transcriptEl, hooks = {}) {
     if (!read && !(brainError && reported)) return null;
     const resetsAt = reported ? info.resetsAt : read?.resetsAt;
     const retryText = t('assistant.limitWait.continue', 'The usage limit has reset. Retry what was blocked and continue where you left off.');
-    let provider = '';
-    try { provider = providerShortLabel(hooks.brainProvider?.() || ''); } catch { /* unknown */ }
-    return limitDock.set('brain', { resetsAt, since: nowMs(), provider, onRetry: () => { limitDock.set('brain', null); hooks.onLimitRetry?.(retryText); } });
+    let providerId = '';
+    try { providerId = hooks.brainProvider?.() || ''; } catch { /* unknown */ }
+    const provider = providerId ? providerShortLabel(providerId) : '';
+    return limitDock.set('brain', {
+      resetsAt, since: nowMs(), provider,
+      onRetry: () => { limitDock.set('brain', null); hooks.onLimitRetry?.(retryText); },
+      onSwitchProvider: typeof hooks.onSwitchProvider === 'function'
+        ? (anchor) => hooks.onSwitchProvider(anchor, { excludeProvider: providerId, retryText })
+        : null,
+      onClose: () => limitDock.set('brain', null),
+    });
   }
 
   /** The session's limit report changed (assistant:limit): this turn's waiting card counts to its reset time. */
@@ -1368,7 +1401,7 @@ export function createRenderer(transcriptEl, hooks = {}) {
     const kind = kindOf(block.name, block.input);
     const step = {
       type: 'call', id: block.id || `call-${++stepSeq}`, seq: ++stepSeq, name: block.name || 'tool', kind, key: stationKey(kind, block.name),
-      input: block.input || {}, state: 'running', result: '', detail: '', code: null, startedAt: nowMs(), endedAt: 0, progress: 0,
+      input: canonicalToolInput(block.input), state: 'running', result: '', detail: '', code: null, startedAt: nowMs(), endedAt: 0, progress: 0,
       timed: isTimed(), ghost, stale: false, rack, station: null, card: null, parent: parentOf(rack.scope), bodyBuilt: false,
       ...(extra || {}),
     };
@@ -1383,7 +1416,7 @@ export function createRenderer(transcriptEl, hooks = {}) {
   /** The final block of a streamed call, or the same block replayed: the step learns its input, nothing is added. */
   function updateCall(step, block) {
     if (block.name) step.name = block.name;
-    if (block.input && typeof block.input === 'object' && Object.keys(block.input).length) step.input = block.input;
+    if (block.input && typeof block.input === 'object' && Object.keys(block.input).length) step.input = canonicalToolInput(block.input);
     step.ghost = false;
     if (step.card?._computer) { step.card._computer.input = step.input; step.card._computer.description = describeComputerAction(step.input, step.name); }
     refreshStep(step);
@@ -3833,8 +3866,8 @@ export function createRenderer(transcriptEl, hooks = {}) {
       }
       case 'result': {
         flushStream(scope);
-        // Codex/OpenCode also send an `error` packet; the SDK reports only here.
-        const errorText = !parentId && ev.brain !== 'codex' && ev.brain !== 'opencode' ? resultErrorText(ev, t) : '';
+        // Codex/OpenCode/Antigravity also send an `error` packet; the SDK reports only here.
+        const errorText = !parentId && ev.brain !== 'codex' && ev.brain !== 'opencode' && ev.brain !== 'antigravity' ? resultErrorText(ev, t) : '';
         if (errorText && !muted) turn.errored = true;
         // The stage on screen waits for the turn's verdict (onResult → finishTurn) before it folds.
         if (!parentId && !muted) grace = newestStage();
@@ -4043,6 +4076,10 @@ export function createRenderer(transcriptEl, hooks = {}) {
   }
 
   function clear() {
+    if (scrollFrame) { cancelAnimationFrame(scrollFrame); scrollFrame = 0; }
+    clearTimeout(recutTimer);
+    recutTimer = 0;
+    toRecut.clear();
     for (const scope of scopes.values()) { if (scope.stream?.mdTimer) clearTimeout(scope.stream.mdTimer); if (scope.stream?.thinkTimer) clearTimeout(scope.stream.thinkTimer); }
     if (rootScope.stream?.mdTimer) clearTimeout(rootScope.stream.mdTimer);
     if (rootScope.stream?.thinkTimer) clearTimeout(rootScope.stream.thinkTimer);
@@ -4085,7 +4122,7 @@ export function createRenderer(transcriptEl, hooks = {}) {
   return {
     el: $msgs,
     clear,
-    destroy: () => { clear(); limitDock.destroy(); },
+    destroy: () => { clear(); stageResizes?.disconnect(); limitDock.destroy(); },
     appendUser,
     appendAssistantMarkdown,
     appendStatus,
@@ -4126,6 +4163,8 @@ export function createRenderer(transcriptEl, hooks = {}) {
     setWaiting,
     /** The session's usage-limit report changed: this turn's waiting card counts to its reset time. */
     noteLimit,
+    /** Dismiss the Assistant's own limit-wait card (a provider switch already decided what follows). */
+    clearLimitWait: () => limitDock.set('brain', null),
     finishTurn,
     renderTranscript,
     showWorking,