synabun 2.1.0 → 2.2.0

package/neural-interface/public/shared/assistant/asst-routes-editor.js

@@ -3,13 +3,12 @@
 import { clampEffortId, getEffortLevelsForModel, modelEffortIds, fetchClaudeAccounts, fetchCodexAccounts, getCachedClaudeAccounts, getCachedCodexAccounts, getClaudeWorkerAccountId, getCodexWorkerAccountId } from '../agent-runtime-options.js';
 import { accountSummary, accountName, accountBadge, accountIdentity } from '../account-view.js';
 import { accountUsageText, autoAccountLabel } from '../account-usage.js';
-import { getProviderMeta } from '../provider-icons.js';
 import { getRouting, putRouting } from './asst-api.js';
 import { catalogModelRow, hiddenModelFor, ICON_CARET, openModelMenu } from './asst-brain-picker.js';
 import { closeMenu, currentMenu } from './asst-menu.js';
 import { loadRouteModels, routeModelLabel, routeModelsStatus, watchRouteModels } from './asst-route-models.js';
 import { designRouteSight, openModelsManager, routeCatalogRow, routeModeLabel } from './asst-route.js';
-import { DEFAULT_ROUTE_MODE, normalizeRouteMode, ROUTE_MODES } from './asst-state.js';
+import { DEFAULT_ROUTE_MODE, normalizeRouteMode, PROVIDERS, providerMeta, ROUTE_MODES } from './asst-state.js';
 
 const ICON_ROUTE = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M4 7h15l-4-4M20 17H5l4 4"/></svg>';
 const ICON_X = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"><path d="m6 6 12 12M18 6 6 18"/></svg>';
