synabun 2.1.0 → 2.2.1

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

@@ -108,14 +108,22 @@ export function createAssistantHosts({
     return { host: hostId, sessionId, focused: true };
   }
 
-  /** Map(id → session) of the sessions still open on the server (boot's saved-tab restore). */
+  /**
+   * Map(id → session) of the sessions still open on the server, or null when the list could not be
+   * read (a server that is starting answers before its Assistant routes exist): a host restoring its
+   * saved tabs from it keeps them then, instead of reading "none is open".
+   */
+  async function readLive() {
+    let list;
+    try { list = await api.list(); } catch { return null; }
+    return new Map((Array.isArray(list) ? list : [])
+      .filter(s => s?.id && isAssistantSessionLive(s))
+      .map(s => [s.id, s]));
+  }
+
+  /** Map(id → session) of the sessions still open on the server (boot's saved-tab restore); a failing server reads as none. */
   async function fetchLive() {
-    try {
-      const list = await api.list();
-      return new Map((Array.isArray(list) ? list : [])
-        .filter(s => s?.id && isAssistantSessionLive(s))
-        .map(s => [s.id, s]));
-    } catch { return new Map(); }
+    return (await readLive()) || new Map();
   }
 
   /**
@@ -302,6 +310,7 @@ export function createAssistantHosts({
     gone,
     noteFocus,
     fetchLive,
+    readLive,
     isLive: isAssistantSessionLive,
     lastUsed: () => lastOpen(),
     hosts: () => [...adapters.keys()],

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

@@ -20,7 +20,12 @@ export function createLimitDock(transcript, { t, createWait = createLimitWait, c
       host.replaceChildren();
       active = key;
       provider = next?.[1].provider;
-      wait = next ? createWait({ t, ...next[1], onRetry: next[1].onRetry ? () => entries.get(key)?.onRetry?.() : null }) : null;
+      wait = next ? createWait({
+        t, ...next[1],
+        onRetry: next[1].onRetry ? () => entries.get(key)?.onRetry?.() : null,
+        onSwitchProvider: next[1].onSwitchProvider ? (anchor) => entries.get(key)?.onSwitchProvider?.(anchor) : null,
+        onClose: next[1].onClose ? () => entries.get(key)?.onClose?.() : null,
+      }) : null;
       if (wait) host.appendChild(wait.el);
     } else if (wait) wait.update({ resetsAt: next[1].resetsAt });
     host.hidden = !wait;

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-motion-gate.js

@@ -0,0 +1,80 @@
+// ═══════════════════════════════════════════
+// SynaBun Assistant — loops run only on screen
+// ═══════════════════════════════════════════
+// The transcript's decorative loops (a run card's cameo, its stage's scene and
+// sweep; a live rack's sweep, ticks and scene; a route line's sweep and icon)
+// run only while their holder is on screen. One IntersectionObserver per
+// renderer marks a holder that is not (scrolled out of its transcript, its tab
+// hidden, its window minimised to nothing) with `data-offscreen`; the
+// stylesheet pauses every animation under it (asst-styles.js), and the loop
+// picks up where it stopped when the holder is back. Every frame the page
+// draws restyles each running animation on the main thread, composited or
+// not, so a loop nobody sees is never free; the observer is the browser's own,
+// so watching costs nothing while the transcript scrolls.
+//
+//   createMotionGate({ IntersectionObserver }?) → { watch(el), unwatch(el), disconnect(), size() }
+//
+// No observer (an old engine, a test without one): nothing is marked, every
+// loop runs as before. DOM-light on purpose: tests/assistant-motion-gate.test.mjs
+// drives it with a stand-in observer.
+
+export const OFFSCREEN_ATTR = 'data-offscreen';
+const PRUNE_EVERY = 32; // watched holders between two sweeps for ones that left the document
+
+export function createMotionGate({ IntersectionObserver: IO = globalThis.IntersectionObserver } = {}) {
+  const watched = new Set();
+  let io = null; // undefined: no observer here
+
+  function mark(el, off) {
+    try {
+      if (off) { if (!el.hasAttribute(OFFSCREEN_ATTR)) el.setAttribute(OFFSCREEN_ATTR, ''); }
+      else if (el.hasAttribute(OFFSCREEN_ATTR)) el.removeAttribute(OFFSCREEN_ATTR);
+    } catch { /* not an element */ }
+  }
+
+  function observer() {
+    if (io !== null) return io;
+    if (typeof IO !== 'function') { io = undefined; return io; }
+    try {
+      io = new IO((entries) => {
+        for (const entry of entries) {
+          const el = entry.target;
+          if (!watched.has(el)) continue;
+          if (el.isConnected === false) { unwatch(el); continue; }
+          mark(el, !entry.isIntersecting);
+        }
+      });
+    } catch { io = undefined; }
+    return io;
+  }
+
+  /** Holders removed while already off screen get no report: drop them now and then. */
+  function prune() {
+    for (const el of Array.from(watched)) if (el.isConnected === false) unwatch(el);
+  }
+
+  function watch(el) {
+    if (!el || watched.has(el)) return false;
+    const o = observer();
+    if (!o) return false;
+    watched.add(el);
+    try { o.observe(el); } catch { watched.delete(el); return false; }
+    if (watched.size % PRUNE_EVERY === 0) prune();
+    return true;
+  }
+
+  function unwatch(el) {
+    if (!watched.delete(el)) return;
+    try { io?.unobserve(el); } catch { /* already gone */ }
+    mark(el, false);
+  }
+
+  function disconnect() {
+    try { io?.disconnect(); } catch { /* already gone */ }
+    for (const el of watched) mark(el, false);
+    watched.clear();
+    if (io) io = null;
+  }
+
+  return { watch, unwatch, disconnect, size: () => watched.size };
+}

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; } },
@@ -1117,7 +1118,7 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
           computerPanel.applyStatus(status);
           applyFeatures();
         })
-        .catch(() => { st.features.computer = false; applyFeatures(); });
+        .catch((err) => { st.features.computer = false; computerPanel.checkFailed?.(err); applyFeatures(); });
     }
   }
 
@@ -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;