synabun 2.1.0 → 2.2.1

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-style-cache.js

@@ -0,0 +1,44 @@
+// ═══════════════════════════════════════════
+// SynaBun Assistant — computed styles read once
+// ═══════════════════════════════════════════
+// A value the stylesheet decides and the renderer needs on a hot path (the
+// rack's --rk-cut, where a long subject is cut; its bubble line's
+// white-space), read once and kept until the renderer says it may have
+// changed. getComputedStyle() on a frame's path forces a style recalculation
+// of everything the frame dirtied (a rig's SVG, a scene); these values change
+// only when a container query flips, which happens only when the stage's width
+// changes, and the renderer's ResizeObserver sees every such change and calls
+// invalidate().
+//
+//   createStyleCache({ read }?) → { get(el, prop), invalidate(el?), reads() }
+//
+// `read(el, prop)` defaults to getComputedStyle(el).getPropertyValue(prop)
+// (trimmed); a read that throws counts as ''. DOM-free: tested in Node.
+
+const defaultRead = (el, prop) => globalThis.getComputedStyle(el).getPropertyValue(prop);
+
+export function createStyleCache({ read = defaultRead } = {}) {
+  let values = new WeakMap(); // element → Map(prop → value)
+  let count = 0;
+  return {
+    /** The element's computed `prop` (a custom property or a longhand), read once until invalidated. */
+    get(el, prop) {
+      if (!el) return '';
+      let props = values.get(el);
+      if (!props) { props = new Map(); values.set(el, props); }
+      if (props.has(prop)) return props.get(prop);
+      count += 1;
+      let value = '';
+      try { value = String(read(el, prop) ?? '').trim(); } catch { value = ''; }
+      props.set(prop, value);
+      return value;
+    },
+    /** Forget one element's values, or every value (no argument). */
+    invalidate(el) {
+      if (el) values.delete(el);
+      else values = new WeakMap();
+    },
+    /** How many real reads were made (tests, the idle-CPU suite). */
+    reads: () => count,
+  };
+}

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

@@ -252,9 +252,13 @@ export function injectAssistantStyles() {
     .asst-count.attention { color: var(--asst-warn); box-shadow: inset 0 0 0 1px var(--asst-pill-warn-ring); }
     /* The running cameo: the mascot's two pill eyes, glancing ±1.2px every 1.4s.
        One form everywhere (the header status, the tray pill, run pills):
-       mascotCameoSvg() from synabun-mascot.js, a 10×7 SVG. */
+       mascotCameoSvg() from synabun-mascot.js, a 10×7 SVG in two spans. The
+       glance moves the HTML box around the eyes (.syna-cameo-eyes), along the
+       pair's −12° lean (1.2 of the SVG's 10×7 units: 11.738% and 3.564% of the
+       box), never a part of the SVG: a box's transform runs on the compositor,
+       and a frame the page draws anyway restyles one span and lays nothing out. */
     .syna-cameo { display: inline-block; flex-shrink: 0; overflow: visible; color: var(--asst-brand); }
-    .syna-cameo-eye { transform-box: fill-box; animation: asst-cameo 2.8s var(--asst-ease-emphasized) infinite; }
+    .syna-cameo-eyes { display: block; animation: asst-cameo 2.8s var(--asst-ease-emphasized) infinite; }
 
     /* ── Toolbar: flush under the terminal tabs ─────────────────────────
        Edge to edge like the tab bar above it (same hairline), no card and no
@@ -1088,6 +1092,8 @@ export function injectAssistantStyles() {
       border-radius: 50%;
       animation: asst-spin .8s linear infinite;
     }
+    /* A spinner nobody can see never runs (a hidden holder still restyles a running loop every frame). */
+    [hidden] .asst-spinner, .asst-spinner[hidden], [inert] .asst-spinner { animation: none; }
     .asst-computer-activity { display: flex; align-items: center; gap: 10px; min-height: 44px; padding: 7px 8px 7px 12px; border-bottom: 1px solid var(--asst-line); }
     .asst-live-dot { width: 6px; height: 6px; flex-shrink: 0; border-radius: 50%; background: var(--asst-live); animation: asst-live 1.4s var(--asst-ease-standard) infinite; }
     .asst-computer-activity[data-state="paused_user"] .asst-live-dot { background: var(--asst-warn); animation: none; }
