synabun 2.1.0 → 2.2.0

package/neural-interface/public/shared/agy/agy-tabs-logic.js

@@ -0,0 +1,181 @@
+// ═══════════════════════════════════════════
+// SynaBun — Antigravity panel: tabs, attachments and dispatched-run events (no DOM)
+// ═══════════════════════════════════════════
+//
+// A tab is one ACP session of Antigravity's in one project folder. What is saved
+// per window (`synabun-antigravity-panel-tabs-<windowId>`, read by the side panel
+// tray too) is `{ tabs, activeIdx }` with the fields below; the transcript is not
+// saved: a tab with a session id replays it from Antigravity (session/load).
+// `bypass` is the tab's Bypass (agy-bypass.js): off unless the owner turned it on.
+
+export const TAB_FIELDS = Object.freeze(['id', 'sessionId', 'project', 'geminiDir', 'label', 'title', 'titleByUser', 'additionalDirectories', 'draft',
+  'running', 'needsYou', 'automationRunId', 'automationActive', 'automationOwnerId', 'releasedRunId', 'createdAt', 'bypass']);
+export const MAX_TABS = 12;
+export const ATTACH_LIMITS = Object.freeze({ maxAttachments: 8, maxBytes: 15 * 1024 * 1024 });
+const ATTACHABLE = /^(image\/(png|jpeg|gif|webp)|application\/pdf|text\/[a-z0-9.+-]+|application\/(json|xml|x-yaml|yaml)|audio\/(wav|x-wav|mpeg|mp4|aac|flac|ogg|opus|webm))$/;
+const TEXT_EXTENSIONS = /\.(txt|md|markdown|json|ya?ml|xml|csv|log|js|mjs|cjs|ts|tsx|jsx|py|rb|go|rs|java|kt|swift|c|cc|cpp|h|hpp|cs|php|sh|zsh|bash|css|scss|html|sql|toml|ini|env)$/i;
+
+let counter = 0;
+const newId = () => (globalThis.crypto?.randomUUID?.() || `agy-${Date.now().toString(36)}-${(counter += 1)}`);
+
+export function newTab({ project = '', sessionId = null, title = null, geminiDir = null } = {}) {
+  return {
+    id: newId(), sessionId, project: String(project || ''), geminiDir: typeof geminiDir === 'string' && geminiDir.trim() ? geminiDir.trim() : null,
+    label: 'New session', title, titleByUser: null, additionalDirectories: [], draft: '',
+    running: false, needsYou: false, automationRunId: null, automationActive: false, automationOwnerId: null,
+    releasedRunId: null, createdAt: Date.now(), bypass: false,
+  };
+}
+
+/**
+ * What the tray and the panel show for a tab: its session's title, else a short id, else "New session". `words`
+ * gives the page's language for the last three (the saved label stays English when none is given).
+ */
+export function tabLabel(tab, words = {}) {
+  const title = typeof tab?.title === 'string' ? tab.title.trim() : '';
+  if (title) return title.length > 60 ? `${title.slice(0, 57)}…` : title;
+  if (tab?.automationRunId) return `${words.run || 'Dispatched run'} · ${String(tab.automationRunId).slice(0, 8)}`;
+  if (tab?.sessionId) return `Antigravity · ${String(tab.sessionId).slice(0, 8)}`;
+  return words.newSession || 'New session';
+}
+
+/** The saved form: `{ tabs, activeIdx }`, each tab its persisted fields only. */
+export function serializeTabs(tabs, activeIdx) {
+  const list = (Array.isArray(tabs) ? tabs : []).slice(0, MAX_TABS).map((tab) => {
+    const out = {};
+    for (const key of TAB_FIELDS) if (tab?.[key] !== undefined) out[key] = tab[key];
+    out.label = tabLabel(tab);
+    return out;
+  });
+  const idx = Number.isInteger(activeIdx) ? Math.min(Math.max(activeIdx, 0), Math.max(list.length - 1, 0)) : 0;
+  return { tabs: list, activeIdx: idx };
+}
+
+/**
+ * Saved tabs as the panel restores them: invalid rows dropped, nothing marked running (the page that ran it is
+ * gone: a live run is reattached by the native-loop router, not by a flag), an id for every tab.
+ */
+export function restoreTabs(raw) {
+  let data = raw;
+  if (typeof raw === 'string') { try { data = JSON.parse(raw); } catch { data = null; } }
+  const rows = Array.isArray(data?.tabs) ? data.tabs : [];
+  const tabs = [];
+  const seen = new Set();
+  for (const row of rows) {
+    if (!row || typeof row !== 'object') continue;
+    const tab = { ...newTab(), ...Object.fromEntries(TAB_FIELDS.filter((key) => row[key] !== undefined).map((key) => [key, row[key]])) };
+    if (typeof tab.id !== 'string' || !tab.id || seen.has(tab.id)) tab.id = newId();
+    seen.add(tab.id);
+    if (tab.sessionId !== null && (typeof tab.sessionId !== 'string' || !/^[A-Za-z0-9._:@-]{1,200}$/.test(tab.sessionId))) tab.sessionId = null;
+    tab.project = typeof tab.project === 'string' ? tab.project : '';
+    tab.geminiDir = typeof tab.geminiDir === 'string' && tab.geminiDir.trim() ? tab.geminiDir.trim() : null;
+    tab.draft = typeof tab.draft === 'string' ? tab.draft : '';
+    tab.titleByUser = typeof tab.titleByUser === 'string' && tab.titleByUser.trim() ? tab.titleByUser.trim().slice(0, 120) : null;
+    tab.additionalDirectories = Array.isArray(tab.additionalDirectories)
+      ? [...new Set(tab.additionalDirectories.filter((p) => typeof p === 'string' && p && p !== tab.project))].slice(0, 8)
+      : [];
+    // Bypass comes back only as the owner's own pick (a literal true), never from anything else in storage.
+    tab.bypass = tab.bypass === true;
+    tab.running = false;
+    tab.needsYou = false;
+    tabs.push(tab);
+    if (tabs.length >= MAX_TABS) break;
+  }
+  const activeIdx = Number.isInteger(data?.activeIdx) && data.activeIdx >= 0 && data.activeIdx < tabs.length ? data.activeIdx : 0;
+  return { tabs, activeIdx };
+}
+
+/** The MIME type a dropped or pasted file is sent as (a browser leaves it empty for many text files). */
+export function attachmentType(file) {
+  const declared = String(file?.type || '').toLowerCase();
+  if (declared) return declared;
+  return TEXT_EXTENSIONS.test(String(file?.name || '')) ? 'text/plain' : '';
+}
+
+/** Whether a file may be attached now: null when it may, else { key, params } for agyText. */
+export function attachmentProblem(file, staged = [], limits = ATTACH_LIMITS) {
+  const name = String(file?.name || 'file');
+  if (staged.length >= limits.maxAttachments) return { key: 'attachmentTooMany', params: { count: limits.maxAttachments } };
+  if (!ATTACHABLE.test(attachmentType(file))) return { key: 'attachmentType', params: { name } };
+  if (Number(file?.size) > limits.maxBytes) return { key: 'attachmentTooLarge', params: { name, size: Math.round(limits.maxBytes / 1048576) } };
+  return null;
+}
+
+/**
+ * A picture another part of the app hands the panel (the whiteboard's Send to Panel, also through a detached window)
+ * as a staged attachment: `{ file: { name, mimeType, dataUrl } }`, `{ problem: { key, params } }` when it may not
+ * be attached now (the same limits as a pasted file), or null when it is not a PNG, JPEG, GIF or WebP data URL.
+ */
+export function stagedPicture(dataUrl, staged = [], { name = 'whiteboard', now = Date.now(), limits = ATTACH_LIMITS } = {}) {
+  const match = /^data:(image\/(png|jpeg|gif|webp));base64,([A-Za-z0-9+/]+={0,2})$/.exec(String(dataUrl || ''));
+  if (!match) return null;
+  const body = match[3];
+  const size = Math.floor((body.length * 3) / 4) - (body.endsWith('==') ? 2 : body.endsWith('=') ? 1 : 0);
+  const file = { name: `${name}-${now}.${match[2] === 'jpeg' ? 'jpg' : match[2]}`, type: match[1], size };
+  const problem = attachmentProblem(file, staged, limits);
+  return problem ? { problem } : { file: { name: file.name, mimeType: match[1], dataUrl } };
+}
+
+/** A data URL's base64 body, or '' for anything else. */
+export function base64Of(dataUrl) {
+  const match = /^data:[^;,]*(?:;[^;,]*)*;base64,([A-Za-z0-9+/]+={0,2})$/.exec(String(dataUrl || ''));
+  return match ? match[1] : '';
+}
+
+/** The bridge's `prompt` request for a tab: its text and staged attachments ({ name, mimeType, dataUrl }). */
+export function promptRequest(tab, text, staged = []) {
+  return {
+    sessionId: tab.sessionId,
+    text: String(text || ''),
+    attachments: staged.map((file) => ({ name: file.name, mimeType: file.mimeType, data: base64Of(file.dataUrl) })).filter((file) => file.data),
+    paths: staged.filter((file) => file.path).map((file) => file.path),
+  };
+}
+
+/**
+ * One event of a dispatched run (the native-loop router's `sync:sidepanel:provider-event` payload, or its `event`)
+ * as what the transcript does with it: { kind: 'user', text, iteration } | { kind: 'update', update } |
+ * { kind: 'notice', text, severity } | null.
+ */
+export function automationEvent(payload) {
+  const message = payload?.event && typeof payload.event === 'object' && (payload.eventType || payload.provider) ? payload : (payload?.event || payload);
+  const eventType = message?.eventType || message?.event?.type || message?.type;
+  const event = message?.event ?? message;
+  if (!event || typeof event !== 'object') return null;
+  if (event.type === 'synabun.user_prompt' || eventType === 'synabun.user_prompt') return { kind: 'user', text: String(event.text || ''), iteration: message.iteration ?? null };
+  if (event.type === 'synabun.confinement') return { kind: 'notice', text: `${event.action === 'warned' ? 'Guard warning' : 'Refused'}: ${event.reason || event.rule || ''}`.trim(), severity: event.action === 'warned' ? 'warning' : 'error' };
+  if (event.type === 'synabun.provider_exit') return { kind: 'notice', text: `Antigravity stopped${event.error ? `: ${event.error}` : ''}`, severity: 'error' };
+  if (event.type === 'synabun.error') return { kind: 'notice', text: String(event.message || event.error || 'Error'), severity: 'error' };
+  if (typeof event.sessionUpdate === 'string') return { kind: 'update', update: event };
+  return null;
+}
+
+/** The per-run Antigravity home (`--gemini-dir`) a dispatched run executed in, or null when none is named. */
+export function runGeminiDir(run) {
+  const raw = run?.antigravityHome ?? run?.geminiDir ?? run?.resumeInfo?.antigravityHome ?? run?.runtime?.antigravityHome ?? null;
+  return typeof raw === 'string' && raw.trim() ? raw.trim() : null;
+}
+
+/** The bridge request (`session:load` or `session:resume`) that opens an existing tab's session in the panel. */
+export function openSessionRequest(tab, { resume = false, folders = [] } = {}) {
+  const dirs = Array.isArray(folders) ? folders.filter((p) => typeof p === 'string' && p) : [];
+  const geminiDir = typeof tab?.geminiDir === 'string' && tab.geminiDir ? tab.geminiDir : null;
+  return {
+    type: resume ? 'session:resume' : 'session:load',
+    payload: {
+      sessionId: tab.sessionId,
+      cwd: tab.project,
+      tabId: tab.id,
+      bypass: tab?.bypass === true,
+      ...(geminiDir ? { geminiDir } : {}),
+      ...(dirs.length ? { additionalDirectories: dirs } : {}),
+    },
+  };
+}
+
+/** The notice shown when loading or resuming a tab's session fails (null when sign-in handles it instead). */
+export function sessionLoadNotice(error, textOf) {
+  if (error?.authRequired) return null;
+  if (error?.code === 'HOME_PRUNED') return { text: textOf('runHomePruned'), severity: 'error' };
+  return { text: textOf('historyFailed', { error: error?.message || String(error ?? '') }), severity: 'error' };
+}