@@ -37,7 +36,8 @@ function choiceKey(p) { return p ? JSON.stringify([p.kind || 'direct', p.provide
 export function routeAccountView(pref, task, brain, accounts, workers = {}, t = null) {
   const tr = translator(t);
   const empty = { label: tr('assistant.routes.editorUnusedValue', '—'), readOnly: true, options: [], hint: '' };
-  if (!pref || pref.provider === 'opencode') return empty;
+  // Only Claude Code and Codex run under an account (OpenCode and Antigravity sign in inside their own CLIs).
+  if (!pref || pref.provider === 'opencode' || pref.provider === 'antigravity') return empty;
   const direct = task.id === 'chat' || routeExecutionKind(pref, task, brain) === 'direct';
   const provider = task.id === 'chat' ? brain.provider : pref.provider;
   if (!['claude-code', 'codex'].includes(provider)) return empty;
@@ -381,7 +381,8 @@ export async function openRoutesEditor(hooks = {}) {
       state.menuFocus = modelBtn.dataset.focusKey;
       const emptyLabel = task.requires ? tr('assistant.routes.noCapableModel', 'No model in your catalog can make {medium} yet.', { medium: tr(`assistant.routes.medium.${task.requires === 'video' ? 'videos' : 'images'}`, task.requires) }) : tr('assistant.routes.noSeeingModel', 'No model in your catalog can see images yet.');
       const menu = await openModelMenu(modelBtn, {
-        brain: brain(), t: hooks.t, includeHere: true, hereLabel: tr('assistant.routes.brainDecides', 'Assistant chooses'), title: task.label,
+        // Every provider a route can name (Antigravity included).
+        brain: brain(), t: hooks.t, includeHere: true, hereLabel: tr('assistant.routes.brainDecides', 'Assistant chooses'), title: task.label, providers: PROVIDERS,
         current: pref ? { provider: pref.provider, model: pref.model } : null, onToast: hooks.onToast,
         routingEditor: true, onManageModels: () => manageModels(modelBtn.dataset.focusKey),
         ...(task.requires ? { accept: (_p, m) => m.outputs?.[task.requires] === true, allowCustom: false, emptyLabel } : {}),
@@ -400,7 +401,7 @@ export async function openRoutesEditor(hooks = {}) {
     // Keys are stable across translations; accessible names use the translated field.
     modelBtn.dataset.focusKey = `${task.id}-model`; caret(modelBtn); modelBtn.setAttribute('aria-haspopup', 'dialog');
     modelBtn.title = label;
-    if (pref?.provider) { const mark = el('span', 'asst-icon'); mark.setAttribute('aria-hidden', 'true'); mark.innerHTML = getProviderMeta(pref.provider).icon; mark.style.color = getProviderMeta(pref.provider).color; modelBtn.prepend(mark); }
+    if (pref?.provider) { const mark = el('span', 'asst-icon'); mark.setAttribute('aria-hidden', 'true'); mark.innerHTML = providerMeta(pref.provider).icon; mark.style.color = providerMeta(pref.provider).color; modelBtn.prepend(mark); }
     modelCell.append(modelBtn);
     const source = el('span', 'asst-routes-source');
     let sourceText = pref ? tr('assistant.routes.source.yours', 'Your choice') : tr('assistant.routes.source.default', 'Assistant chooses');
@@ -433,14 +434,14 @@ export async function openRoutesEditor(hooks = {}) {
     if (effortValue !== unusedValue && effortValue !== effortText) effortBtn.setAttribute('aria-label', tr('assistant.routes.fieldLabel', '{task}: {field}, {value}', { task: task.label, field: tr('assistant.routes.columns.effort', 'Effort'), value: `${effortValue} · ${effortText}` }));
     const effortCell = el('div', 'asst-routes-cell asst-routes-effort-cell'); effortCell.append(el('span', 'asst-routes-cell-label', tr('assistant.routes.columns.effort', 'Effort')), effortBtn); node.append(effortCell);
     const kind = routeExecutionKind(pref, task, brain());
-    const runLabel = task.id === 'chat' ? tr('assistant.routes.inConversation', 'In conversation') : !pref ? task.dispatchOnly ? tr('assistant.routes.workerChooses', 'Worker · assistant chooses') : tr('assistant.routes.brainDecides', 'Assistant chooses') : kind === 'direct' ? tr('assistant.routes.inConversation', 'In conversation') : tr('assistant.routes.onWorker', '{provider} worker', { provider: getProviderMeta(pref.provider).label });
+    const runLabel = task.id === 'chat' ? tr('assistant.routes.inConversation', 'In conversation') : !pref ? task.dispatchOnly ? tr('assistant.routes.workerChooses', 'Worker · assistant chooses') : tr('assistant.routes.brainDecides', 'Assistant chooses') : kind === 'direct' ? tr('assistant.routes.inConversation', 'In conversation') : tr('assistant.routes.onWorker', '{provider} worker', { provider: providerMeta(pref.provider).label });
     const run = fieldButton('asst-routes-run', task, tr('assistant.routes.columns.run', 'Runs in'), runLabel, () => openMenuFor(run, tr('assistant.routes.columns.run', 'Runs in'), [
       { kind: 'radio', id: 'direct', label: tr('assistant.routes.inConversation', 'In conversation'), desc: tr('assistant.routes.conversationDesc', 'Continue this conversation on the chosen model for this task.'), selected: kind === 'direct', onSelect: () => setChoice(task.id, { ...pref, kind: 'direct' }, run.dataset.focusKey) },
-      { kind: 'radio', id: 'dispatch', label: tr('assistant.routes.onWorker', '{provider} worker', { provider: getProviderMeta(pref?.provider).label }), desc: tr('assistant.routes.workerDesc', 'Hand the task to a worker and show its result here.'), selected: kind === 'dispatch', onSelect: () => setChoice(task.id, { ...pref, kind: 'dispatch' }, run.dataset.focusKey) },
+      { kind: 'radio', id: 'dispatch', label: tr('assistant.routes.onWorker', '{provider} worker', { provider: providerMeta(pref?.provider).label }), desc: tr('assistant.routes.workerDesc', 'Hand the task to a worker and show its result here.'), selected: kind === 'dispatch', onSelect: () => setChoice(task.id, { ...pref, kind: 'dispatch' }, run.dataset.focusKey) },
     ]));
     run.dataset.focusKey = `${task.id}-run`; run.disabled = !pref || task.dispatchOnly || pref.provider !== brain().provider || task.id === 'chat';
     const inConversation = task.id === 'chat' || (pref && kind === 'direct');
-    const runValue = inConversation ? tr('assistant.routes.editorInConversation', 'This conversation') : pref ? getProviderMeta(pref.provider).label : unusedValue;
+    const runValue = inConversation ? tr('assistant.routes.editorInConversation', 'This conversation') : pref ? providerMeta(pref.provider).label : unusedValue;
     run.querySelector('.asst-dd-label').textContent = runValue;
     if (inConversation) run.setAttribute('aria-label', tr('assistant.routes.fieldLabel', '{task}: {field}, {value}', { task: task.label, field: tr('assistant.routes.columns.run', 'Runs in'), value: runValue }));
     if (!run.disabled) caret(run);

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

@@ -116,6 +116,8 @@ export function runChip(run, t = tFallback) {
   }
   if (awaitsAnswer(run)) return { tone: 'action', label: t('assistant.run.waitingInput', 'waiting for your answer') };
   const tone = runTone(run);
+  // A held run whose card the user answered "here": the assistant does it, this worker never started.
+  if (run?.completionReason === 'route_here') return { tone, label: t('assistant.run.routedHere', 'not started: done here instead') };
   if (run?.turnState === 'awaiting_permission') return { tone, label: t('assistant.run.needsApproval', 'needs approval') };
   if (run?.turnState === 'needs_input') return { tone, label: t('assistant.run.needsInput', 'needs input') };
   // A Claude Code worker a server restart cut off, until the next start has resumed it (lib/assistant-dispatch.js).
@@ -169,6 +171,46 @@ export const CODEX_ITEM_EVENTS = Object.freeze({
  */
 export const OPENCODE_TOOL_STATES = Object.freeze(['running', 'completed', 'error']);
 
+// The path-like fields of an Antigravity tool call's arguments (lib/worker-confinement.js reads the same ones).
+const ACP_PATH_KEYS = ['path', 'file_path', 'filePath', 'Path', 'AbsolutePath', 'TargetFile', 'DirectoryPath', 'SearchPath'];
+
+/**
+ * An Antigravity (ACP) tool call as an activity: its `kind` says what it does (read, edit, delete,
+ * move, search, execute, think, fetch, switch_mode, other), its `rawInput` holds the tool's own
+ * arguments and its `locations` the files it touches. Another tool (an MCP server's) is read by its
+ * name, as for the other providers. null for a mode switch.
+ */
+function acpToolActivity(call) {
+  const args = obj(call.rawInput);
+  const kind = str(call.kind) || 'other';
+  const title = str(call.title).trim();
+  const paths = [...new Set([
+    ...(Array.isArray(call.locations) ? call.locations : []).map((location) => str(location?.path)),
+    ...ACP_PATH_KEYS.map((key) => (typeof args[key] === 'string' ? args[key] : '')),
+  ].filter(Boolean))];
+  const pick = (...values) => values.map((v) => (typeof v === 'string' ? v.trim() : '')).find(Boolean) || '';
+  switch (kind) {
+    case 'execute': {
+      const command = Array.isArray(args.command) ? args.command.map(str).join(' ') : pick(args.command, args.CommandLine, args.cmd);
+      return { kind: 'shell', name: 'exec_command', input: { command: command || title } };
+    }
+    case 'read': return { kind: 'read', name: 'read', input: { file_path: paths[0] || title } };
+    case 'edit': case 'delete': case 'move':
+      return { kind: 'edit', name: kind === 'edit' ? 'edit' : 'apply_patch', input: paths.length > 1 ? { changes: paths.map((path) => ({ path })) } : { file_path: paths[0] || title } };
+    case 'search': return { kind: 'search', name: 'grep', input: { pattern: pick(args.pattern, args.query, args.Query, args.Pattern) || title, path: paths[0] || '' } };
+    case 'fetch': {
+      const url = pick(args.url, args.Url, args.href);
+      return url ? { kind: 'web', name: 'WebFetch', input: { url } } : { kind: 'web', name: 'WebSearch', input: { query: pick(args.query, args.Query) || title } };
+    }
+    case 'think': return { kind: 'think', name: 'thinking', input: {} };
+    case 'switch_mode': return null;
+    default: {
+      const name = pick(call.name, args.toolName, title) || 'tool';
+      return { kind: kindOf(name, args), name, input: args };
+    }
+  }
+}
+
 /**
  * A worker's provider event ({ provider, eventType?, event }, the payload of
  * sync:sidepanel:provider-event) as what it is doing: { kind, name, input }
@@ -177,7 +219,11 @@ export const OPENCODE_TOOL_STATES = Object.freeze(['running', 'completed', 'erro
  * stage and the tray keep only compactActivity() of it. OpenCode names its
  * tools bash, read, edit, write, patch, glob, grep, list, webfetch,
  * websearch, codesearch, task, todowrite, and MCP tools `<server>_<tool>`
- * (SynaBun_browser_navigate): kindOf() reads all of them.
+ * (SynaBun_browser_navigate): kindOf() reads all of them. An Antigravity
+ * worker's events are ACP session updates (eventType = their `sessionUpdate`):
+ * a tool call when it is announced (`tool_call`, or an update that starts it
+ * and names its kind), a thought chunk as thinking, a plan as planning; its
+ * message text is no activity, as for the others.
  */
 export function activityOf(payload) {
   const provider = str(payload?.provider);
@@ -222,6 +268,13 @@ export function activityOf(payload) {
     const input = obj(part.state?.input);
     return { kind: kindOf(name, input), name, input };
   }
+  if (provider === 'antigravity') {
+    const type = str(payload.eventType || event.sessionUpdate);
+    if (type === 'agent_thought_chunk') return { kind: 'think', name: 'thinking', input: {} };
+    if (type === 'plan') return { kind: 'plan', name: 'update_plan', input: { todos: Array.isArray(event.entries) ? event.entries : [] } };
+    if (type === 'tool_call' || (type === 'tool_call_update' && str(event.kind) && event.status === 'in_progress')) return acpToolActivity(event);
+    return null;
+  }
   return null;
 }
 

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

@@ -22,7 +22,7 @@ import { getProviderMeta } from '../provider-icons.js';
 import { showGuestToast } from '../ui-sync.js';
 import { registerSidepanel, setSidepanelVisible, syncSidepanelLayout, focusSidepanel } from '../ui-sidepanel-windows.js';
 import {
-  assistantBlocked, assistantOwnerOf, fetchLiveAssistantSessions, noteAssistantFocus, openAssistant, registerAssistantHost,
+  assistantBlocked, assistantOwnerOf, noteAssistantFocus, openAssistant, readLiveAssistantSessions, registerAssistantHost,
 } from '../ui-assistant.js';
 import { mountAssistant } from './asst-panel.js';
 import { openModelsManager } from './asst-route.js';
@@ -57,6 +57,11 @@ let _renaming = false;
 const _tabs = [];   // { sessionId, viewport, toolbar, ctl, pill, label, userRenamed, status, brain }
 let _activeIdx = -1;
 let _tourPresenting = false;
+// The saved tabs ({ activeIdx, tabs }) while the session list could not be read (a server that is
+// starting answers before its Assistant routes exist): they stay saved and are asked about again.
+let _unrestored = null;
+let _restoring = null; // that restore under way: a session start waits for it
+const RESTORE_RETRY_MS = [500, 1000, 2000, 4000, 8000, 15_000];
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -94,11 +99,13 @@ function conversationOf(tab) {
 
 function saveTabs() {
   try {
-    if (!_tabs.length) { storage.removeItem(KEYS.ASSISTANT_PANEL_TABS); return; }
+    // Saved tabs not restored yet stay saved (their names with them), after the open ones.
+    const waiting = (_unrestored?.tabs || []).filter(entry => !findTab(entry.sessionId));
+    if (!_tabs.length) { if (!waiting.length) storage.removeItem(KEYS.ASSISTANT_PANEL_TABS); return; }
     storage.setItem(KEYS.ASSISTANT_PANEL_TABS, JSON.stringify({
       v: 1,
       activeIdx: Math.max(0, _activeIdx),
-      tabs: _tabs.map(tab => ({ sessionId: tab.sessionId, label: tab.userRenamed ? tab.label : '', userRenamed: !!tab.userRenamed })),
+      tabs: [..._tabs.map(tab => ({ sessionId: tab.sessionId, label: tab.userRenamed ? tab.label : '', userRenamed: !!tab.userRenamed })), ...waiting],
     }));
   } catch { /* storage unavailable */ }
 }
@@ -416,6 +423,16 @@ async function startSession(prompt = '') {
   _startError = '';
   renderPlaceholder('starting');
   try {
+    // The saved tabs come back before a new session is made: the restore under way (the server is
+    // starting), or once more for the ones it could not ask about.
+    if (!_restoring && _unrestored) startRestore(_unrestored, []);
+    if (_restoring) await _restoring.catch(() => { /* a new session, then */ });
+    if (_tabs.length) {
+      const tab = activeTab() || _tabs[0];
+      switchTo(_tabs.indexOf(tab));
+      if (prompt) { tab.ctl?.insertText?.(prompt); tab.ctl?.focus?.(); } // a conversation's draft, never sent for them
+      return;
+    }
     const res = await openAssistant(prompt ? { host: HOST_ID, prompt } : { host: HOST_ID });
     if (!_tabs.length) renderPlaceholder(res ? null : 'failed');
   } finally {
@@ -635,7 +652,7 @@ export function beginAssistantTour({ onPreviewSend = () => {} } = {}) {
   const wasVisible = _visible;
   const previousPanel = state.lastActivePanel;
   const previousSidepanel = state.lastActiveSidepanel;
-  const peers = ['#topright-claude-panel-btn', '#topright-codex-panel-btn', '#topright-opencode-panel-btn']
+  const peers = ['#topright-claude-panel-btn', '#topright-codex-panel-btn', '#topright-opencode-panel-btn', '#topright-antigravity-panel-btn']
     .map(s => document.querySelector(s)).filter(b => b?.classList.contains('active'));
   _tourPresenting = true;
   const tab = activeTab();
@@ -731,7 +748,30 @@ export async function initAssistantPanel() {
 
   const saved = readSavedTabs();
   if (!saved?.tabs.length) return;
-  const live = await fetchLiveAssistantSessions();
+  await startRestore(saved, RESTORE_RETRY_MS);
+}
+
+function startRestore(saved, retries) {
+  _restoring = restoreSavedTabs(saved, retries).finally(() => { _restoring = null; });
+  return _restoring;
+}
+
+/**
+ * The saved tabs come back (hidden, as pills) for the sessions the server still has open. A list
+ * that cannot be read restores nothing and forgets nothing: the tabs stay saved, names included
+ * (saveTabs), the list is asked again after each wait of `retries`, then at the next session start.
+ */
+async function restoreSavedTabs(saved, retries) {
+  _unrestored = saved;
+  let live = await readLiveAssistantSessions();
+  for (const wait of retries) {
+    if (live || assistantBlocked()) break;
+    await new Promise(done => setTimeout(done, wait));
+    live = await readLiveAssistantSessions();
+  }
+  if (!live) return;
+  _unrestored = null;
+  const hadTabs = _tabs.length > 0; // one opened meanwhile stays the one showing
   for (const entry of saved.tabs) {
     const meta = live.get(entry.sessionId);
     if (!meta) continue;
@@ -746,8 +786,12 @@ export async function initAssistantPanel() {
       restoring: true,
     });
   }
-  if (_tabs.length) {
-    _activeIdx = Math.min(Math.max(0, saved.activeIdx), _tabs.length - 1);
+  if (_tabs.length && !hadTabs) {
+    // The tab that was showing, by its session: a saved tab before it that did not come back (a draft,
+    // an ended session) must not hand the header to its neighbour.
+    const shownId = saved.tabs[saved.activeIdx]?.sessionId;
+    const shown = _tabs.findIndex(tab => tab.sessionId === shownId);
+    _activeIdx = shown >= 0 ? shown : Math.min(Math.max(0, saved.activeIdx), _tabs.length - 1);
     markActive();
     renderHeader();
     renderPills();

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

@@ -4,7 +4,7 @@
 // Pure module (no DOM, no i18n import) so node:test can exercise it. The
 // composer resolves `descKey` through i18n and falls back to `desc`.
 
-import { normalizeComputerMode, normalizeProvider, normalizeRouteMode } from './asst-state.js';
+import { isBrainProvider, normalizeComputerMode, normalizeProvider, normalizeRouteMode } from './asst-state.js';
 
 export const SLASH_COMMANDS = [
   { name: 'dispatch', usage: '/dispatch <provider> [--model m] [--effort e] [--agent a] [--project p] [--tools a,b] [--account id] [--ask] [--title "t"] <task>', descKey: 'assistant.slash.dispatch', desc: 'Dispatch a task to a sidepanel agent' },
@@ -143,6 +143,8 @@ function parseModel(rest) {
     provider = normalizeProvider(first);
     model = null;
   }
+  // /model switches the brain: a provider that only runs dispatched work (none of the four today) is refused, not swapped.
+  if (provider && !isBrainProvider(provider)) return { name: 'model', provider, model, effort: tokens[1] || null, error: 'not_brain' };
   return { name: 'model', provider, model, effort: tokens[1] || null };
 }
 
@@ -182,7 +184,11 @@ export function parseSlashCommand(text) {
       return enabled == null ? { name, mode: null, error: 'invalid_mode', value: restTrim } : { name, mode: enabled ? 'on' : 'off' };
     }
     case 'stop': return { name, target: restTrim && !/^all$/i.test(restTrim) ? restTrim : null, all: /^all$/i.test(restTrim) };
-    case 'new': return { name, provider: restTrim ? normalizeProvider(restTrim) : null };
+    case 'new': {
+      const provider = restTrim ? normalizeProvider(restTrim) : null;
+      // A new session's brain: a provider that only runs dispatched work cannot be one (Antigravity can, since it runs the brain too).
+      return provider && !isBrainProvider(provider) ? { name, provider, error: 'not_brain' } : { name, provider };
+    }
     case 'resume': return { name, sessionId: restTrim || null };
     case 'compact':
     case 'clear':

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

@@ -8,9 +8,23 @@
 import { KEYS } from '../constants.js';
 import { isNewerRunDescriptor } from '../ui-native-loop-router-state.js';
 import { modelEffortIds } from '../agent-runtime-options.js';
+import { getProviderMeta } from '../provider-icons.js';
 import { usagePacketIsStale } from './asst-usage.js';
 
-export const PROVIDERS = ['claude-code', 'codex', 'opencode'];
+// The providers the Assistant itself can run on (its brain): the brain picker, /model and /new.
+// Antigravity runs over ACP (lib/assistant-brains/antigravity.js), like a worker.
+export const BRAIN_PROVIDERS = ['claude-code', 'codex', 'opencode', 'antigravity'];
+// Providers that only ever run dispatched work. None any more (Antigravity became a brain too); kept so a module
+// or a test that still imports the list reads it as empty.
+export const WORKER_ONLY_PROVIDERS = [];
+// Every provider the Assistant lists models for and can route a task to.
+export const PROVIDERS = [...BRAIN_PROVIDERS, ...WORKER_ONLY_PROVIDERS];
+// Providers that report tokens and no prices (Antigravity bills through its Google sign-in): a budget gives them no
+// share, so a dry share never names them (asst-route.js), and their rows read "unpriced".
+export const UNPRICED_PROVIDERS = ['antigravity'];
+// Providers an older server may not list in its catalog yet: a model section without rows and without an archive
+// for them stays hidden rather than showing an empty provider.
+export const OPTIONAL_PROVIDERS = ['antigravity'];
 
 export const PROVIDER_ALIASES = {
   'claude-code': 'claude-code',
@@ -22,24 +36,38 @@ export const PROVIDER_ALIASES = {
   openai: 'codex',
   opencode: 'opencode',
   oc: 'opencode',
+  antigravity: 'antigravity',
+  agy: 'antigravity',
+  'google antigravity': 'antigravity',
+  // Antigravity's CLI took the place of Gemini CLI: an old name or saved route means it.
+  gemini: 'antigravity',
 };
 
 export const PROVIDER_SHORT_LABELS = {
   'claude-code': 'Claude',
   codex: 'Codex',
   opencode: 'OpenCode',
+  antigravity: 'Antigravity',
+};
+
+export const PROVIDER_LABELS = {
+  'claude-code': 'Claude Code',
+  codex: 'Codex',
+  opencode: 'OpenCode',
+  antigravity: 'Antigravity',
 };
 
 // Providers whose brain carries an account profile picker.
 export const ACCOUNT_PROVIDERS = new Set(['claude-code', 'codex']);
 
 // Approval modes are sent as `permissionMode` (`set_permission_mode {mode}` /
-// `query.permissionMode`). Claude uses the SDK enum; Codex/OpenCode brains only
-// distinguish "ask me" from "auto-approve". Plan mode is a separate flag
-// (`planMode`) that combines with any approval mode, each provider in its own
-// way: Claude runs the SDK 'plan' mode and returns to the approval mode once
+// `query.permissionMode`). Claude uses the SDK enum; Codex/OpenCode/Antigravity
+// brains only distinguish "ask me" from "auto-approve". Plan mode is a separate
+// flag (`planMode`) that combines with any approval mode, each provider in its
+// own way: Claude runs the SDK 'plan' mode and returns to the approval mode once
 // the plan is approved; Codex runs its native plan collaboration mode (read-only
-// sandbox); OpenCode runs its own `plan` agent.
+// sandbox); OpenCode runs its own `plan` agent; Antigravity refuses code changes
+// through SynaBun's hook and proposes the plan in a <proposed_plan> block.
 export const PERMISSION_MODES = {
   'claude-code': [
     { id: 'default', label: 'Default' },
@@ -54,9 +82,13 @@ export const PERMISSION_MODES = {
     { id: 'default', label: 'Default' },
     { id: 'auto', label: 'Auto-accept' },
   ],
+  antigravity: [
+    { id: 'default', label: 'Default' },
+    { id: 'auto', label: 'Auto-accept' },
+  ],
 };
 
-export const PLAN_MODE_PROVIDERS = new Set(['claude-code', 'codex', 'opencode']);
+export const PLAN_MODE_PROVIDERS = new Set(['claude-code', 'codex', 'opencode', 'antigravity']);
 
 export const DEFAULT_BRAIN = Object.freeze({
   provider: 'claude-code',
@@ -80,10 +112,42 @@ export function normalizeProvider(value, fallback = null) {
   return PROVIDER_ALIASES[key] || fallback;
 }
 
+/** Can the Assistant itself run on `provider` (a canonical id)? */
+export function isBrainProvider(provider) {
+  return BRAIN_PROVIDERS.includes(provider);
+}
+
+/** Does `provider` report tokens and no prices (Antigravity)? */
+export function isUnpricedProvider(provider) {
+  return UNPRICED_PROVIDERS.includes(provider);
+}
+
+/** `value` as a brain provider, else `fallback`: an unknown name (or a worker-only provider) is never a brain. */
+export function normalizeBrainProvider(value, fallback = null) {
+  const provider = normalizeProvider(value);
+  return provider && isBrainProvider(provider) ? provider : fallback;
+}
+
 export function providerShortLabel(provider) {
   return PROVIDER_SHORT_LABELS[provider] || String(provider || '');
 }
 
+/** "Claude Code", "Antigravity": a provider's full name ('' for none). */
+export function providerLabel(provider) {
+  return PROVIDER_LABELS[provider] || String(provider || '');
+}
+
+/**
+ * The icon, colour and name of a provider (provider-icons.js). A provider that file does not know
+ * yet keeps its own name and shows no icon, never another provider's (getProviderMeta falls back to
+ * Claude Code's for an unknown id).
+ */
+export function providerMeta(provider) {
+  const meta = getProviderMeta(provider || undefined);
+  if (!provider || meta?.id === provider) return meta;
+  return { id: provider, label: providerLabel(provider), shortLabel: providerShortLabel(provider), icon: '', color: '' };
+}
+
 function str(value) {
   if (value == null) return '';
   return String(value).trim();
@@ -93,16 +157,19 @@ function str(value) {
 export function normalizeBrain(raw, fallback = DEFAULT_BRAIN) {
   const base = { ...DEFAULT_BRAIN, ...(fallback || {}) };
   const src = raw && typeof raw === 'object' ? raw : {};
-  const provider = normalizeProvider(src.provider ?? src.brain, base.provider) || 'claude-code';
+  // A provider that cannot be the brain (an unknown name) falls back like any unknown one.
+  const provider = normalizeBrainProvider(src.provider ?? src.brain, normalizeBrainProvider(base.provider)) || 'claude-code';
   const modes = PERMISSION_MODES[provider] || PERMISSION_MODES['claude-code'];
   const rawMode = str(src.permissionMode);
   // 'plan' used to be one of Claude's permission modes: it is the plan flag now.
   const legacyPlan = rawMode === 'plan';
   const mode = legacyPlan ? 'default' : rawMode;
+  const effort = str(src.effort) || null;
   return {
     provider,
     model: str(src.model),
-    effort: str(src.effort) || null,
+    // Antigravity's thinking levels have no "off": no level is the model's own default (null).
+    effort: provider === 'antigravity' && effort === 'off' ? null : effort,
     agent: provider === 'opencode' ? (str(src.agent) || null) : null,
     project: str(src.project ?? src.cwd) || null,
     tools: provider === 'opencode' ? (Array.isArray(src.tools) ? [...src.tools] : null) : ['all'],

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

@@ -1368,6 +1368,40 @@ export function injectAssistantStyles() {
     /* Route card */
     .asst-route-summary { color: var(--asst-text); }
     .asst-route-reasons { margin-top: -4px; color: var(--asst-text-3); font-size: 11.5px; }
+    /* Here / Dispatch: a segmented choice of where the task runs; the list, the model menu and Run follow it.
+       sm capsules in one xs-padded track; the pick takes the gold "on" pair, like the option's key. */
+    .asst-route-sides {
+      display: inline-flex;
+      align-self: flex-start;
+      gap: 2px;
+      padding: 2px;
+      border-radius: var(--asst-pill-r-md);
+      background: var(--asst-fill-1);
+      box-shadow: inset 0 0 0 1px var(--asst-line);
+    }
+    .asst-route-side {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      min-width: 76px;
+      height: var(--asst-pill-h-sm);
+      padding: 0 var(--asst-pill-px-sm);
+      border: 0;
+      border-radius: var(--asst-pill-r-sm);
+      background: transparent;
+      color: var(--asst-text-2);
+      font: inherit;
+      font-size: 12px;
+      font-weight: 500;
+      white-space: nowrap;
+      cursor: pointer;
+      transition: background-color var(--asst-dur-fast) var(--asst-ease-standard), box-shadow var(--asst-dur-fast) var(--asst-ease-standard), color var(--asst-dur-fast) var(--asst-ease-standard);
+    }
+    .asst-route-side:hover { background: var(--asst-fill-2); color: var(--asst-text); }
+    .asst-route-side.selected { background: var(--asst-pill-on-fill); box-shadow: inset 0 0 0 1px var(--asst-pill-on-ring); color: var(--asst-text); }
+    .asst-route-side[aria-disabled="true"] { opacity: .45; cursor: not-allowed; }
+    .asst-route-side[aria-disabled="true"]:not(.selected):hover { background: transparent; color: var(--asst-text-2); }
+    .asst-route-side-note { margin-top: -6px; color: var(--asst-text-3); font-size: 11.5px; }
     .asst-route-options { display: flex; flex-direction: column; gap: 4px; }
     .asst-route-option {
       display: flex;

package/neural-interface/public/shared/assistant/asst-tool-kinds.js

@@ -13,16 +13,43 @@
 
 export const KIND_IDS = Object.freeze(['shell', 'read', 'edit', 'search', 'web', 'subagent', 'plan', 'memory', 'runs', 'computer', 'think', 'mcp']);
 
-// Tool names after lowercasing and stripping `mcp__<server>__` / `<server>_`.
+// Tool names after lowercasing and stripping `mcp__<server>__` / `<server>_`. Antigravity's own tools keep their
+// snake_case names (run_command, read_file, write_to_file, grep_search, search_web …).
 const KIND_TOOLS = {
-  shell: ['bash', 'bashoutput', 'killshell', 'shell', 'exec_command', 'commandexecution'],
-  read: ['read', 'notebookread', 'view'],
-  edit: ['edit', 'multiedit', 'write', 'notebookedit', 'patch', 'apply_patch', 'filechange'],
-  search: ['grep', 'glob', 'ls', 'list', 'codesearch', 'toolsearch'],
-  web: ['webfetch', 'websearch'],
-  subagent: ['task', 'agent', 'collabtoolcall', 'taskstop'],
+  shell: ['bash', 'bashoutput', 'killshell', 'shell', 'exec_command', 'commandexecution', 'run_command', 'send_command_input', 'command_status', 'read_terminal', 'shell_exec'],
+  read: ['read', 'notebookread', 'view', 'read_file', 'view_file', 'view_file_outline', 'view_code_item', 'view_content_chunk', 'read_resource', 'read_notebook'],
+  edit: ['edit', 'multiedit', 'write', 'notebookedit', 'patch', 'apply_patch', 'filechange', 'write_to_file', 'write_file', 'create_file', 'replace_file_content', 'multi_replace_file_content', 'edit_file', 'edit_notebook', 'delete_file', 'move_file'],
+  search: ['grep', 'glob', 'ls', 'list', 'codesearch', 'toolsearch', 'grep_search', 'find_by_name', 'list_dir', 'list_directory', 'codebase_search', 'code_search'],
+  web: ['webfetch', 'websearch', 'search_web', 'read_url_content', 'open_browser_url', 'read_browser_page', 'browser_subagent'],
+  subagent: ['task', 'agent', 'collabtoolcall', 'taskstop', 'invoke_subagent'],
   plan: ['todowrite', 'todoread', 'update_plan'],
 };
+
+// Antigravity names its arguments in its own words: each alias is filled from the first of them that is set.
+const INPUT_ALIASES = [
+  ['command', ['CommandLine']],
+  ['cwd', ['Cwd']],
+  ['file_path', ['AbsolutePath', 'TargetFile', 'Path']],
+  ['path', ['DirectoryPath', 'SearchPath', 'SearchDirectory']],
+  ['query', ['Query']],
+  ['url', ['Url']],
+];
+
+/**
+ * A tool call's input with the names the rack reads (command, file_path, path, query, url) filled from
+ * Antigravity's own (CommandLine, AbsolutePath, TargetFile, DirectoryPath, Query, Url …). A name that is set
+ * already is kept; anything else is left as it came. Not an object: {}.
+ */
+export function canonicalToolInput(input) {
+  const i = input && typeof input === 'object' && !Array.isArray(input) ? input : {};
+  let out = null;
+  for (const [alias, sources] of INPUT_ALIASES) {
+    if (i[alias] !== undefined && i[alias] !== null && i[alias] !== '') continue;
+    const value = sources.map(key => i[key]).find(v => typeof v === 'string' && v);
+    if (value) { out = out || { ...i }; out[alias] = value; }
+  }
+  return out || i;
+}
 // SynaBun's own tools: only when the call is SynaBun's (or carries no server).
 const MEMORY_TOOLS = ['recall', 'remember', 'reflect', 'forget', 'restore', 'memories', 'sync', 'category'];
 const COMPUTER_TOOLS = ['computer', 'computer_apps', 'computer_ax', 'computer_status'];

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

@@ -13,6 +13,7 @@ const REASONS = {
   'codex-no-records': ['reason.codex-no-records', 'Codex ended without final usage records.'],
   'codex-rollout-missing': ['reason.codex-rollout-missing', "Codex usage records were missing; the turn's own totals were used."],
   'opencode-not-reconciled': ['reason.opencode-not-reconciled', "OpenCode's final message check did not finish."],
+  'antigravity-total-mismatch': ['reason.antigravity-total-mismatch', "Antigravity's token total did not match its token classes; the classes were counted as reported."],
   interrupted: ['reason.interrupted', 'A turn was interrupted; the call it cut off is counted from the stream.'],
   'no-result': ['reason.no-result', 'A run ended mid-turn; its last calls are counted from the stream.'],
 };
@@ -34,7 +35,7 @@ const node = (tag, cls, value) => {
 };
 const valid = (n) => Number.isSafeInteger(n) && n >= 0;
 const safe = (n) => (valid(n) ? n : 0);
-const providerName = (id) => ['claude-code', 'codex', 'opencode'].includes(id) ? getProviderMeta(id).label : id === 'jev' ? 'Jev' : String(id || '');
+const providerName = (id) => ['claude-code', 'codex', 'opencode'].includes(id) ? getProviderMeta(id).label : id === 'antigravity' ? 'Antigravity' : id === 'jev' ? 'Jev' : String(id || '');
 const defaultTr = (_, fallback, params) => String(fallback).replace(/\{(\w+)\}/g, (_m, key) => params?.[key] ?? `{${key}}`);
 export const formatExactTokens = (n) => new Intl.NumberFormat('en-US', { maximumFractionDigits: 0 }).format(valid(n) ? n : 0);
 export function formatCompactTokens(n) {

package/neural-interface/public/shared/cdx/cdx-output.js

@@ -6,7 +6,7 @@ const bound = new WeakSet();
 const diffStates = new WeakMap();
 const pending = new WeakMap();
 const cleaned = new WeakMap();
-const watched = new WeakSet();
+const watched = new WeakMap(); // transcript -> teardown (including queued mutation work)
 const observer = typeof IntersectionObserver === 'function' ? new IntersectionObserver(entries => {
   for (const entry of entries) if (entry.isIntersecting) { pending.get(entry.target)?.(); observer.unobserve(entry.target); pending.delete(entry.target); }
 }, { rootMargin: '200px' }) : null;
@@ -23,6 +23,7 @@ const measurements = new WeakMap();
 const measurementQueue = new Set();
 let measurementFrame = false, capId = 0;
 function queueMeasurement(el) {
+  if (!measurements.has(el)) return;
   measurementQueue.add(el);
   if (measurementFrame) return;
   measurementFrame = true;
@@ -50,6 +51,7 @@ function measureChanges(el, update) {
 }
 function releaseMeasurements(root) {
   for (const el of [root, ...(root.querySelectorAll?.('*') || [])]) {
+    observer?.unobserve(el); pending.delete(el);
     sizeObserver?.unobserve(el); contentObservers.get(el)?.disconnect();
     contentObservers.delete(el); measurements.delete(el); measurementQueue.delete(el);
   }
@@ -249,11 +251,13 @@ export function cleanOutputBlocks(container) {
 // Covers generic/legacy cards and request builders which assign pre.textContent
 // directly. Observe each transcript once; our own writes settle after one pass.
 export function observeOutputBlocks(container) {
-  if (!container || watched.has(container) || typeof MutationObserver !== 'function') return;
-  watched.add(container);
+  if (!container || typeof MutationObserver !== 'function') return;
+  if (watched.has(container)) return watched.get(container);
   let queued = false;
+  let disposed = false;
   const dirty = new Set();
   const watcher = new MutationObserver(records => {
+    if (disposed) return;
     for (const record of records) {
       for (const removed of record.removedNodes || []) if (removed.nodeType === 1 && !removed.isConnected) releaseMeasurements(removed);
       const target = record.target.nodeType === 1 ? record.target : record.target.parentElement;
@@ -265,6 +269,7 @@ export function observeOutputBlocks(container) {
     queued = true;
     queueMicrotask(() => {
       queued = false;
+      if (disposed) return;
       for (const root of dirty) {
         if (root.matches?.('pre, .cxp-card-pre') && !root.closest('.cxp-readable, .cxp-output-source, .cxp-diff-view') && !root.querySelector('.cxp-readable')) {
           const code = root.querySelector('code');
@@ -276,6 +281,24 @@ export function observeOutputBlocks(container) {
     });
   });
   watcher.observe(container, { childList: true, characterData: true, subtree: true });
+  const dispose = () => {
+    disposed = true;
+    watcher.disconnect();
+    dirty.clear();
+    watched.delete(container);
+    releaseMeasurements(container);
+  };
+  watched.set(container, dispose);
+  return dispose;
+}
+
+// Removing a whole transcript does not produce a mutation *inside* it. Both
+// global observers must release its outputs and lazy diffs explicitly on close.
+export function disposeOutputBlocks(container) {
+  if (!container) return;
+  const dispose = watched.get(container);
+  if (dispose) dispose();
+  else releaseMeasurements(container);
 }
 
 function diffRows(file, target, count) {