synabun 2.1.0 → 2.2.1

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

@@ -208,6 +208,7 @@ export function normalizeSynaBunChoiceElicitation(params = {}) {
       if (options.length < 2) return null;
       return {
         id,
+        multiSelect: question.multiSelect === true,
         header: String(question?.header || id),
         question: String(question?.question || ''),
         options,
@@ -226,16 +227,16 @@ export function buildSynaBunChoiceContent(questions = [], answers = {}) {
   const content = {};
   for (const question of questions) {
     const id = question?.id;
-    const answer = id ? answers[id]?.answers?.[0] : '';
-    if (!id || !answer) continue;
-    const option = (question.options || []).find((candidate) => candidate.label === answer);
-    if (option) {
-      content[id] = option.value || option.label;
-      continue;
-    }
-    const meta = question._synabunMcp || {};
-    content[id] = meta.otherValue || SYNABUN_OTHER_VALUE;
-    content[meta.otherField || `${id}__other`] = answer;
+    const selected = id ? answers[id]?.answers || [] : [];
+    if (!id || !selected.length) continue;
+    const values = selected.map((answer) => {
+      const option = (question.options || []).find((candidate) => candidate.label === answer);
+      if (option) return option.value || option.label;
+      const meta = question._synabunMcp || {};
+      content[meta.otherField || `${id}__other`] = answer;
+      return meta.otherValue || SYNABUN_OTHER_VALUE;
+    });
+    content[id] = question.multiSelect ? values : values[0];
   }
   return content;
 }

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

@@ -19,6 +19,7 @@ import { OUTPUT_LIMITS, boundedText, jsonAnswer, prettyJsonFences, readableStruc
 import { renderReadableOutput, renderReadableBlock, cleanOutputBlocks, hydrateOutputControls, observeOutputBlocks, renderDiffView, restoreDiffViews } from './cdx-output.js';
 import { fileLinkTitle, fillFileLinkCopy, isInsideRoots, parseFileLinkTarget, readFileLink } from '../file-links.js';
 import { sanitizeHtmlString } from '../assistant/asst-sanitize.js';
+import { createTextCache } from '../text-cache.js';
 export { setCardExpanded } from './cdx-cards.js';
 
 // ── Shared context (set by cdx-tabs via setRenderContext) ──
@@ -105,8 +106,9 @@ export function esc(s) {
 // `<img onerror>` in a reply would run in SynaBun's origin with no click. Every
 // Markdown sink of the panel takes md()'s output, so it goes through the
 // allowlist sanitiser the Assistant, Claude and OpenCode panels use, here, once.
-const _mdCache = new Map();
-const _MD_CACHE_LIMIT = 512;
+const _mdCache = createTextCache();
+export const markdownCacheStats = () => _mdCache.stats();
+export const clearMarkdownCache = () => _mdCache.clear();
 let _mdRenderer = null;
 let _mdParser;
 function markdownFallback(text) {
@@ -130,7 +132,7 @@ export function md(text) {
     _mdRenderer = renderer;
     _mdParser = parser;
   }
-  const key = text || '';
+  const key = String(text || '');
   if (key.length > OUTPUT_LIMITS.input) return `<pre class="cxp-card-pre cxp-output-raw"><code>${esc(boundedText(key))}</code></pre>`;
   const cached = _mdCache.get(key);
   if (cached !== undefined) return cached;
@@ -144,10 +146,6 @@ export function md(text) {
   // A page with no DOM to sanitise in, or a sanitiser that fails, gets escaped text: never raw HTML.
   try { html = sanitizeHtmlString(html); }
   catch { html = markdownFallback(key); }
-  if (_mdCache.size >= _MD_CACHE_LIMIT) {
-    const firstKey = _mdCache.keys().next().value;
-    if (firstKey !== undefined) _mdCache.delete(firstKey);
-  }
   _mdCache.set(key, html);
   return html;
 }
@@ -3264,7 +3262,10 @@ export function resolveHistoryRenderSource(thread, fallbackItems = null, storedS
 // `authoritative`: the thread's turns are its whole history (a revert reply),
 // so the saved rendering is never used in their place, even when none remain.
 export function renderHistory(thread, fallbackItems = null, { authoritative = false } = {}) {
-  _ctx.flushThreadSnapshotSave(_ctx.boundTab);
+  // A save still pending for what is on screen is written before the transcript is rebuilt; with nothing
+  // pending there is nothing to keep (no forced serialisation of the whole transcript on every open).
+  const pendingTab = _ctx.boundTab;
+  if (pendingTab?.snapshotTimer || pendingTab?.snapshotIdleHandle) _ctx.flushThreadSnapshotSave(pendingTab);
   const preservedTokenUsage = thread?.id && _ctx.threadId && thread.id === _ctx.threadId
     ? _ctx.threadTokenUsage
     : null;
@@ -3341,7 +3342,7 @@ export function renderHistory(thread, fallbackItems = null, { authoritative = fa
   });
   _ctx.hideEmpty();
   _ctx.scrollEnd(true);
-  _ctx.flushThreadSnapshotSave(_ctx.boundTab);
+  _ctx.scheduleThreadSnapshotSave(_ctx.boundTab);
   renderPostPlanActions(_ctx.boundTab);
   renderPostCompactionActions(_ctx.boundTab);
 }

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

@@ -417,7 +417,7 @@ export function renderUserInputRequest(requestId, params, protocol = {}) {
           <span class="cxp-ask-option-desc">${esc(optionDesc)}</span>
         `;
         const retainedValue = answers[answerKey]?.answers?.[0];
-        if (!isOtherOption && retainedValue === optionLabel) btn.classList.add('selected');
+        if (!isOtherOption && (answers[answerKey]?.answers || []).includes(optionLabel)) btn.classList.add('selected');
         btn.addEventListener('click', async () => {
           if (isChangelogAsk && /edit first/i.test(optionLabel)) {
             const allButtons = Array.from(optionsEl.querySelectorAll('.cxp-ask-option'));
@@ -434,6 +434,16 @@ export function renderUserInputRequest(requestId, params, protocol = {}) {
             if (!opened) _ctx.restoreChangelogButtons(allButtons);
             return;
           }
+          if (question.multiSelect && !isOtherOption) {
+            otherWrap.hidden = true;
+            const selected = new Set(answers[answerKey]?.answers || []);
+            if (selected.has(optionLabel)) selected.delete(optionLabel); else selected.add(optionLabel);
+            const labels = new Set(explicitOptions.map((o) => typeof o === 'string' ? o : o.label));
+            const values = [...selected].filter((label) => labels.has(label));
+            if (values.length) answers[answerKey] = { answers: values }; else delete answers[answerKey];
+            optionsEl.querySelectorAll('.cxp-ask-option').forEach((node) => node.classList.toggle('selected', values.includes(node.querySelector('.cxp-ask-option-label')?.textContent)));
+            persistEditingDraft(); syncSubmit(); return;
+          }
           optionsEl.querySelectorAll('.cxp-ask-option').forEach((node) => node.classList.remove('selected'));
           btn.classList.add('selected');
           if (isOtherOption) {

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

@@ -125,6 +125,10 @@ export function injectStyles() {
       opacity: 1;
       overflow: visible;
     }
+    /* Windows: the shell is 92% opaque, so the blur behind it barely shows, yet Chromium recomputes it on every
+       repaint inside the panel (a transcript rendering, a stream). There it goes; the colour stays. */
+    html.platform-win32 .codex-panel,
+    html.desktop-titlebar--win32 .codex-panel { backdrop-filter: none; -webkit-backdrop-filter: none; }
     /* A floating terminal is promoted above the panel when focused. Raise the
        whole stacking context while a footer menu is open so it stays visible. */
     .codex-panel:has(.cxp-dropdown.open) {

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

@@ -1,4 +1,6 @@
+import { answerWorkerQuestion } from '../worker-questions.js';
 import { cxpText, cxpSessionLabel } from './cdx-copy.js';
+import { codexWantsRolloutPreview, rolloutPreviewApplies } from './cdx-preview.js';
 import { mountCodexSettings } from './cdx-settings.js';
 import { t } from '../i18n.js';
 import { getCliState, isCliInstalling } from '../cli-status.js';
@@ -14,8 +16,8 @@ import { accountName, accountSummary, accountSwitchPlan, accountText, serverAcco
 import { mountAccountMenu } from '../account-menu.js';
 import '../account-i18n.js';
 import { restoreMcpAppCards, teardownMcpApps, retireMcpAppNode, stripMcpAppRuntime } from './cdx-mcp-app-host.js';
-import { renderTurnDiff, completeTurnOutputs } from './cdx-render.js';
-import { hydrateOutputControls } from './cdx-output.js';
+import { renderTurnDiff, completeTurnOutputs, clearMarkdownCache } from './cdx-render.js';
+import { hydrateOutputControls, disposeOutputBlocks } from './cdx-output.js';
 import { sanitizeStoredHtml } from '../assistant/asst-sanitize.js';
 import {
   beginPlanTurn, capturePlanItem, finishPlanTurn, getPlanMarkdown, syncPlanMirrors, recordPlanTurn,
@@ -205,6 +207,13 @@ function autosizeInput() { _onAutosizeInput?.(); }
 function emit(...args) { _onEmit?.(...args); }
 
 function sendSocket(msg) {
+  if (_boundTab?.automationRunId && msg?.type === 'server_request_response') {
+    const tab = _boundTab;
+    answerWorkerQuestion(tab.automationRunId, msg.requestId, { behavior: msg.error || ['cancel', 'decline'].includes(msg.result?.action) || ['cancel', 'decline'].includes(msg.result?.decision) ? 'deny' : 'allow', result: msg.result, error: msg.error })
+      .then((result) => withTab(tab, () => handleServerRequestResponseResult({ responseToken: msg.responseToken, ok: true, status: result.stale ? 'stale' : 'answered' })),
+        (error) => withTab(tab, () => handleServerRequestResponseResult({ responseToken: msg.responseToken, ok: false, status: tab._workerQuestions?.has(String(msg.requestId)) ? 'delivery_failed' : 'stale', retryable: true, error: error.message })));
+    return true;
+  }
   const packet = msg && _boundTab?.id
     ? {
         ...msg,
@@ -277,6 +286,16 @@ function closeAutomationHistorySocket(tab) {
   }
 }
 
+// The rollout read before Codex's app-server is up (server.js sendEarlyCodexRolloutPreview): shown only for
+// the thread this tab shows, and only while nothing else (a stored snapshot) is on screen. The real history
+// replaces it.
+function paintRolloutPreview(tab, msg) {
+  const shownThread = String(_boundTab?.threadId || _threadId || '');
+  if (!rolloutPreviewApplies(msg, shownThread, _transcriptSourceType)) return;
+  renderHistory(msg.thread, msg.fallbackItems || null);
+  placeWorkerEnd(tab);
+}
+
 function buildWsCallbacks(tab, options = {}) {
   return {
     onConnecting() {
@@ -309,6 +328,8 @@ function buildWsCallbacks(tab, options = {}) {
           userVerification: true,
           windowId: windowId,
           threadId: _threadId || null,
+          // The early rollout preview only for the tab on screen (server.js sendEarlyCodexRolloutPreview).
+          preview: codexWantsRolloutPreview(tab, _boundTab, _threadId),
           cwd: _project || null,
           accountId: _accountId || 'default',
           ...codexRuntimeSelection(tab),
@@ -450,6 +471,7 @@ function buildWsCallbacks(tab, options = {}) {
       // which rebuilds the transcript: they go back onto it afterwards.
       const heldRequests = heldServerRequests();
       if (msg.thread) {
+        if (msg.preview) { paintRolloutPreview(tab, msg); return; }
         if (_boundTab) {
           _boundTab.expectedThreadId = null;
           _boundTab.expectedThreadRequestId = null;
@@ -757,6 +779,7 @@ let _projectThreads = parseStoredJson(STOR.projectThreads, {});
 // async; getThreadSnapshot returns null pre-hydration and renderHistory falls
 // back to SDK/JSONL items.
 let _threadSnapshots = {};
+let _threadSnapshotsHydrated = false;
 const _threadSnapshotsReady = fetchBlobNamespace('codex-snapshots')
   .then((map) => {
     const valid = {};
@@ -772,7 +795,8 @@ const _threadSnapshotsReady = fetchBlobNamespace('codex-snapshots')
     _threadSnapshots = { ...valid, ..._threadSnapshots };
     try { if (storage.getItem(STOR.threadSnapshots)) storage.removeItem(STOR.threadSnapshots); } catch {}
   })
-  .catch(() => {});
+  .catch(() => {})
+  .finally(() => { _threadSnapshotsHydrated = true; });
 let _tabs = [];
 let _activeTabIdx = -1;
 let _boundTab = null;
@@ -2631,6 +2655,9 @@ function disposeDiscardedTab(tab) {
     clearTimeout(tab.snapshotTimer);
     tab.snapshotTimer = null;
   }
+  tab.scrollController?.destroy();
+  tab.scrollController = null;
+  disposeOutputBlocks(tab.messagesEl);
   tab.messagesEl?.remove();
   tab.pillEl?.remove();
 }
@@ -2719,9 +2746,37 @@ export function renderProjects() {
   ddPopulate(projectDropdown, projectItemsForValue(_project), _project);
 }
 
+function paintInitialThreadSnapshot(tab) {
+  if (!tab || tab.closed || !tab.threadId || tab.transcriptSourceType || tab.automationRunId) return false;
+  const expectedThreadId = String(tab.threadId);
+  let painted = false;
+  withTab(tab, () => {
+    const snap = getThreadSnapshot(expectedThreadId);
+    if (!snap) return;
+    painted = renderStoredTranscript(snap, 'Continue this Codex thread or start a fresh one.');
+    if (painted) {
+      updateThreadTokenUsage(tab.threadTokenUsage || snap.threadTokenUsage || null);
+      renderPostPlanActions(tab);
+      renderPostCompactionActions(tab);
+      placeWorkerEnd(tab);
+    }
+  });
+  if (!painted && !_threadSnapshotsHydrated && !tab._pendingSnapshotPaint) {
+    tab._pendingSnapshotPaint = true;
+    _threadSnapshotsReady.finally(() => {
+      tab._pendingSnapshotPaint = false;
+      if (!tab.closed && tab.threadId === expectedThreadId && !tab.transcriptSourceType) {
+        paintInitialThreadSnapshot(tab);
+      }
+    });
+  }
+  return painted;
+}
+
 export function updateActiveTabView() {
   const tab = activeTab();
   if (!_getPanelEl() || !tab) return;
+  paintInitialThreadSnapshot(tab);
   bindTabState(tab);
   _onActiveTabChanged?.(tab);
   _tabs.forEach((entry) => {
@@ -2945,6 +3000,8 @@ export function closeTab(idx, { detachAutomation = false } = {}) {
   tab.closed = true;
   tab.titleRequestController?.abort();
   tab.titleRequestController = null;
+  tab.authView?.dispose();
+  tab.terminalAuthView?.dispose();
   if (tab.titleReassertTimer) clearTimeout(tab.titleReassertTimer);
   flushThreadSnapshotSave(tab);
   withTab(tab, () => {
@@ -2967,11 +3024,16 @@ export function closeTab(idx, { detachAutomation = false } = {}) {
   }
   tab.scrollController?.destroy();
   tab.scrollController = null;
+  disposeOutputBlocks(tab.messagesEl);
   if (tab.messagesEl) retireMcpAppNode(tab.messagesEl, () => tab.messagesEl.remove());
   tab.pillEl?.remove();
   _tabs.splice(idx, 1);
   if (!_tabs.length) {
     _activeTabIdx = -1;
+    // The module binding otherwise keeps the last closed transcript, its item
+    // and request maps, and every closure on their DOM alive indefinitely.
+    bindTabState(null);
+    clearMarkdownCache();
     saveTabs();
     renderPills();
     _setVisible(false);
@@ -3165,7 +3227,13 @@ export function restoreTabs() {
           if (tab && !tab.automationRunId && (saved.running || saved.startingThread || saved.needsYou)) wereWorking.push(tab);
         }
         if (!_tabs.length) throw new Error('No restorable Codex tabs');
-        _activeTabIdx = Math.min(Math.max(Number(data.activeIdx) || 0, 0), _tabs.length - 1);
+        const pendingTabId = globalThis.__synabunPendingTab?.provider === 'codex'
+          ? String(globalThis.__synabunPendingTab.tabId || '')
+          : '';
+        const pendingIdx = pendingTabId ? _tabs.findIndex((entry) => String(entry.id) === pendingTabId) : -1;
+        _activeTabIdx = pendingIdx >= 0
+          ? pendingIdx
+          : Math.min(Math.max(Number(data.activeIdx) || 0, 0), _tabs.length - 1);
         pruneDiscardableTabs({ keepTab: activeTab(), persist: false });
         if (!_tabs.length) throw new Error('No restorable Codex tabs');
         updateActiveTabView();
@@ -4597,6 +4665,7 @@ export function promptNameNewSession() {
       try {
         const statusResponse = await fetch(`/api/git/status?path=${encodeURIComponent(chosenProject)}`);
         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.');
         const shouldCheckout = !status?.changes?.length || window.confirm(
           `Switch from ${branchOriginal} to ${chosenBranch} with ${status.changes.length} uncommitted change${status.changes.length === 1 ? '' : 's'}? Git will preserve them when possible.`,
         );
@@ -6551,8 +6620,9 @@ function setModelForTab(tab, model) {
 function setEffortForTab(tab, effort) {
   if (!tab) return false;
   const normalized = String(effort || '').trim().toLowerCase();
-  const nextEffort = normalized === 'default' || normalized === 'none' ? 'off' : normalized;
   const supported = effortOptionsForTab(tab);
+  // 'none' is a real level on models that advertise it; elsewhere it means the default.
+  const nextEffort = normalized === 'default' || (normalized === 'none' && !supported.some((option) => option.id === 'none')) ? 'off' : normalized;
   if (!supported.some((option) => option.id === nextEffort)) {
     withTab(tab, () => appendSystem(`Unsupported reasoning effort for ${tab.model || 'this model'}: ${effort}. Use ${supported.map((option) => option.id).join(', ')}.`, 'error'));
     return false;

package/neural-interface/public/shared/cli-install-controller.js

@@ -0,0 +1,218 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — one CLI's install state, for a side panel (no DOM)
+// ═══════════════════════════════════════════
+//
+// What a panel needs to show for its CLI and to act on it: the latest answer of
+// /api/system/tool-versions (cli-status.js), an install this page started or
+// follows (POST /api/cli/install/:tool, or one another window started), a
+// "failed to start" a session reported, Add to PATH, Re-check. One controller
+// per panel; `onChange(view)` hears every change, `view()` is
+// cli-install-view.js cliBannerView() plus `checking` (a Re-check is under way)
+// and `nudging` (a held-back send asked for attention a moment ago).
+//
+// ui-cli-banner.js paints it as the Claude, Codex and OpenCode panels' banner;
+// the Antigravity panel paints it as its setup card (agy/agy-setup.js).
+
+import { subscribeCliStatus, recheckCliStatus, getCliDocUrl, getCliInstallCommand, getCliLabel, installCli, followCliInstall, getCliInstallJobs, addCliToPath } from './cli-status.js';
+import { cliBannerView, cliInstallText, cliStateOf, reduceInstallJob, INSTALLABLE_CLIS } from './cli-install-view.js';
+
+/** How long the note about where an install put the CLI stays, when it has one. */
+export const DONE_NOTICE_MS = 12000;
+export const NUDGE_MS = 700;
+
+/**
+ * @param {object} o
+ * @param {string} o.toolKey 'claude-code' | 'codex' | 'opencode' | 'antigravity'
+ * @param {(view: object) => void} [o.onChange]
+ * @param {number} [o.doneNoticeMs]
+ * @param {number} [o.nudgeMs]
+ */
+export function createCliInstallController({ toolKey, onChange = () => {}, doneNoticeMs = DONE_NOTICE_MS, nudgeMs = NUDGE_MS } = {}) {
+  let info = null;        // this CLI in the latest answer of /api/system/tool-versions (null: none yet)
+  let forced = null;      // { reason }: a session could not start it, and the server was not asked again yet
+  let job = null;         // the install under way or just ended (cli-install-view.js reduceInstallJob)
+  let installing = false;
+  let addingPath = false;
+  let pathError = '';
+  let checking = false;
+  let looked = false;     // asked whether the server is already installing it since it went missing
+  let doneTimer = null;
+  let nudgeTimer = null;
+  let destroyed = false;
+
+  const view = () => ({
+    ...cliBannerView({
+      toolKey,
+      label: getCliLabel(toolKey),
+      info,
+      forced,
+      job,
+      addingPath, pathError,
+      guideUrl: getCliDocUrl(toolKey),
+      installCommand: getCliInstallCommand(toolKey),
+    }, { t: cliInstallText }),
+    checking,
+    nudging: !!nudgeTimer,
+    job,
+    info,
+  });
+
+  const changed = () => {
+    if (destroyed) return;
+    try { onChange(view()); } catch (error) { console.error('[cli-install] onChange:', error); }
+  };
+
+  function clearDone() {
+    clearTimeout(doneTimer);
+    doneTimer = null;
+    if (job?.phase === 'done') job = null;
+    changed();
+  }
+
+  function apply(event) {
+    if (!job && event?.type !== 'start') job = reduceInstallJob(null, { type: 'start' });
+    job = reduceInstallJob(job, event);
+    if (event?.type === 'done' && event.ok && event.status && typeof event.status === 'object') {
+      info = event.status;
+      forced = null;
+    }
+    changed();
+  }
+
+  function settle(final) {
+    if (job?.phase === 'running' && final) job = reduceInstallJob(job, final);
+    if (job?.phase === 'done') {
+      clearTimeout(doneTimer);
+      const where = job.path;
+      if (where && (where.onPath === false || where.added === true)) doneTimer = setTimeout(clearDone, doneNoticeMs);
+      else job = null;
+    }
+    changed();
+  }
+
+  async function install() {
+    if (installing || !INSTALLABLE_CLIS.includes(toolKey)) return null;
+    installing = true;
+    clearTimeout(doneTimer);
+    job = reduceInstallJob(null, { type: 'start' });
+    changed();
+    let final = null;
+    try {
+      final = await installCli(toolKey, { onEvent: apply });
+    } catch (error) {
+      final = { type: 'done', ok: false, code: 'internal', error: error?.message || null };
+    } finally {
+      installing = false;
+      settle(final);
+    }
+    return final;
+  }
+
+  async function addPath() {
+    if (addingPath) return;
+    addingPath = true; pathError = ''; changed();
+    try {
+      const result = await addCliToPath(toolKey);
+      info = { ...info, pathStatus: { dir: result.dir, onPath: true, canAdd: false } };
+      job = reduceInstallJob(null, { type: 'done', ok: true, status: info, path: { ...result, added: true } });
+      settle();
+    } catch (error) { pathError = error.message; }
+    finally { addingPath = false; changed(); }
+  }
+
+  // An install the server is already running (another window started it, or this page was reloaded during
+  // one): followed here as if this page had started it.
+  async function followRunning() {
+    if (installing) return;
+    const jobs = await getCliInstallJobs();
+    if (destroyed || installing || jobs?.[toolKey]?.state !== 'running') return;
+    installing = true;
+    job = reduceInstallJob(null, { type: 'start' });
+    changed();
+    let final = null;
+    try {
+      final = await followCliInstall(toolKey, { onEvent: apply });
+    } catch (error) {
+      final = { type: 'done', ok: false, code: 'connection', error: error?.message || null };
+    } finally {
+      installing = false;
+      settle(final);
+    }
+  }
+
+  async function recheck() {
+    if (checking) return info;
+    checking = true;
+    // Asking again starts over: an earlier failure is not repeated over a fresh answer.
+    if (job?.phase === 'failed') job = null;
+    changed();
+    try {
+      const next = await recheckCliStatus(toolKey);
+      info = next || info;
+      if (cliStateOf(info) === 'installed' || cliStateOf(info) === 'broken') forced = null;
+    } catch { /* the view stays as it is */ }
+    finally {
+      checking = false;
+      changed();
+    }
+    return info;
+  }
+
+  const unsubscribe = subscribeCliStatus(toolKey, (next) => {
+    info = next || null;
+    const state = cliStateOf(info);
+    if (state === 'installed') {
+      forced = null;
+      if (job?.phase === 'failed') job = null;
+    }
+    if (state === 'missing') {
+      if (!looked) { looked = true; followRunning().catch(() => {}); }
+    } else {
+      looked = false;
+    }
+    changed();
+  });
+
+  return {
+    view,
+    /** Tell `onChange` again (the panel was shown, or rebuilt). */
+    refresh: changed,
+    /** Sending is held back: the CLI is missing, broken, failed to install, or being installed. */
+    blocked: () => view().blocked,
+    /** A send was held back: `nudging` is true for a moment. */
+    nudge() {
+      if (!view().show) return;
+      clearTimeout(nudgeTimer);
+      nudgeTimer = setTimeout(() => { nudgeTimer = null; changed(); }, nudgeMs);
+      changed();
+    },
+    /**
+     * A session could not start the CLI ("CLI not found", a spawn error): "failed to start" with its words at
+     * once, then the server is asked again; its answer decides what stays.
+     */
+    flagFailure(reason = null) {
+      forced = { reason: reason ? String(reason).slice(0, 300) : null };
+      changed();
+      recheckCliStatus(toolKey)
+        .then((next) => {
+          info = next || info;
+          const state = cliStateOf(info);
+          if (state === 'installed' || state === 'broken') forced = null;
+          changed();
+        })
+        .catch(() => {});
+    },
+    install,
+    recheck,
+    addPath,
+    clearDone,
+    /** Whether an install runs from this page now. */
+    installing: () => installing,
+    destroy() {
+      destroyed = true;
+      unsubscribe();
+      clearTimeout(doneTimer);
+      clearTimeout(nudgeTimer);
+    },
+  };
+}

package/neural-interface/public/shared/cli-install-view.js

@@ -2,7 +2,8 @@
 // SynaBun Neural Interface — the CLI banner of the side panels: what it says
 // ═══════════════════════════════════════════
 //
-// What the Claude Code, Codex and OpenCode panels show above their transcript
+// What the Claude Code, Codex and OpenCode panels show above their transcript (and the Antigravity panel's setup
+// card words its install steps with)
 // for one CLI: nothing while it is installed, "not installed" with a one-click
 // Install (the vendor's own installer, run by the server: POST
 // /api/cli/install/:tool) and the command to run by hand, the progress of an
@@ -35,6 +36,7 @@ export const CLI_INSTALL_COPY = Object.freeze({
   stepPathAdded: 'Added {dir} to your PATH',
   bodyMissing: 'Install it with one click from {vendor}\'s official installer, or run:',
   bodyMissingManual: 'Install it with this command, then re-check:',
+  bodyMissingGuide: 'Follow its install guide, then re-check.',
   bodyBroken: '{label} was found at {path}, but it could not be started:',
   bodyBrokenVersion: '{label} {version} was found at {path}, but it could not be started:',
   bodyBrokenLatched: '{label} is installed, but it could not be started:',
@@ -80,11 +82,11 @@ export const CLI_VENDORS = Object.freeze({
   'claude-code': 'Anthropic',
   codex: 'OpenAI',
   opencode: 'OpenCode',
-  gemini: 'Google',
+  antigravity: 'Google',
 });
 
 /** The CLIs a server can install with one click (POST /api/cli/install/:tool). */
-export const INSTALLABLE_CLIS = Object.freeze(['claude-code', 'codex', 'opencode']);
+export const INSTALLABLE_CLIS = Object.freeze(['claude-code', 'codex', 'opencode', 'antigravity']);
 
 /** The steps an install reports (`{ type: 'step' }`), in the order they can come. */
 export const INSTALL_STEPS = Object.freeze(['start', 'download', 'verify', 'run', 'check', 'path']);
@@ -371,9 +373,10 @@ export function cliBannerView({ toolKey, label = '', info = null, forced = null,
         recheck: true,
       });
     }
+    // No command at all (none from the server, and none on the page either): the guide only.
     const text = offer
       ? t('bodyMissing', { vendor: CLI_VENDORS[toolKey] || name, label: name })
-      : t('bodyMissingManual');
+      : t(command ? 'bodyMissingManual' : 'bodyMissingGuide');
     return Object.assign(view, {
       show: true, blocked: true, kind: 'missing', tone: 'warn', icon: '!',
       title: t('titleMissing', { label: name }),

package/neural-interface/public/shared/cli-status.js

@@ -1,6 +1,6 @@
 // ═══════════════════════════════════════════
 // SynaBun — CLI Status (shared)
-// Detects whether Claude / Codex / OpenCode CLIs are installed by
+// Detects whether Claude / Codex / OpenCode / Antigravity CLIs are installed by
 // querying /api/system/tool-versions. Caches the response, fans out
 // updates to subscribers, and auto-polls (every 30s) while at least
 // one subscribed tool is not installed (missing, or found but broken).
@@ -17,33 +17,34 @@ import { cliStateOf, cliInstallOffer, INSTALLABLE_CLIS } from './cli-install-vie
 
 export { cliStateOf, cliInstallOffer };
 
-const TOOL_KEYS = ['claude-code', 'codex', 'opencode', 'gemini'];
+const TOOL_KEYS = ['claude-code', 'codex', 'opencode', 'antigravity'];
 
 // The vendors' install pages. The server's `guideUrl` wins when it sends one.
 const CLI_DOC_URLS = {
   'claude-code': 'https://code.claude.com/docs/en/setup',
   'codex':       'https://learn.chatgpt.com/docs/codex/cli',
   'opencode':    'https://opencode.ai/v2/docs',
-  'gemini':      'https://github.com/google-gemini/gemini-cli',
+  'antigravity': 'https://antigravity.google/docs/getting-started',
 };
 
 // Fallback only. The server computes the command that fits the machine (the
 // vendor's recommended installer for its system, or the package manager the
-// other CLIs came from: buildInstallCommand in lib/cli-update-planner.js) and
-// returns it as `installCommand`. These apply only before the first
-// tool-versions response.
+// other CLIs came from: buildInstallCommand in lib/cli-update-planner.js; for
+// the Antigravity CLI, the command of the install its button runs there, which
+// is Homebrew's cask on a Mac that has Homebrew) and returns it as
+// `installCommand`. These apply only before the first tool-versions response.
 const CLI_INSTALL_CMDS = {
   'claude-code': { posix: 'curl -fsSL https://claude.ai/install.sh | bash', windows: 'irm https://claude.ai/install.ps1 | iex' },
   'codex':       { posix: 'curl -fsSL https://chatgpt.com/codex/install.sh | sh', windows: 'powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"' },
   'opencode':    { posix: 'curl -fsSL https://opencode.ai/v2/install | bash', windows: 'winget install --id Anomaly.OpenCode --exact' },
-  'gemini':      { posix: 'npm install -g @google/gemini-cli', windows: 'npm install -g @google/gemini-cli' },
+  'antigravity': { posix: 'curl -fsSL https://antigravity.google/cli/install.sh | bash', windows: 'irm https://antigravity.google/cli/install.ps1 | iex' },
 };
 
 const CLI_LABELS = {
   'claude-code': 'Claude Code',
   'codex':       'Codex',
   'opencode':    'OpenCode',
-  'gemini':      'Gemini CLI',
+  'antigravity': 'Antigravity CLI',
 };
 
 const POLL_INTERVAL_MS = 30000;

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

@@ -66,6 +66,7 @@ export const KEYS = {
   ACTIVE_WORKSPACE:    'neural-active-workspace',  // sessionStorage
   GRID_SNAP:           'neural-grid-snap',
   TOPRIGHT_TOOLS_HIDDEN: 'neural-topright-tools-hidden',  // the workspace tools toggle is off ('true')
+  WHITEBOARD_TOOLBAR_HIDDEN: 'neural-whiteboard-toolbar-hidden',  // the whiteboard rail (#wb-toolbar) is hidden behind the logo button ('true')
   CATEGORIES_VISIBLE:  'neural-categories-visible',
   WHITEBOARD:          'neural-whiteboard',
   WHITEBOARD_RULESET_ALERT_DISMISSED: 'neural-whiteboard-ruleset-alert-dismissed',
@@ -127,7 +128,7 @@ export const DEFAULT_KEYBINDS = {
   'toggle-assistant':    'Ctrl+a',
   'launch-claude':       '1',
   'launch-codex':        '2',
-  'launch-gemini':       '3',
+  'launch-antigravity':  '3',
   'launch-opencode':     '4',
   'launch-browser':      'b',
   'launch-youtube':      'y',
@@ -154,7 +155,7 @@ export const KEYBIND_META = {
   'toggle-assistant-panel': { label: 'Toggle Assistant Sidepanel', group: 'Launch App', icon: 'assistant' },
   'launch-claude':       { label: 'Claude Code',           group: 'Launch App', icon: 'claude' },
   'launch-codex':        { label: 'Codex CLI',             group: 'Launch App', icon: 'codex' },
-  'launch-gemini':       { label: 'Gemini CLI',            group: 'Launch App', icon: 'gemini' },
+  'launch-antigravity':  { label: 'Antigravity CLI',       group: 'Launch App', icon: 'antigravity' },
   'launch-opencode':     { label: 'OpenCode',              group: 'Launch App', icon: 'opencode' },
   'launch-browser':      { label: 'Browser',               group: 'Launch App', icon: 'browser' },
   'launch-youtube':      { label: 'YouTube',               group: 'Launch App', icon: 'youtube' },