package/neural-interface/public/shared/api.js

@@ -881,15 +881,15 @@ export async function fetchOpencodeSessions({ project, limit, offset, search } =
   return jsonFetch(`/api/opencode/sessions?${params}`);
 }
 
-// ─── Gemini CLI Sessions (Resume) ─────
+// ─── Antigravity CLI Sessions (Resume) ─────
 
-export async function fetchGeminiSessions({ project, limit, offset, search } = {}) {
+export async function fetchAntigravitySessions({ project, limit, offset, search } = {}) {
   const params = new URLSearchParams();
   if (project) params.set('project', project);
   if (limit) params.set('limit', String(limit));
   if (offset) params.set('offset', String(offset));
   if (search) params.set('search', search);
-  return jsonFetch(`/api/gemini/sessions?${params}`);
+  return jsonFetch(`/api/antigravity/sessions?${params}`);
 }
 
 // ─── Hybrid session content search (FTS5 + semantic for Claude) ─────
@@ -1143,7 +1143,7 @@ export async function fetchRulesStatus() {
   }
 }
 
-/** The rendered text for a host (claude, codex, opencode, gemini, cursor) or the copy-only `coexistence` snippet. */
+/** The rendered text for a host (claude, codex, opencode, antigravity, cursor) or the copy-only `coexistence` snippet. */
 export async function fetchRulesText(host) {
   return jsonFetch(`/api/setup/rules/${encodeURIComponent(host)}/text`);
 }

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