@@ -1368,6 +1374,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;
@@ -2029,10 +2069,24 @@ export function injectAssistantStyles() {
        whole Assistant holds still: the component, its menus and modals, the
        sidepanel frame and its header (.asp-*), and the tray pills. */
     @keyframes asst-live { 0%, 100% { opacity: 1; transform: scale(1); } 50% { opacity: .35; transform: scale(.8); } }
-    @keyframes asst-cameo { 0%, 42% { transform: translateX(-1.2px); } 50%, 92% { transform: translateX(1.2px); } 100% { transform: translateX(-1.2px); } }
+    @keyframes asst-cameo { 0%, 42% { transform: translate(-11.738%, 3.564%); } 50%, 92% { transform: translate(11.738%, -3.564%); } 100% { transform: translate(-11.738%, 3.564%); } }
     @keyframes asst-spin { to { transform: rotate(360deg); } }
 
-    body.ui-interacting :is(.asst-live-dot, .asst-spinner, .asst-computer-dot, .syna-cameo-eye) { animation-play-state: paused !important; }
+    /* A moving box gets its layer up front (only where motion is allowed; nothing is promoted under reduced motion). */
+    @media (prefers-reduced-motion: no-preference) {
+      .syna-cameo-eyes { will-change: transform; }
+    }
+
+    body.ui-interacting :is(.asst-live-dot, .asst-spinner, .asst-computer-dot, .syna-cameo-eyes) { animation-play-state: paused !important; }
+
+    /* Off screen, nothing loops. A holder the renderer saw leave the viewport (asst-motion-gate.js marks it
+       data-offscreen: a run card, a rack or a route line scrolled out of its transcript) and a closed side
+       panel (it stays in the page, moved out and faded: .assistant-panel without .open) pause every loop
+       under them; each picks up where it stopped when it is back. Every frame the page draws restyles each
+       running animation, composited or not, so a loop nobody sees is never free. */
+    [data-offscreen], [data-offscreen]::before, [data-offscreen]::after,
+    [data-offscreen] *, [data-offscreen] *::before, [data-offscreen] *::after,
+    .assistant-panel:not(.open) *, .assistant-panel:not(.open) *::before, .assistant-panel:not(.open) *::after { animation-play-state: paused !important; }
     body.ui-interacting .asst-route-line[data-live] .asst-route-icon,
     body.ui-interacting .asst-route-line[data-live] .asst-route-sweep::after { animation-play-state: paused !important; }
 

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) {

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

@@ -1,3 +1,5 @@
+import { syncWorkerQuestions } from '../worker-questions.js';
+import { handleServerRequest, resolveRequestCard } from './cdx-requests.js';
 import { cxpText, cxpSessionLabel, setCodexTranslator } from './cdx-copy.js';
 // SynaBun — Codex Panel: DOM, Events & Lifecycle
 // ═══════════════════════════════════════════
@@ -808,6 +810,7 @@ function wireEvents() {
     try {
       const statusResponse = await fetch(`/api/git/status?path=${encodeURIComponent(project)}`);
       const status = statusResponse.ok ? await statusResponse.json() : null;
+      if (!status?.ok || !status.isGit || status.partial || status.stale || status.timedOut) throw new Error(status?.error || 'Git status is incomplete. Refresh before switching branches.');
       if (status?.changes?.length) {
         const confirmed = window.confirm(`Switch from ${previous || 'the current branch'} to ${branch} with ${status.changes.length} uncommitted change${status.changes.length === 1 ? '' : 's'}? Git will preserve them when possible.`);
         if (!confirmed) {
@@ -927,11 +930,12 @@ function wireEvents() {
 
 
   on('codex-panel:show', async (data) => {
-    setVisible(true);
     if (data?.tabId) {
       const idx = _tabs.findIndex((entry) => entry.id === data.tabId);
       if (idx >= 0) switchTab(idx);
     }
+    setVisible(true);
+    ensureProjectsLoaded().catch(() => {});
   });
 
   const findPlanEditorTab = ({ source, tabId, planId, accountId, threadId } = {}) => {
@@ -1108,8 +1112,8 @@ export async function toggleCodexPanel() {
     setVisible(false);
     return;
   }
-  await ensureProjectsLoaded();
   setVisible(true);
+  await ensureProjectsLoaded();
 }
 
 export async function attachCodexAutomation(run, {
@@ -1188,6 +1192,14 @@ export async function attachCodexAutomation(run, {
     tab._automationLifecycleError = run.error;
     withTab(tab, () => appendSystem(run.error, 'error'));
   }
+  withTab(tab, () => syncWorkerQuestions(tab, run, {
+    open: (id, pending) => handleServerRequest({ requestId: id, method: pending.protocol?.method, params: pending.input || {}, threadId }),
+    close: (id) => {
+      resolveRequestCard(id, t('workerQuestion.resolved'));
+      tab.heldServerRequests?.delete(String(id));
+      tab.blockingServerRequests?.delete(String(id));
+    },
+  }));
   trackWorkerEnd(run, { apply: (view) => { tab._workerEnd = view; placeWorkerEnd(tab); } });
   saveTabs();
   renderPills();

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

@@ -0,0 +1,12 @@
+// The early Codex rollout preview (server.js sendEarlyCodexRolloutPreview): DOM-free decisions.
+
+/** A bootstrap asks for the preview only for a saved thread of the tab on screen. */
+export function codexWantsRolloutPreview(tab, shownTab, threadId) {
+  return !!threadId && !!tab && tab === shownTab;
+}
+
+/** A preview paints only for the thread shown, and only while nothing else (a stored snapshot) is on screen. */
+export function rolloutPreviewApplies(msg, shownThread, transcriptSourceType) {
+  const previewFor = String(msg?.threadId || msg?.thread?.id || '');
+  return !transcriptSourceType && !!previewFor && previewFor === String(shownThread || '');
+}