@@ -23,13 +23,12 @@
 // last card, so one stray click or key there must not end the session's work.
 
 import { on } from '../state.js';
-import { getProviderMeta } from '../provider-icons.js';
 import { listAssistantRuns } from './asst-api.js';
 import { buildRunCard, tickRunCard, updateRunCard } from './asst-render.js';
 import { awaitsAnswer, compactActivity, isLivePhase, phaseLine, sceneFor, sceneSvg, stageLabel, stagePhase, stepLine } from './asst-scenes.js';
 import { injectSceneStyles } from './asst-scene-styles.js';
 import { plural } from './asst-tool-kinds.js';
-import { isRemovableRun, isRunIdle, isTerminalRunStatus, mergeRunDescriptor, runFromPayload, runNeedsAttention, sortRuns } from './asst-state.js';
+import { isRemovableRun, isRunIdle, isTerminalRunStatus, mergeRunDescriptor, providerMeta, runFromPayload, runNeedsAttention, sortRuns } from './asst-state.js';
 import { createConfirmGate } from './asst-stop.js';
 
 const TICK_MS = 5000;
@@ -166,8 +165,8 @@ export function createAgentsDock(hostEl, hooks = {}) {
     return {
       t: hooks.t,
       compact: true,
-      providerIcon: (p) => getProviderMeta(p).icon,
-      providerColor: (p) => getProviderMeta(p).color,
+      providerIcon: (p) => providerMeta(p).icon,
+      providerColor: (p) => providerMeta(p).color,
       onFocus: hooks.onFocus,
       onStop: hooks.onStop,
       onRead: hooks.onRead,

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

@@ -48,7 +48,7 @@ export function fetchAssistantCatalog({ force = false } = {}) {
 
 // ── Hidden models (Assistant → Models) ───────
 
-/** → { ok, providers: { 'claude-code': [], codex: [], opencode: [] } } */
+/** → { ok, providers: { 'claude-code': [], codex: [], opencode: [], antigravity: [] } } */
 export function getHiddenModelLists() {
   return jsonFetch('/api/assistant/hidden-models');
 }

package/neural-interface/public/shared/assistant/asst-brain-picker.js

@@ -42,6 +42,7 @@ import { createMascotControl } from './asst-mascot.js';
 import { modelChipForms, modelChipName, modelChipTag } from './asst-model-chip.js';
 import {
   ACCOUNT_PROVIDERS,
+  BRAIN_PROVIDERS,
   brainRequiresSwitch,
   emptyProjectView,
   modelShortName,
@@ -50,6 +51,7 @@ import {
   PLAN_MODE_PROVIDERS,
   permissionModeLabel,
   PROVIDERS,
+  providerMeta,
   projectLabel,
   resolveBrainDefaults,
   TEST_DENSITIES,
@@ -113,6 +115,7 @@ const PLAN_DESC = {
   'claude-code': 'Plan first; approving the plan continues in the approval mode below',
   codex: 'Native Codex plan mode (read-only sandbox)',
   opencode: 'OpenCode plan agent (no file edits)',
+  antigravity: 'Antigravity explores and proposes a plan; code changes wait for your approval',
 };
 
 function agentName(agent) {
@@ -194,7 +197,7 @@ function hiddenOpencodeIds(remote) {
 }
 
 // The models the user hid (Assistant → Models), per provider, as the last catalog load saw them.
-let _hidden = { 'claude-code': new Set(), codex: new Set(), opencode: new Set() };
+let _hidden = { 'claude-code': new Set(), codex: new Set(), opencode: new Set(), antigravity: new Set() };
 
 function hiddenSets(remote) {
   const out = {};
@@ -295,7 +298,7 @@ function catalogSaysNone(remote, provider, local) {
 }
 
 /**
- * { 'claude-code': [...], codex: [...], opencode: [...] }: the models of every
+ * { 'claude-code': [...], codex: [...], opencode: [...], antigravity: [...] }: the models of every
  * Assistant model menu and of the Routes editor, from GET /api/assistant/catalog
  * (see mergeProviderModels). Models the user hid (Assistant → Models, and
  * Settings → OpenCode for OpenCode) never appear. `force` asks the server for a
@@ -316,6 +319,7 @@ export async function loadModelCatalog({ force = false } = {}) {
     // No catalog (request failed): the last known disabled lists still apply.
     const sets = remote ? hiddenSets(remote) : { ..._hidden, opencode: new Set([...(_hidden.opencode || []), ...hiddenOpencodeIds(null)]) };
     _hidden = sets;
+    if (remote?.providers) _providerInfo = remote.providers;
     for (const provider of PROVIDERS) {
       const local = getModelsForProfile(provider) || [];
       // An empty list the catalog vouches for is its answer: the window's own rows do not stand in for it.
@@ -366,6 +370,33 @@ function keepCatalog(catalog, sets) {
 /** The last loadModelCatalog() result, synchronously (null before the first load). */
 export function cachedModelCatalog() { return _catalog; }
 
+// The catalog's provider entries ([{ id, brain, accounts, priced, signedIn?, tier? }]) as the last load saw them:
+// Antigravity's sign-in state is read from there (it signs in inside its own CLI; SynaBun keeps no account of it).
+let _providerInfo = null;
+
+/** One provider's catalog entry ({ id, brain, signedIn?, tier?, … }), from an array or a map; null when unknown. */
+export function catalogProviderInfo(provider, providers = _providerInfo) {
+  if (!provider || !providers) return null;
+  if (Array.isArray(providers)) return providers.find(p => p && p.id === provider) || null;
+  const entry = providers[provider];
+  return entry && typeof entry === 'object' ? entry : null;
+}
+
+/**
+ * What the model menu and the model chip say about Antigravity's sign-in (`info`: its catalog entry):
+ * { state: 'signedIn' | 'signedOut' | 'unknown', text }. Antigravity signs in with Google inside its own panel;
+ * the tier is the plan its session reported ("Google AI Pro").
+ */
+export function antigravitySignInView(info, t = null) {
+  const tr = tf(t);
+  const tier = typeof info?.tier === 'string' && info.tier.trim() ? info.tier.trim() : (typeof info?.tier?.name === 'string' ? info.tier.name.trim() : '');
+  if (info?.signedIn === true) {
+    return { state: 'signedIn', text: tier ? tr('assistant.brain.antigravitySignedInTier', 'Signed in with Google ({tier})', { tier }) : tr('assistant.brain.antigravitySignedIn', 'Signed in with Google') };
+  }
+  if (info?.signedIn === false) return { state: 'signedOut', text: tr('assistant.brain.antigravitySignedOut', 'Not signed in: open the Antigravity panel to sign in') };
+  return { state: 'unknown', text: tr('assistant.brain.antigravitySignInUnknown', 'Sign-in not checked yet: Antigravity signs in inside its own panel') };
+}
+
 /** UI metadata from the same catalog load; no second list or extra endpoint. */
 export function modelCatalogStatus() {
   return { partial: _catalogPartial, hiddenCounts: Object.fromEntries(PROVIDERS.map(provider => [provider, _hidden[provider]?.size || 0])) };
@@ -474,7 +505,8 @@ function tierTag(m, tr) {
 /**
  * Model menu grouped by provider, filterable, with "Custom model id…".
  * opts: { brain, onSelect(target), includeHere, hereLabel, title, t, placement,
- *         current:{provider, model}|null, warnSwitch, providers, onToast(text),
+ *         current:{provider, model}|null, warnSwitch, providers (default: the brain
+ *         providers, so a worker-only one is listed only when named), onToast(text),
  *         accept(provider, model) → bool (only those models), emptyLabel (when none
  *         passes), allowCustom (default true), zIndex (see asst-menu.js),
  *         accountItems (menu items listed first, under accountTitle) }
@@ -546,13 +578,15 @@ export async function openModelMenu(anchor, opts = {}) {
     if (includeHere) {
       items.push({ kind: 'radio', id: '__here', label: hereLabel || tr('assistant.routes.brainDecides', 'Let the brain decide'), selected: !current, onSelect: () => onSelect?.({ here: true }) });
     }
-    const list = Array.isArray(providers) && providers.length ? PROVIDERS.filter(p => providers.includes(p)) : PROVIDERS;
+    // Without `providers` the menu is a brain's (the toolbar's model field, the WhatsApp brain): every provider the
+    // Assistant can run on (BRAIN_PROVIDERS, Antigravity included); a route or a dispatch names its own providers.
+    const list = Array.isArray(providers) && providers.length ? PROVIDERS.filter(p => providers.includes(p)) : BRAIN_PROVIDERS;
     let listed = 0;
     for (const provider of list) {
       const models = (catalog[provider] || []).filter(m => typeof accept !== 'function' || accept(provider, m));
       if (!models.length && !opts.routingEditor) continue;
       listed += models.length;
-      const meta = getProviderMeta(provider);
+      const meta = providerMeta(provider);
       const hiddenCount = metadata.hiddenCounts[provider] || 0;
       const note = opts.routingEditor ? tr('assistant.routes.menu.hiddenCount', '{count} hidden in Models', { count: hiddenCount }) : warnSwitch && provider !== b.provider ? tr('assistant.brain.newConversation', 'starts a new conversation') : '';
       items.push({ kind: 'header', label: meta.label, icon: meta.icon, color: meta.color, note });
@@ -780,6 +814,8 @@ export function createBrainPicker(host, hooks = {}) {
   // The composer chip's account cue: the account menu's initial avatar when the provider has more than one
   // account (or the account is signed out), "Auto" for Auto; null otherwise. Its full words are the tooltip's.
   function accountCue(brain) {
+    // Antigravity signed out: a warning cue on the chip (its words are the tooltip's and the Model menu's).
+    if (brain.provider === 'antigravity') return catalogProviderInfo('antigravity')?.signedIn === false ? { text: '!', tone: 'warn' } : null;
     if (!ACCOUNT_PROVIDERS.has(brain.provider)) return null;
     if (brain.accountId === 'auto') return { text: t('assistant.brain.accountAutoShort', 'Auto'), tone: 'muted' };
     const accounts = brain.provider === 'codex' ? getCachedCodexAccounts() : getCachedClaudeAccounts();
@@ -804,7 +840,8 @@ export function createBrainPicker(host, hooks = {}) {
       effortSupported: brain.provider === 'opencode' || hasEfforts,
       effort: brain.provider === 'opencode'
         ? (brain.agent || t('assistant.brain.agentDefault', 'default'))
-        : (level ? level.label : (brain.effort || t('assistant.brain.effortOff', 'off'))),
+        // Antigravity has no "off" level: no level is the model's own default ("Default").
+        : (level ? level.label : (brain.effort || (brain.provider === 'antigravity' ? (efforts.find(e => e.id === 'off')?.label || t('assistant.brain.effortOff', 'off')) : t('assistant.brain.effortOff', 'off')))),
       variantSupported: brain.provider === 'opencode' && hasEfforts,
       variant: level ? level.label : (brain.effort || t('assistant.brain.variantDefault', 'default variant')),
       project: brain.project ? projectLabel(brain.project, _projectsCache || []) : t('assistant.brain.projectHome', 'Home'),
@@ -888,6 +925,7 @@ export function createBrainPicker(host, hooks = {}) {
     const tip = [
       v.meta.label, model, who ? t('assistant.brain.asAccount', 'as {account}', { account: who }) : '',
       acc ? accountIdentity(acc) : '', acc ? accountBadge(acc, p).text : '',
+      brain.provider === 'antigravity' ? antigravitySignInView(catalogProviderInfo('antigravity'), hooks.t).text : '',
     ].filter(Boolean).join(' · ');
     setBtn('model', { label: '', icon: v.meta.icon, color: v.meta.color, tooltip: tip, aria: `${t('assistant.brain.model', 'Model')}: ${tip}` });
 
@@ -1111,10 +1149,12 @@ export function createBrainPicker(host, hooks = {}) {
     const brain = currentBrain();
     if (field === 'model') {
       // The account rows come from the kept lists; they are read again in the background once loaded.
-      if (ACCOUNT_PROVIDERS.has(brain.provider)) {
+      // Antigravity has no SynaBun account: its sign-in state comes with the catalog.
+      if (ACCOUNT_PROVIDERS.has(brain.provider) || brain.provider === 'antigravity') {
         if (_warmProviders.has(brain.provider)) ensureLoaded(brain.provider).catch(() => {});
         else await ensureLoaded(brain.provider);
       }
+      const antigravity = brain.provider === 'antigravity';
       await openModelMenu(anchor, {
         brain,
         shouldOpen,
@@ -1122,8 +1162,8 @@ export function createBrainPicker(host, hooks = {}) {
         placement,
         current: { provider: brain.provider, model: brain.model },
         warnSwitch: true,
-        accountItems: ACCOUNT_PROVIDERS.has(brain.provider) ? accountItems(brain) : [],
-        accountTitle: accountText('menuTitle', {}, accountProvider(brain)),
+        accountItems: ACCOUNT_PROVIDERS.has(brain.provider) ? accountItems(brain) : antigravity ? antigravitySignInItems() : [],
+        accountTitle: antigravity ? t('assistant.brain.antigravitySignIn', 'Antigravity sign-in') : accountText('menuTitle', {}, accountProvider(brain)),
         onToast: hooks.onToast,
         onManageModels: hooks.onManageModels,
         onSelect: (target) => {
@@ -1298,6 +1338,12 @@ export function createBrainPicker(host, hooks = {}) {
     };
   }
 
+  // Antigravity's place for accounts in the Model menu: its sign-in state, one line (antigravitySignInView).
+  function antigravitySignInItems() {
+    const view = antigravitySignInView(catalogProviderInfo('antigravity'), hooks.t);
+    return [{ kind: 'info', id: '__antigravity_signin', label: view.text, className: `asst-agy-signin asst-agy-signin-${view.state}` }];
+  }
+
   // The composer's Model menu lists the brain's accounts too (Claude or Codex), as the cog's account menu
   // does (asst-account-menu.js): Auto, every account once (a signed-out one opens its sign-in), the Uses
   // switch of an account holding both credentials, Add account… and Manage….
@@ -1369,6 +1415,7 @@ export function createBrainPicker(host, hooks = {}) {
     refresh,
     snapshot,
     openField,
+    switchProvider,
     fieldSummary,
     modelLabel: () => modelLabel(),
     mountEmptyProject,

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

@@ -228,10 +228,11 @@ export function renderBudgetSession(view, { t } = {}) {
       ? tr('assistant.budget.providerSpend', '{spent} spent', { spent: money(row.spentUsd) })
       : tr('assistant.budget.providerAmounts', 'Share {share} · spent {spent} · left for tasks {left}', { share: row.shareUsd == null ? '—' : money(row.shareUsd), spent: money(row.spentUsd), left: row.workerLeftUsd == null ? '—' : money(row.workerLeftUsd) })));
     if (!view.unlimited && row.isBrain && view.split) item.append(el('div', 'asst-modal-note', tr('assistant.budget.reserve', '{reserve} reserved for the brain within this share.', { reserve: money(view.split.brainReserveLeftUsd) })));
-    if (!view.unlimited && (view.dry || []).includes(row.provider)) item.append(el('div', 'asst-budget-dry', tr('assistant.budget.dry', 'Share used up')));
-    if (!row.eligible && row.reason) {
-      const reason = String(row.reason).replace(/^brain:/, '');
-      item.append(el('div', 'asst-modal-note', tr(`assistant.budget.ineligible.${reason}`, { no_models: 'No available models', signed_out: 'Signed out', limited: 'Provider usage limit reached' }[reason] || reason)));
+    const reason = !row.eligible && row.reason ? String(row.reason).replace(/^brain:/, '') : '';
+    // A provider that reports no prices (Antigravity) gets no share under a budget: nothing of it was "used up".
+    if (!view.unlimited && (view.dry || []).includes(row.provider) && reason !== 'unpriced') item.append(el('div', 'asst-budget-dry', tr('assistant.budget.dry', 'Share used up')));
+    if (reason) {
+      item.append(el('div', 'asst-modal-note', tr(`assistant.budget.ineligible.${reason}`, { no_models: 'No available models', signed_out: 'Signed out', limited: 'Provider usage limit reached', unpriced: 'Reports tokens, not prices' }[reason] || reason)));
     }
     providers.append(item);
   }

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

@@ -10,6 +10,8 @@
 //   Claude   → cp/cp-permissions.js   { behavior, always, updatedInput, updatedPermissions, message, planDecision }
 //   Codex    → cdx/cdx-requests.js    result:{ decision } | result:{ permissions, scope } | result:{ answers } | result:{ action, content }
 //   OpenCode → ocp-v2/ocp-v2-render.js reply:'once'|'always'|'reject' | answers:[[label]]
+//   Antigravity (a dispatched worker's ACP session/request_permission, relayed by the broker as
+//   { toolName, input: <the ACP toolCall> }) → { behavior } once or deny, never "always"
 // Every response additionally carries `behavior`, `provider` and `kind` so the
 // server-side envelope translator can route without re-deriving them; Codex
 // replies repeat `answers` / `content` and OpenCode replies repeat `always` at
@@ -192,6 +194,9 @@ export function describeToolInput(toolName, input = {}) {
 function inferProvider(req, packet) {
   const explicit = normalizeProvider(packet?.provider ?? req?.provider);
   if (explicit) return explicit;
+  // An ACP permission request (Antigravity): a tool call with its id, options of allow_* / reject_* kinds.
+  if (req?.brain_native?.toolCall?.toolCallId || req?.toolCall?.toolCallId) return 'antigravity';
+  if (Array.isArray(req?.options) && req.options.some(o => typeof o?.optionId === 'string' && /^(allow|reject)_(once|always)$/.test(String(o?.kind || '')))) return 'antigravity';
   if (typeof req?.method === 'string' && req.method.includes('/')) return 'codex';
   if (typeof req?.brain_native?.method === 'string' && req.brain_native.method.includes('/')) return 'codex';
   if (req?.subtype === 'can_use_tool' || req?.subtype === 'permission_request' || req?.tool_name) return 'claude-code';
@@ -296,9 +301,49 @@ export function normalizeControlRequest(packet, { origin = null } = {}) {
   if (firstStr(req.tool_name, req.toolName) === 'ExitPlanMode') return normalizeClaude(req, base);
   if (provider === 'codex') return normalizeCodex(req, base);
   if (provider === 'opencode') return normalizeOpenCode(req, base);
+  if (provider === 'antigravity') return normalizeAntigravity(req, base);
   return normalizeClaude(req, base);
 }
 
+// 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 worker's permission request: the broker relays the ACP tool call
+ * ({ toolCallId, title, kind, status, locations, rawInput }) as `input`. The card shows
+ * the call's own arguments, and its command (execute) or the paths it touches as the detail.
+ */
+function normalizeAntigravity(req, base) {
+  // A worker's relay sends the ACP tool call as `input`; the brain sends the call's arguments as `input` and the
+  // call itself as `brain_native.toolCall`. Either way: the call, then its arguments.
+  const given = obj(req.input) || {};
+  const looksLikeCall = given.rawInput !== undefined || given.toolCallId !== undefined || Array.isArray(given.locations);
+  const call = obj(req.brain_native?.toolCall) || obj(req.toolCall) || (looksLikeCall ? given : {});
+  const args = obj(call.rawInput) || (looksLikeCall ? {} : given);
+  const kind = str(call.kind) || 'other';
+  // An MCP call names its server and tool in its arguments ({ ServerName, ToolName, Arguments }).
+  const mcpServer = firstStr(args.ServerName, args.serverName);
+  const mcpTool = firstStr(args.ToolName, args.toolName);
+  const mcpArgs = obj(args.Arguments) || obj(args.arguments);
+  const command = Array.isArray(args.command) ? args.command.map(str).join(' ') : firstStr(args.command, args.CommandLine, args.cmd);
+  const paths = [...new Set([
+    ...(Array.isArray(call.locations) ? call.locations : []).map(location => str(location?.path)),
+    ...ACP_PATH_KEYS.map(key => (typeof args[key] === 'string' ? str(args[key]) : '')),
+  ].filter(Boolean))];
+  let mcpDetail = '';
+  if (mcpServer && mcpTool && mcpArgs) { try { mcpDetail = JSON.stringify(mcpArgs).slice(0, 400); } catch { mcpDetail = ''; } }
+  const detail = mcpServer && mcpTool ? (mcpDetail || `${mcpServer} · ${mcpTool}`)
+    : kind === 'execute' && command ? command : paths.length ? paths.join('\n') : str(call.title);
+  return {
+    ...base,
+    kind: CONTROL_KINDS.PERMISSION,
+    toolName: (mcpServer && mcpTool ? `${mcpServer}_${mcpTool}` : '') || firstStr(req.toolName, req.tool_name, call.title, kind) || 'tool',
+    title: 'Permission required',
+    detail,
+    input: mcpServer && mcpTool && mcpArgs ? mcpArgs : args,
+  };
+}
+
 function normalizeClaude(req, base) {
   const toolName = firstStr(req.tool_name, req.toolName) || 'Unknown';
   const input = obj(req.input) || {};
@@ -543,6 +588,8 @@ export function buildControlResponse(normalized, decision = {}) {
   if (normalized.kind === CONTROL_KINDS.PLAN) return buildClaude(normalized, decision, base, allow, always);
   if (normalized.provider === 'codex') return buildCodex(normalized, decision, base, allow, always);
   if (normalized.provider === 'opencode') return buildOpenCode(normalized, decision, base, allow, always);
+  // Antigravity: allowed once or denied; an "always" is never sent (see controlActions).
+  if (normalized.provider === 'antigravity') return buildClaude(normalized, decision, base, allow, false);
   return buildClaude(normalized, decision, base, allow, always);
 }
 
@@ -651,6 +698,7 @@ export function controlActions(normalized) {
     ];
   }
   const actions = [];
+  // Never for Antigravity: its "always" option is saved by Antigravity for later sessions too, beyond this run.
   const canAlways = n.provider === 'claude-code'
     || n.provider === 'opencode'
     || (n.provider === 'codex' && (n.method === 'item/permissions/requestApproval'

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;