synabun 2.1.0 → 2.2.0

package/neural-interface/server.js

@@ -56,10 +56,11 @@ import { createEventLoopMonitor } from './lib/event-loop-monitor.js';
 import { createRulesetInstaller } from './lib/rulesets/installer.js';
 import { registerRulesetRoutes, registerLegacyRulesetRoutes } from './lib/rulesets/api.js';
 import { createPtyHostManager } from './lib/pty-host/manager.js';
-import { AGENT_HEADERS, hostNameOf, isAllowedHost, isAllowedWebSocketOrigin, parseCookies, refuseUpgrade } from './lib/http-guards.js';
+import { AGENT_HEADERS, hostNameOf, isAllowedHost, isAllowedWebSocketOrigin, parseCookies, refuseUpgrade, requireLocal as requireLoopbackSocket } from './lib/http-guards.js';
 import { createRequestGates, extraHostNames, hostsOf, savedValueOf, startedValueOf } from './lib/request-gate.js';
 import { createGitDiffRouter } from './lib/git-diff-api.js';
-import { gitRead, gitReadSync, setGitFallbackFolder, withGitFallback } from './lib/git-read.js';
+import { setGitFallbackFolder } from './lib/git-read.js';
+import { gitStatusRunner, projectStatus } from './lib/git-status-runner.js';
 import { createPhoneAuthority } from './lib/remote-policy.js';
 import { brainCredentialOf } from './lib/virtual-socket.js';
 import { buildTerminalEnv, interactiveShellArgs, cliWrapperArgs } from './lib/terminal-env.js';
@@ -104,6 +105,8 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlink
 import * as fsp from 'fs/promises';
 import { createInterface as createReadlineInterface } from 'readline';
 import { jsonlLines } from './lib/jsonl-lines.js';
+import { createHistoryCache } from './lib/claude-history-cache.js';
+import { createRolloutReader } from './lib/codex-rollout-reader.js';
 import { randomBytes, randomUUID, createHash, pbkdf2Sync, createDecipheriv } from 'crypto';
 import { exec, execFile, execSync, spawn, spawnSync } from 'child_process';
 import { promisify } from 'util';
@@ -192,6 +195,7 @@ import { codexReasoningEffort } from './lib/effort-levels.js';
 import {
   createClaudeNativeLoopAdapter,
   createCodexNativeLoopAdapter,
+  createAntigravityNativeLoopAdapter,
   createOpenCodeNativeLoopAdapter,
   openCodeRunConfigFor,
   openCodeRunEnvFor,
@@ -203,7 +207,7 @@ import { createOpenCodeActivityRelay } from './lib/opencode-worker-activity.js';
 import { browserServePortDenial } from './lib/browser-tool-policy.js';
 import { createNativeServeBoundary, nativeServeCapability } from './lib/opencode-native-boundary.js';
 const nativeServeBoundary = createNativeServeBoundary();
-import { setBrowserNetworkRule, usesNativeBrowserNetworkGuard, disposeBrowserNetworkGuard, MONEY_PATTERNS, SERVE_PORT_PATTERNS } from './lib/browser-network-guard.js';
+import { setBrowserNetworkRule, usesNativeBrowserNetworkGuard, disposeBrowserNetworkGuard, recoverBrowserNetworkGuard, MONEY_PATTERNS, SERVE_PORT_PATTERNS } from './lib/browser-network-guard.js';
 import { browserPolicyRoots } from './lib/browser-policy-roots.js';
 import {
   mergeCodexModelContextCapabilities,
@@ -234,12 +238,21 @@ import { initBlobStore, blobGetNamespace, blobGet, blobPut, blobDelete, blobClea
 import { createUiBlobRouter } from './lib/ui-blob-api.js';
 import { memoCache, asyncPool } from './lib/memo-cache.js';
 import {
+  buildAntigravityMcpEntry,
   buildClaudeMcpEntry,
   buildCodexMcpKv,
-  buildGeminiMcpEntry,
+  describeAntigravityMcpEntry,
+  mergeAntigravityMcpConfig,
   mergeClaudeMcpConfig,
-  mergeGeminiMcpConfig,
+  parseAntigravityMcpConfig,
+  removeAntigravityMcpServer,
 } from './lib/mcp-client-config.js';
+import { ANTIGRAVITY_PANEL_CAPABILITIES, ANTIGRAVITY_WS_PATH, createAntigravityPanelBridge, validateRunHome } from './lib/antigravity/panel-bridge.js';
+import { migrateGeminiFiles, migrateUiStateValues as migrateGeminiUiState } from './lib/antigravity/migrate-gemini.js';
+import { groupSessionsByProject, listAntigravityModels, listAntigravitySessions } from './lib/antigravity/catalog.js';
+import { defaultAntigravityPolicy } from './lib/antigravity/policy.js';
+import { antigravityHomeDir, antigravityHomesRoot, pruneAntigravityHomes } from './lib/antigravity/home.js';
+import { antigravityStores, findUserConversation, parseAntigravityTranscript, readTranscriptText } from './lib/antigravity/transcripts.js';
 import {
   buildAgentDisallowedTools,
   agentAccessFrom,
@@ -304,7 +317,7 @@ import { registerSkillEvalRoutes } from './lib/skills/evals-api.js';
 import { evalConfinementSupport } from './lib/skills/eval-confinement.js';
 import { evalShellReadPaths, evalShellSupported, prepareEvalShell } from './lib/skills/eval-sandbox.js';
 import { urlProblem as skillSourceUrlProblem } from './public/shared/skills/ss-creation.js';
-import { claudeRowsToMessages, codexRolloutToMessages, opencodeRowsToMessages } from './lib/skills/creation-sources.js';
+import { antigravityMessagesToMessages, claudeRowsToMessages, codexRolloutToMessages, opencodeRowsToMessages } from './lib/skills/creation-sources.js';
 import { renderSkillBody } from './public/shared/skills/ss-args.js';
 import { claudeBoolean } from './public/shared/skills/ss-profiles.js';
 import { generateSessionTitle } from './lib/session-title-generator.js';
@@ -355,6 +368,7 @@ import {
 import { ensureProjectCategories as ensureProjectCategoriesInFile, ensureCategories as ensureCategoriesInFile, FEATURE_CATEGORIES } from '../hooks/claude-code/shared.mjs';
 import { getDataHome, getDataHomeDiagnostics, isGlobalInstall, pathIsInside } from '../lib/paths.js';
 import { launcherLogPath } from '../lib/first-launch-protection.js';
+import { prunePreUpdateSnapshots, resolvePreUpdateKeep } from '../lib/update-snapshot.js';
 import { launcherRegistrationAllowed, registerStartLauncher, startLauncherState } from '../lib/start-launcher.js';
 import { effectiveNpmPrefix } from '../lib/child-path.js';
 import { checkRuntimeDependencies, fallbackInstallArgs, fallbackInstallEnv, findInstalled, mcpCompiler, npmCommand, npmInvocation } from '../lib/runtime-dependencies.js';
@@ -381,7 +395,7 @@ import {
   getFbActionBudget, getFbEngagementTier, FB_ACTION_TYPES,
 } from './lib/db.js';
 import {
-  rebuildClaudeCache, rebuildCodexCache, rebuildOpencodeCache,
+  rebuildClaudeCache, rebuildCodexCache, rebuildOpencodeCache, rebuildAntigravityCache,
 } from './lib/session-cache-builder.js';
 import {
   clearOpenCodeHistory,
@@ -2388,6 +2402,7 @@ function gracefulShutdown(reason = 'shutdown') {
 }
 
 async function runGracefulShutdown(reason) {
+  gitStatusRunner.shutdown();
   console.log(`[server] gracefulShutdown(${reason}) — releasing children...`);
 
   // Native automation providers own SDK subprocesses/isolated serves that are
@@ -2399,6 +2414,8 @@ async function runGracefulShutdown(reason) {
   try { keepRuns = _assistantDispatcher?.suspendForShutdown?.(reason) || []; } catch (err) { console.warn('  assistant suspend err:', err?.message); }
   try { await _nativeLoopRuntime?.shutdown(reason, { keep: keepRuns }); } catch (err) { console.warn('  native loop stop err:', err?.message); }
   try { stopAllIsolatedServes(); } catch (err) { console.warn('  isolated opencode stop err:', err?.message); }
+  // The Antigravity panel's `agy acp` processes (one per open panel socket).
+  try { await antigravityPanel.closeAll(); } catch (err) { console.warn('  antigravity panel stop err:', err?.message); }
   // The code editor's completion serve, and today's autocomplete counters.
   try { await editorCompletion.stop(); } catch (err) { console.warn('  editor completion stop err:', err?.message); }
 
@@ -2818,7 +2835,17 @@ app.post('/api/system/run-update', async (req, res) => {
       appVersion: installPlan.current,
       additionalEntries: getBackupAdditionalEntries(),
     }));
-    applyBackupRetention({ folderPath: updateBackupDir });
+    // Older pre-update snapshots are pruned only now, after this one is written and verified: a
+    // failed createVerifiedBackup above threw and never reached here.
+    try {
+      const configuredKeep = loadAutoBackupConfig()?.retention?.preUpdateKeep ?? null;
+      prunePreUpdateSnapshots({
+        folderPath: updateBackupDir,
+        keep: resolvePreUpdateKeep(configuredKeep),
+        keepPath: snapshot.path,
+        log: (message) => console.log(`[update-backup] ${message}`),
+      });
+    } catch (error) { console.error(`[update-backup] retention cleanup failed: ${error?.message || error}`); }
     const handoffPath = resolve(DATA_HOME, 'data', 'update-handoff.json');
     writeFileSync(handoffPath, JSON.stringify({
       version: 1,
@@ -3656,6 +3683,28 @@ function getClaudeSdkExecutable() {
   });
 }
 
+// Google Antigravity's CLI (`agy`): what the side panel (`agy acp`), the workers, the model list and the session list
+// start. The resolver's answer, as a program and the words before its own arguments: a binary as it is, a script
+// through node, a PowerShell script through PowerShell. A Windows command file (cmd.exe) cannot take words after the
+// fact, so it is reported as not runnable here (the terminal profile still runs it). null when none is installed.
+function antigravityLaunch() {
+  const found = cliResolver.launcher('antigravity');
+  _noteCliLookup('antigravity', found, 'Antigravity CLI');
+  const spec = found.spec;
+  if (!found.path || !spec || found.state === 'broken') return null;
+  if (spec.kind === 'direct') return { command: spec.launchPath || found.path, args: [], version: found.version || null, path: found.path };
+  if (spec.kind === 'node-script') return { command: process.execPath, args: [spec.launchPath], version: found.version || null, path: found.path };
+  if (spec.kind === 'powershell') return { command: 'powershell.exe', args: ['-NoProfile', '-NonInteractive', '-File', spec.launchPath], version: found.version || null, path: found.path };
+  return null;
+}
+// The environment an Antigravity process gets: the PATH a new terminal has (agy runs the user's tools), never the
+// owner's live data paths or a brain's credential.
+function antigravityChildEnv() {
+  const env = withPathEnv({ ...process.env }, getAugmentedPath());
+  for (const key of ['SQLITE_DB_PATH', 'MEMORY_DATA_DIR', 'SYNABUN_BRAIN_TOKEN', 'SYNABUN_ASSISTANT_SESSION', 'SYNABUN_ASSISTANT_THREADS']) delete env[key];
+  return env;
+}
+
 // Codex: what the SDK and the app-server start. On Windows the native codex.exe
 // an npm command file leads to (the SDK spawns without a shell); the file found
 // otherwise. SynaBun carries no Codex (lib/external-tools.js): without one,
@@ -5626,10 +5675,10 @@ CRITICAL — When you need clarification during planning:
     return item;
   }
 
-  function loadCodexThreadHistoryFallback(threadId) {
-    if (!threadId) return [];
+  function codexRolloutPathFor(threadId) {
+    if (!threadId) return '';
     const dbPath = resolve(activeCodexHome, 'state_5.sqlite');
-    if (!existsSync(dbPath)) return [];
+    if (!existsSync(dbPath)) return '';
 
     let db = null;
     let rolloutPath = '';
@@ -5642,20 +5691,27 @@ CRITICAL — When you need clarification during planning:
     } finally {
       try { db?.close(); } catch {}
     }
-    if (!rolloutPath || !existsSync(rolloutPath)) return [];
+    return rolloutPath && existsSync(rolloutPath) ? rolloutPath : '';
+  }
 
-    let raw = '';
+  // The rollout as history items: read as a stream, parsed once while the file is unchanged
+  // (lib/codex-rollout-reader.js), so the early preview and the fallback that follows share one read.
+  async function loadCodexThreadHistoryFallback(threadId) {
+    const rolloutPath = codexRolloutPathFor(threadId);
+    if (!rolloutPath) return [];
     try {
-      raw = readFileSync(rolloutPath, 'utf-8');
+      return await codexRolloutReader.items(rolloutPath, parseCodexRolloutLines);
     } catch (err) {
       console.warn('[codex-skin] Failed to read rollout history:', err.message);
       return [];
     }
+  }
 
+  async function parseCodexRolloutLines(lines) {
     const items = [];
     const calls = new Map();
     let seq = 0;
-    for (const line of raw.split('\n')) {
+    for await (const line of lines) {
       if (!line.trim()) continue;
       let entry;
       try {
@@ -6178,7 +6234,29 @@ CRITICAL — When you need clarification during planning:
   }
 
 
-  async function bootstrapThread(threadId, cwd = PACKAGE_ROOT) {
+  // Only for the thread the client shows (it asks with `preview: true`), only before the app-server is up, read
+  // without blocking its start; dropped once the real history went out. The read is reused by the fallback.
+  function sendEarlyCodexRolloutPreview(threadId, state) {
+    if (!threadId || initialized) return null;
+    const job = loadCodexThreadHistoryFallback(threadId);
+    job.then((previewItems) => {
+      if (state.historySent || !Array.isArray(previewItems) || !previewItems.length) return;
+      const previewThreadId = String(threadId);
+      sendToClient({
+        type: 'history',
+        preview: true,
+        threadId: previewThreadId,
+        thread: { id: previewThreadId, turns: [] },
+        fallbackItems: previewItems,
+        historyMode: 'read',
+      });
+    }).catch(() => {});
+    return job;
+  }
+
+  async function bootstrapThread(threadId, cwd = PACKAGE_ROOT, { preview = false } = {}) {
+    const previewState = { historySent: false };
+    if (preview) sendEarlyCodexRolloutPreview(threadId, previewState);
     await ensureInitialized();
     if (!threadId) {
       displayedThreadId = activeThreadId;
@@ -6193,11 +6271,13 @@ CRITICAL — When you need clarification during planning:
       const historyMode = activeThreadId && effectiveThreadId && activeThreadId === effectiveThreadId
         ? 'resume'
         : 'read';
+      const fallbackItems = await loadCodexThreadHistoryFallback(effectiveThreadId);
+      previewState.historySent = true;
       sendToClient({
         type: 'history',
         threadId: effectiveThreadId,
         thread: sanitizeCodexThreadForClient(thread),
-        fallbackItems: loadCodexThreadHistoryFallback(effectiveThreadId),
+        fallbackItems,
         historyMode,
       });
       // `history` and `ready` must describe the same displayed thread. Returning
@@ -6206,6 +6286,7 @@ CRITICAL — When you need clarification during planning:
       sendToClient({ type: 'ready', threadId: effectiveThreadId });
     } catch (err) {
       console.warn('[codex-skin] Failed to resume thread:', threadId, err.message);
+      previewState.historySent = true;
       sendToClient({ type: 'history', thread: null, resumeFailed: true, threadId });
       sendToClient({ type: 'error', message: `Could not restore saved Codex thread. ${err.message}` });
       sendToClient({ type: 'ready', threadId });
@@ -6318,7 +6399,7 @@ CRITICAL — When you need clarification during planning:
     const runtime = opts.runtimeOptions || await resolveCodexThreadRuntimeOptions(opts);
     displayedThreadId = String(threadId);
     const readThread = await readThreadHistory(threadId).catch(() => null);
-    const fallbackItems = loadCodexThreadHistoryFallback(threadId);
+    const fallbackItems = await loadCodexThreadHistoryFallback(threadId);
     const previewThread = readThread || (fallbackItems.length ? { id: threadId, turns: [] } : null);
     if (previewThread) {
       sendToClient({
@@ -6783,7 +6864,7 @@ CRITICAL — When you need clarification during planning:
         }
         // Resolve the tab's account BEFORE first spawn so CODEX_HOME is correct.
         if (!child && msg.accountId) setActiveCodexAccount(msg.accountId);
-        await bootstrapThread(msg.threadId || null, msg.cwd || PACKAGE_ROOT);
+        await bootstrapThread(msg.threadId || null, msg.cwd || PACKAGE_ROOT, { preview: msg.preview === true });
         return;
       }
       if (msg.type === 'permission_roots_list') {
@@ -9023,6 +9104,30 @@ setInterval(() => {
 
 process.once('exit', stopAllIsolatedServes);
 
+// ── Antigravity side panel (/ws/antigravity) ──
+// One `agy acp` (Google's Antigravity ACP server) per panel socket, one ACP session per tab
+// (lib/antigravity/panel-bridge.js; docs/antigravity-sidepanel.md). Pasted attachments are written under the data
+// home for the agent to read; nothing reaches Antigravity's own folders.
+const antigravityPanel = createAntigravityPanelBridge({
+  resolveLaunch: async () => antigravityLaunch(),
+  childEnv: () => antigravityChildEnv(),
+  attachmentsRoot: resolve(DATA_HOME, 'data', 'antigravity', 'attachments'),
+  homesRoot: () => antigravityHomesRoot(DATA_HOME),
+  isRunHomeActive: (homeDir) => (_nativeLoopRuntime?.list({ activeOnly: true }) || []).some((run) => run.provider === 'antigravity' && run.antigravityHome === homeDir && (run.status === 'starting' || run.status === 'running')),
+  // Bypass keeps the browser policy: a test runner passes from inside a registered code project (lib/antigravity/bypass.js).
+  policyRoots: () => { try { return browserPolicyRoots(loadHookProjects()); } catch { return []; } },
+  clientInfo: { name: 'synabun', title: 'SynaBun', version: String(process.env.npm_package_version || '0') },
+  // Greeting (lib/greeting/): a prompt typed in the panel is noted, and the greeting a tab opened with is told to
+  // the model once, before the typed words (public/shared/agy/agy-greeting.js markers).
+  onHumanPrompt: ({ cwd, words }) => { try { _greeting?.noteActivity({ cwd: cwd || PACKAGE_ROOT, surface: 'antigravity-panel', words }); } catch {} },
+  greetingNote: (id, opts) => _greeting?.consumeNote(id, opts) || '',
+  // `/synabun …` reads the bundled skill, as the Codex panel's does (lib/skill-prompt-bridge.js).
+  expandPrompt: (text) => expandSynabunCodexSlashPrompt(text, join(SKILLS_SOURCE_DIR, 'synabun', 'SKILL.md')),
+  // A turn that ended may have added to the conversation's transcript: Resume search and memory sessions follow.
+  onTurnEnd: ({ sessionId }) => { try { refreshAntigravitySession(sessionId); } catch {} },
+  log: (line) => console.log(line),
+});
+
 function handleOpencodeV2Ws(ws) {
   _ocpV2WsClients.add(ws);
   ws._nativeLoopWindowId = null;
@@ -11001,7 +11106,7 @@ const _codexSettingsProbes = createLaunchCache({
 });
 setCodexSettingsStore({ get: (key) => _codexSettingsProbes.peek(key), set: (key, value) => _codexSettingsProbes.set(key, value) });
 
-async function getClaudeModelsForClient(force = false) {
+async function getClaudeModelsForClient(force = false, { nonBlocking = false } = {}) {
   try {
     const bin = getClaudeBin();
     // Sidepanel sessions and native loops run this same installation. The Agent
@@ -11010,8 +11115,9 @@ async function getClaudeModelsForClient(force = false) {
     // when the CLI changes).
     checkClaudeCliSkew(bin).catch(() => {});
     // Answered from the kept list at once (asked again in the background when it is old);
-    // only a first read, another binary or account, or ?refresh=1 waits for the CLI.
-    const result = await discoverClaudeModels(bin, { force, cwd: PACKAGE_ROOT, account: claudeModelAccountKey() });
+    // only a first read, another binary or account, or ?refresh=1 waits for the CLI, unless
+    // nonBlocking=true (e.g. cold /api/claude/config boot on Windows) warms it asynchronously.
+    const result = await discoverClaudeModels(bin, { force, nonBlocking, cwd: PACKAGE_ROOT, account: claudeModelAccountKey() });
     if (result?.models?.length) return result;
   } catch (err) {
     console.warn('[claude-models] discovery failed:', err.message);
@@ -11039,7 +11145,11 @@ app.get('/api/claude/config', async (req, res) => {
     // Model ids come straight from the CLI and are already spawn-ready (they carry
     // the `[1m]` suffix where applicable), so the client uses them verbatim — no
     // "<id>:<contextWindow>" composite. See toCliModelName() for the legacy form.
-    const { source, models } = await getClaudeModelsForClient();
+    // Default to non-blocking model discovery so cold panel opens on Windows never stall
+    // behind a 3–7s `claude.exe` spawn; ui-claude-panel.js refreshes fallback models async.
+    const { source, models } = await getClaudeModelsForClient(false, {
+      nonBlocking: req.query?.waitModels !== '1',
+    });
     res.json({ ok: true, config: cliCfg, projects, models, modelsSource: source, bootId: SERVER_BOOT_ID });
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -14372,9 +14482,15 @@ function isSidepanelClaimTokenRevoked(windowId, claimToken) {
 
 // Native provider run ledger. A sidepanel can attach after a page refresh or
 // after a schedule started while no Neural Interface window was open.
+function withSidepanelRunHome(run) {
+  if (!run || run.provider !== 'antigravity' || run.antigravityHome || !run.runId) return run;
+  const home = _assistantDispatcher?.get?.(run.runId)?.antigravityHome || null;
+  return home ? { ...run, antigravityHome: home } : run;
+}
+
 app.get('/api/sidepanel-runs', (req, res) => {
   const activeOnly = req.query.active === '1' || req.query.active === 'true';
-  res.json({ ok: true, runs: _nativeLoopRuntime?.list({ activeOnly }) || [] });
+  res.json({ ok: true, runs: (_nativeLoopRuntime?.list({ activeOnly }) || []).map(withSidepanelRunHome) });
 });
 
 app.post('/api/sidepanel-runs/release-window', (req, res) => {
@@ -14386,7 +14502,7 @@ app.post('/api/sidepanel-runs/release-window', (req, res) => {
 app.get('/api/sidepanel-runs/:runId', (req, res) => {
   const run = _nativeLoopRuntime?.get(req.params.runId);
   if (!run) return res.status(404).json({ error: 'Native sidepanel run not found' });
-  res.json({ ok: true, run });
+  res.json({ ok: true, run: withSidepanelRunHome(run) });
 });
 
 app.post('/api/sidepanel-runs/:runId/claim', (req, res) => {
@@ -14395,7 +14511,7 @@ app.post('/api/sidepanel-runs/:runId/claim', (req, res) => {
   }
   const result = _nativeLoopRuntime?.claim(req.params.runId, req.body?.windowId);
   if (!result?.ok) return res.status(result?.reason === 'not_found' ? 404 : 409).json(result || { ok: false });
-  res.json(result);
+  res.json(result.run ? { ...result, run: withSidepanelRunHome(result.run) } : result);
 });
 
 app.post('/api/sidepanel-runs/:runId/release', (req, res) => {
@@ -14533,7 +14649,7 @@ app.post('/api/loop/launch', async (req, res) => {
       // .claude/ set awaitingNext and attachLoopDriver() drives /clear + re-prompt; if those
       // hooks are absent (e.g. a claude-code task run under a hookless harness) the loop STALLS.
       // 'exec': harness-agnostic — attachExecLoopDriver() owns iteration via sentinel echoes, so
-      // OpenCode/Codex/Gemini self-advance. Facebook seeding must stay profile:opencode for this.
+      // OpenCode/Codex/Antigravity self-advance. Facebook seeding must stay profile:opencode for this.
       driverType: nativeRuntime ? 'native' : (cliProfile === 'claude-code' ? 'hook' : 'exec'),
       runtimeType: nativeRuntime ? 'native' : 'pty',
       surface: nativeRuntime ? 'sidepanel' : 'terminal',
@@ -14652,12 +14768,12 @@ app.post('/api/loop/launch', async (req, res) => {
       loopLog(terminalSessionId, 'launch:driver', 'attaching hook-driven loop driver (claude-code)');
       attachLoopDriver(terminalSessionId);
     } else {
-      // Codex/Gemini/other: spawn shell, server drives `<cli> exec` commands per iteration.
+      // Codex/Antigravity/other: spawn shell, server drives `<cli> exec` commands per iteration.
       // The driver invokes a platform-native wrapper that captures the CLI
       // status and emits a sentinel. Immune to PS1/PROMPT overrides.
       loopLog(terminalSessionId, 'launch:spawn', 'creating shell PTY for exec-driven CLI', { profile: cliProfile, cwd: loopCwd });
       createTerminalSession('shell', 120, 30, loopCwd, { extraEnv: loopExtraEnv, sessionId: terminalSessionId });
-      loopLog(terminalSessionId, 'launch:driver', 'attaching exec loop driver (codex/gemini/other)', { profile: cliProfile });
+      loopLog(terminalSessionId, 'launch:driver', 'attaching exec loop driver (codex/antigravity/other)', { profile: cliProfile });
       attachExecLoopDriver(terminalSessionId);
     }
 
@@ -14774,7 +14890,7 @@ app.post('/api/loop/stop', async (req, res) => {
 });
 
 // POST /api/loop/resolve-from-ancestors — process-tree fallback for MCP env loss.
-// The MCP server walks its ancestor PID chain (codex/opencode/gemini → shell PTY)
+// The MCP server walks its ancestor PID chain (codex/opencode/antigravity → shell PTY)
 // and POSTs the chain here. We match any PID against terminalSessions[*].pty.pid
 // and return that loop's browserSessionId/browserTabId. Layer B of the
 // defense-in-depth browser tab isolation fix.
@@ -15570,7 +15686,7 @@ async function launchScheduledLoop(schedule) {
     }
 
     // Native providers run headlessly in their durable provider conversation.
-    // Gemini and unsupported profiles retain the existing PTY drivers.
+    // Unsupported profiles retain the existing PTY drivers.
     let runDescriptor = null;
     if (nativeRuntime) {
       const presentation = resolveScheduleRunPresentation(
@@ -17499,7 +17615,7 @@ function isSynabunGitHubRemote(remoteText) {
   return /github\.com[:/]danilokhury\/Synabun(?:\.git)?(?:[\s)]|$)/i.test(String(remoteText || ''));
 }
 
-function detectSynabunInstallSource() {
+async function detectSynabunInstallSource() {
   if (PACKAGED_RUNTIME) return { kind: 'packaged-app' };
   const normalizedRoot = PACKAGE_ROOT.replace(/\\/g, '/');
   if (/\/node_modules\/synabun$/i.test(normalizedRoot)) {
@@ -17509,13 +17625,13 @@ function detectSynabunInstallSource() {
   try {
     // Run as reads (lib/git-read.js): the app's own checkout is a folder like any other, and can be a registered
     // project. What git could not say is an empty answer.
-    const git = (args) => {
-      const result = spawnGitRead(args, { cwd: PACKAGE_ROOT, timeout: 2000 });
+    const git = async (args) => {
+      const result = await spawnGitRead(args, { cwd: PACKAGE_ROOT, timeout: 2000 });
       return result.status === 0 ? result.stdout.toString().trim() : '';
     };
-    if (git(['rev-parse', '--is-inside-work-tree']) === 'true') {
-      const remote = git(['remote', 'get-url', 'origin']);
-      const remotes = git(['remote', '-v']);
+    if (await git(['rev-parse', '--is-inside-work-tree']) === 'true') {
+      const remote = await git(['remote', 'get-url', 'origin']);
+      const remotes = await git(['remote', '-v']);
       if (isSynabunGitHubRemote(`${remote}\n${remotes}`)) {
         const firstRemote = remote || remotes.split(/\s+/).find(part => isSynabunGitHubRemote(part)) || null;
         return { kind: 'github-clone', remote: firstRemote };
@@ -17600,7 +17716,7 @@ async function checkSynabunUpdate() {
   const installPlan = buildSynabunInstallPlan({
     ...found,
     current,
-    installSource: updateAvailable ? detectSynabunInstallSource() : null,
+    installSource: updateAvailable ? await detectSynabunInstallSource() : null,
     repoUrl: SYNABUN_GITHUB_REPO_URL,
   });
 
@@ -17742,6 +17858,8 @@ function systemActivitySources() {
       const blockers = getOpenCodeHistoryBlockers();
       return blockers.activeTurns + blockers.startingTurns;
     },
+    // A prompt running in an Antigravity panel tab (lib/antigravity/panel-bridge.js); dispatched runs are under assistant.
+    'antigravity-panel': () => antigravityPanel.turnsRunning(),
     'claude-cli': () => recentCliSessions(sessionRegistry),
     loop: () => {
       // A dispatched worker also runs in the native runtime: it is counted under assistant.
@@ -17770,7 +17888,9 @@ app.get('/api/system/activity', (req, res) => {
 const TOOL_DEFS = [
   { key: 'claude-code', cmd: 'claude',   versionArg: '--version', npm: '@anthropic-ai/claude-code' },
   { key: 'codex',       cmd: 'codex',    versionArg: '--version', npm: '@openai/codex' },
-  { key: 'gemini',      cmd: 'gemini',   versionArg: '--version', npm: '@google/gemini-cli' },
+  // Google's Antigravity CLI has no npm package: a Homebrew cask's newer version is what `brew outdated` says, and
+  // the CLI updates itself (`agy update`).
+  { key: 'antigravity', cmd: 'agy',      versionArg: '--version' },
   // npm's opencode-ai is OpenCode 1: OpenCode 2's newer version is what Homebrew says (a brew install) or what OpenCode
   // itself announces in its own interface.
   { key: 'opencode',    cmd: 'opencode', versionArg: '--version' },
@@ -17970,7 +18090,11 @@ async function checkToolVersions({ force = false } = {}) {
     || 'unknown';
   for (const [key, info] of Object.entries(results)) {
     const source = info.installed ? info.installSource : dominantSource;
-    info.installCommand = buildInstallCommand(key, source, { platform: process.platform });
+    // The Antigravity CLI: the command of the install its button runs here (Homebrew's cask on a Mac that has
+    // Homebrew, else Google's installer), so the banner never shows one command and runs another.
+    info.installCommand = key === 'antigravity' && info.install?.available
+      ? cliInstaller.manualCommand(key)
+      : buildInstallCommand(key, source, { platform: process.platform });
   }
 
   // A check started before a newer refresh must never publish its stale answer.
@@ -18039,7 +18163,7 @@ app.use('/api/cli/path', createCliPathApi({
   pathManager: cliPathManager, resolver: cliResolver, isGuestRequest, port: () => PORT,
   diagnostics: async () => {
     const fresh = await freshTerminalPath();
-    const statuses = await cliResolver.resolveAll(['claude-code', 'codex', 'opencode']);
+    const statuses = await cliResolver.resolveAll(['claude-code', 'codex', 'opencode', 'antigravity']);
     return { platform: process.platform, pathKey: Object.keys(fresh.env).find(key => key.toUpperCase() === 'PATH'),
       entries: fresh.entries, os: fresh.os, pathext: fresh.env.PATHEXT || fresh.env.PathExt || null,
       tools: Object.fromEntries(Object.entries(statuses).map(([tool, status]) => [tool, { path: status.path, launchPath: status.launchPath, ...cliPathManager.inspect(status) }])) };
@@ -18753,7 +18877,7 @@ app.get('/api/project-files', editorOwnerGuard, async (req, res) => {
     }
 
     // Git info for status badges
-    const git = getGitInfo(normalizedDir);
+    const git = await getGitInfo(normalizedDir, { signal: gitRequestSignal(res) });
 
     if (recursive || (search && search.length > 2)) {
       // Recursive search mode
@@ -19171,8 +19295,9 @@ app.put('/api/morelogin/config', (req, res) => {
 app.post('/api/morelogin/test', async (req, res) => {
   try {
     const status = await moreLogin.getMoreLoginStatus(_moreLoginOpts());
-    if (!status.installed) return res.json({ ok: false, error: 'MoreLogin desktop app is not installed.' });
+    if (!status.installed) return res.json({ ok: false, error: `MoreLogin desktop app was not found and nothing answers on port ${status.port}.` });
     if (!status.running) return res.json({ ok: false, error: `MoreLogin API not reachable on port ${status.port}. Open MoreLogin and enable its local API (Settings → API & MCP).` });
+    if (status.apiError) return res.json({ ok: false, error: status.apiError });
     res.json({ ok: true, port: status.port, profileCount: status.profileCount });
   } catch (err) {
     res.json({ ok: false, error: err.message });
@@ -19268,6 +19393,25 @@ function _normalizeMcpEntry(input) {
   return { command, args, env, url, type };
 }
 
+// ── Antigravity's MCP configuration (~/.gemini/config/mcp_config.json) ──
+// The one file `agy mcp add` writes and both the Antigravity CLI and app read: { mcpServers: { name: { command, args,
+// env, disabled } | { serverUrl, headers, disabled } } }. Antigravity creates it empty; an empty file reads as {}.
+function antigravityConfigDir() { return join(getHomePath(), '.gemini', 'config'); }
+function antigravityMcpConfigPath() { return join(antigravityConfigDir(), 'mcp_config.json'); }
+/** The parsed file ({} when missing or empty); throws on a file that is not a JSON object, so nothing overwrites it. */
+function readAntigravityMcpConfig() {
+  const path = antigravityMcpConfigPath();
+  if (!existsSync(path)) return {};
+  return parseAntigravityMcpConfig(readFileSync(path, 'utf8'));
+}
+function writeAntigravityMcpConfig(data) {
+  const path = antigravityMcpConfigPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.synabun-${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+  renameSync(tmp, path);
+}
+
 function _writeMoreLoginMcpToAgents(entry) {
   const targets = [];
   const home = getHomePath();
@@ -19283,18 +19427,16 @@ function _writeMoreLoginMcpToAgents(entry) {
       targets.push('Claude Code');
     }
   } catch (e) { console.warn('[morelogin] Claude register failed:', e.message); }
-  try { // Gemini (~/.gemini/settings.json)
-    const p = join(home, '.gemini', 'settings.json');
-    if (existsSync(p)) {
-      const data = JSON.parse(readFileSync(p, 'utf8') || '{}');
-      if (!data.mcpServers) data.mcpServers = {};
-      data.mcpServers[MORELOGIN_MCP_KEY] = entry.url
-        ? { url: entry.url, trust: true }
-        : { command: entry.command, args: entry.args || [], ...(entry.env ? { env: entry.env } : {}), trust: true };
-      writeFileSync(p, JSON.stringify(data, null, 2) + '\n', 'utf8');
-      targets.push('Gemini');
+  try { // Antigravity (~/.gemini/config/mcp_config.json, the CLI's and the app's): only where Antigravity has run
+    if (existsSync(antigravityConfigDir())) {
+      const data = readAntigravityMcpConfig();
+      data.mcpServers = { ...(data.mcpServers || {}), [MORELOGIN_MCP_KEY]: buildAntigravityMcpEntry(entry.url
+        ? { type: entry.type || 'http', url: entry.url }
+        : { command: entry.command, args: entry.args || [], env: entry.env }) };
+      writeAntigravityMcpConfig(data);
+      targets.push('Antigravity');
     }
-  } catch (e) { console.warn('[morelogin] Gemini register failed:', e.message); }
+  } catch (e) { console.warn('[morelogin] Antigravity register failed:', e.message); }
   try { // Codex (~/.codex/config.toml) — stdio only
     const p = join(home, '.codex', 'config.toml');
     if (existsSync(p) && entry.command) {
@@ -19332,13 +19474,11 @@ function _removeMoreLoginMcpFromAgents() {
     }
   } catch {}
   try {
-    const p = join(home, '.gemini', 'settings.json');
-    if (existsSync(p)) {
-      const data = JSON.parse(readFileSync(p, 'utf8') || '{}');
+    if (existsSync(antigravityMcpConfigPath())) {
+      const data = readAntigravityMcpConfig();
       if (data.mcpServers && data.mcpServers[MORELOGIN_MCP_KEY]) {
-        delete data.mcpServers[MORELOGIN_MCP_KEY];
-        writeFileSync(p, JSON.stringify(data, null, 2) + '\n', 'utf8');
-        targets.push('Gemini');
+        writeAntigravityMcpConfig(removeAntigravityMcpServer(data, MORELOGIN_MCP_KEY));
+        targets.push('Antigravity');
       }
     }
   } catch {}
@@ -21164,10 +21304,106 @@ app.get('/api/opencode/sessions', (req, res) => {
   }
 });
 
-// GET /api/gemini/sessions — stub (Gemini CLI has no known session storage)
-app.get('/api/gemini/sessions', (req, res) => {
-  const projects = loadHookProjects();
-  res.json({ projects: projects.map(p => ({ path: p.path, label: p.label || basename(p.path), total: 0, sessions: [] })) });
+// GET /api/antigravity/sessions — Antigravity's own conversations (ACP session/list on a short-lived `agy acp`),
+// grouped under the registered projects. A missing or signed-out CLI lists nothing and says why.
+let _antigravitySessionsCache = null; // { at, value }
+app.get('/api/antigravity/sessions', async (req, res) => {
+  try {
+    const projects = loadHookProjects();
+    const limit = Math.min(parseInt(req.query.limit) || 30, 100);
+    const offset = parseInt(req.query.offset) || 0;
+    const search = (req.query.search || '').toString();
+    const fresh = _antigravitySessionsCache && Date.now() - _antigravitySessionsCache.at < 15_000 && req.query.refresh !== '1';
+    const listed = fresh ? _antigravitySessionsCache.value : await listAntigravitySessions({ launch: antigravityLaunch(), env: antigravityChildEnv() });
+    if (!fresh && !listed.error) _antigravitySessionsCache = { at: Date.now(), value: listed };
+    res.json({
+      projects: groupSessionsByProject(listed.sessions, projects, { targetProject: req.query.project || null, search, offset, limit }),
+      ...(listed.error ? { error: listed.error } : {}),
+      ...(listed.authRequired ? { authRequired: true } : {}),
+      ...(listed.cliMissing ? { cliMissing: true } : {}),
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// GET /api/antigravity/models — what an ACP session offers SynaBun (lib/antigravity/catalog.js: a short-lived `agy acp`
+// in a throwaway home; `agy models` only when ACP fails), kept for a minute.
+// { models: [{ id, label, efforts?, default? }], source: 'live' | 'stale' | 'unavailable', via, signedIn?, tier?, error? }
+let _antigravityModelsCache = null; // { at, value }
+app.get('/api/antigravity/models', async (req, res) => {
+  try {
+    const age = _antigravityModelsCache ? Date.now() - _antigravityModelsCache.at : Infinity;
+    if (age < 60_000 && req.query.refresh !== '1') return res.json(_antigravityModelsCache.value);
+    const value = await listAntigravityModels({ launch: antigravityLaunch(), env: antigravityChildEnv() });
+    if (value.source === 'live') {
+      // A different list than the one the Assistant's catalog last read: its rows are rebuilt (as for Claude's).
+      const ids = (rows) => (rows || []).map((row) => `${row.id}${row.default ? '*' : ''}`).join('\n');
+      const changed = _antigravityModelsCache && ids(_antigravityModelsCache.value.models) !== ids(value.models);
+      _antigravityModelsCache = { at: Date.now(), value };
+      if (changed) _assistantCatalog?.refresh?.().catch(() => {});
+    }
+    else if (_antigravityModelsCache?.value?.models?.length) return res.json({ ..._antigravityModelsCache.value, source: 'stale', error: value.error });
+    res.json(value);
+  } catch (err) {
+    res.status(500).json({ models: [], source: 'unavailable', error: err.message });
+  }
+});
+
+// POST /api/antigravity/policy — the question the PreToolUse hook of a SynaBun Antigravity home asks before every tool
+// call of a brain or run SynaBun started (lib/antigravity/policy-hook.mjs → lib/antigravity/policy.js). The home's
+// token names who registered the checker; an unknown token is refused. Loopback socket only (requireLocal), and only
+// { token, payload }: the answer is { decision: 'deny' | 'ask' | 'allow', reason? }.
+app.post('/api/antigravity/policy', requireLoopbackSocket, express.json({ limit: '4mb' }), async (req, res) => {
+  const body = req.body && typeof req.body === 'object' && !Array.isArray(req.body) ? req.body : {};
+  try {
+    res.json(await defaultAntigravityPolicy.decide(body.token, body.payload && typeof body.payload === 'object' ? body.payload : {}));
+  } catch (err) {
+    res.json({ decision: 'deny', reason: `SynaBun could not check this call (${err?.message || err}).` });
+  }
+});
+/** Where the hook of a SynaBun Antigravity home reaches this server (loopback, the port this server listens on). */
+function antigravityPolicyUrl() { return `http://127.0.0.1:${PORT}/api/antigravity/policy`; }
+/** The home of an Antigravity brain or run (lib/antigravity/home.js), under the data home's runtime folder. */
+function antigravityHomeFor(kind, id) { return antigravityHomeDir(antigravityHomesRoot(DATA_HOME), kind, id); }
+
+// Antigravity's conversations as SynaBun keeps them (lib/antigravity/transcripts.js, read only): the user's own go
+// into Resume's index (session_cache + session_fts, provider antigravity), every one, SynaBun's brain and run homes
+// included, into memory capture (lib/memory-session-capture.js). A pass at start, one after a panel turn ends (that
+// conversation only, a moment later so agy has written its last step), one every five minutes, and a fresh one
+// before Resume or Skills Studio searches them (at most every 15 s).
+function antigravitySessionStores({ userOnly = false } = {}) {
+  return antigravityStores({ homesRoot: userOnly ? null : antigravityHomesRoot(DATA_HOME) });
+}
+let _antigravityCacheAt = 0;
+function refreshAntigravityCatalog({ force = false } = {}) {
+  if (!force && Date.now() - _antigravityCacheAt < 15_000) return null;
+  _antigravityCacheAt = Date.now();
+  try { return rebuildAntigravityCache({ stores: antigravitySessionStores() }); }
+  catch (err) { console.warn('  Session cache (antigravity) error:', err.message); return null; }
+}
+const _antigravityRefreshTimers = new Map();
+function refreshAntigravitySession(sessionId) {
+  if (typeof sessionId !== 'string' || !sessionId) return;
+  clearTimeout(_antigravityRefreshTimers.get(sessionId));
+  _antigravityRefreshTimers.set(sessionId, setTimeout(() => {
+    _antigravityRefreshTimers.delete(sessionId);
+    try { rebuildAntigravityCache({ stores: antigravitySessionStores({ userOnly: true }), only: sessionId }); }
+    catch (err) { console.warn('  Session cache (antigravity) error:', err.message); }
+  }, 1500));
+  _antigravityRefreshTimers.get(sessionId).unref?.();
+}
+/** SynaBun's own MCP entry for an Antigravity home: the registration the Setup card writes (stdio, this install). */
+function antigravitySynabunMcpEntry() {
+  const { envPath, mcpCommand, mcpArgs } = getMcpPaths();
+  return { command: mcpCommand, args: mcpArgs, env: { DOTENV_PATH: envPath, SYNABUN_DATA_HOME: DATA_HOME, MEMORY_DATA_DIR: resolve(DATA_HOME, 'mcp-data') } };
+}
+
+// GET /api/antigravity/panel — what the side panel's socket offers on this server (lib/antigravity/panel-bridge.js).
+// Admin-only like the socket itself, so the page tells a refused socket (403 here too: a guest, the automation
+// browser) from a server that predates it (404: it needs a restart) instead of reconnecting forever.
+app.get('/api/antigravity/panel', (req, res) => {
+  res.json({ ok: true, socket: ANTIGRAVITY_WS_PATH, capabilities: [...ANTIGRAVITY_PANEL_CAPABILITIES], live: antigravityPanel.liveCount() });
 });
 
 // ── Hybrid session content search (FTS5 + semantic re-rank for Claude) ──
@@ -21204,6 +21440,9 @@ app.get('/api/session-search', async (req, res) => {
       codexCatalogById = new Map(codexCatalog.map((session) => [session.sessionId, session]));
     }
 
+    // Antigravity's index follows its transcripts (refreshAntigravityCatalog: at most every 15 s).
+    if (provider === 'antigravity') refreshAntigravityCatalog();
+
     // 1. FTS5 substring hits
     const ftsRows = searchSessionFts(q, { provider, project: projectFilter, limit: limit * 2 });
     const ftsMap = new Map();
@@ -21468,13 +21707,21 @@ app.post('/api/claude-code/sessions/:sessionId/fork', express.json(), claudeSess
 app.delete('/api/claude-code/sessions/:sessionId', express.json(), claudeSessionRoute((req) => {
   // Irreversible: the panel asks first, and says so here.
   if (req.body?.confirm !== true) { const e = new Error('Deleting a session needs confirm: true'); e.status = 400; throw e; }
-  return claudeSessionOps.remove(req.params.sessionId, req.body?.project);
+  // The transcript cache keeps parsed rows by path: a deleted session's go with it (also when the delete fails half way).
+  return Promise.resolve()
+    .then(() => claudeSessionOps.remove(req.params.sessionId, req.body?.project))
+    .finally(() => { try { claudeHistoryCache.forgetSession(req.params.sessionId); } catch {} });
 }));
 app.get('/api/claude-code/sessions/:sessionId/subagents', claudeSessionRoute(req => claudeSessionOps.subagents(req.params.sessionId, req.query.project)));
 app.get('/api/claude-code/sessions/:sessionId/subagents/:agentId/messages', claudeSessionRoute(req => claudeSessionOps.subagentMessages(req.params.sessionId, req.params.agentId, req.query.project)));
 
 // --- Session Messages (read JSONL for panel history) ---
 
+// The parsed transcripts of the last few sessions opened (lib/claude-history-cache.js).
+const claudeHistoryCache = createHistoryCache();
+// The Codex rollouts read last, parsed once for the early preview and the history fallback (lib/codex-rollout-reader.js).
+const codexRolloutReader = createRolloutReader();
+
 app.get('/api/claude-code/sessions/:sessionId/messages', async (req, res) => {
   try {
     const { sessionId } = req.params;
@@ -21514,22 +21761,17 @@ app.get('/api/claude-code/sessions/:sessionId/messages', async (req, res) => {
       return res.status(missing.status).json(missing.body);
     }
 
-    // Stream line-by-line — session JSONLs reach tens of MB and this endpoint
-    // fires on every session open; a whole-file readFileSync stalled the loop.
-    // Split on "\n" only: readline also breaks at U+2028 / U+2029, which are legal
-    // inside a JSON string, and the halves of such a line were silently dropped.
-    // Read from the canonical path that was checked, opened without following a link.
-    const rl = jsonlLines(openConfinedStream(found.realFolder, found.realPath, { encoding: 'utf-8' }));
+    // Session JSONLs reach tens of MB and one session open asks this route several times (the panel's
+    // snapshot probe, the rebuild, "load earlier", a clipped result): the collector of a transcript is
+    // kept, and a file that grew is parsed only from where the last read stopped (lib/claude-history-cache.js:
+    // whole lines split on "\n" only, read from the canonical path that was checked, opened without following
+    // a link).
     // Rows per transcript line: prompts (with their uuid), assistant text, thinking
     // and tool calls, tool results with their typed output (they live inside user
     // lines), compaction markers. The collector also follows the parentUuid chain,
     // so the branches a conversation rewind abandoned are left out: what is shown
     // is what the resumed model has. See lib/claude-history.js.
-    const collector = createHistoryCollector();
-    for await (const line of rl) {
-      if (!line.trim()) continue;
-      try { collector.add(JSON.parse(line)); } catch {}
-    }
+    const collector = await claudeHistoryCache.collectorFor(found);
 
     // `?tool=<tool_use_id>`: just that call's result (a restored snapshot holds
     // only the clipped text of a long result and asks for the rest).
@@ -21747,7 +21989,7 @@ app.get('/api/claude-code/integrations', (req, res) => {
 
 // POST /api/claude-code/integrations — enable hook for a target
 // Optional `hook` param: 'SessionStart' | 'UserPromptSubmit' (omit for both)
-app.post('/api/claude-code/integrations', (req, res) => {
+app.post('/api/claude-code/integrations', async (req, res) => {
   try {
     const { target, projectPath, label, hook } = req.body;
     // target: 'global' | 'project'
@@ -21817,7 +22059,7 @@ app.post('/api/claude-code/integrations', (req, res) => {
       let dubiousOwnership = false;
       let trustPath = null;
       try {
-        if (detectDubiousOwnership(normalized)) {
+        if (await detectDubiousOwnership(normalized)) {
           dubiousOwnership = true;
           trustPath = normalizeGitPath(normalized);
         }
@@ -22252,7 +22494,7 @@ app.delete('/api/claude-code/mcp', (req, res) => {
 });
 
 // ═══════════════════════════════════════════
-// Multi-Provider MCP Setup (Gemini, Codex)
+// Multi-Provider MCP Setup (Antigravity, Codex)
 // ═══════════════════════════════════════════
 
 // ── Minimal TOML helpers (for Codex config.toml) ──
@@ -22411,51 +22653,43 @@ function buildCodexMcpCliCommand() {
   return `codex mcp add SynaBun ${envArgs} -- node ${JSON.stringify(definition.args[0])}`;
 }
 
-// ── Gemini MCP endpoints ──
+// ── Antigravity MCP endpoints ──
+// ~/.gemini/config/mcp_config.json (lib/mcp-client-config.js): the file the Antigravity CLI and app share. A file that
+// is not a JSON object is never overwritten: the request fails and says so.
 
-app.get('/api/setup/gemini/mcp', (req, res) => {
+app.get('/api/setup/antigravity/mcp', (req, res) => {
   try {
-    const settingsPath = join(getHomePath(), '.gemini', 'settings.json');
-    if (!existsSync(settingsPath)) return res.json({ ok: true, connected: false });
-    const data = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-    const connected = !!(data.mcpServers && data.mcpServers.SynaBun);
-    res.json({ ok: true, connected });
+    const path = antigravityMcpConfigPath();
+    if (!existsSync(path)) return res.json({ ok: true, connected: false, path });
+    const data = readAntigravityMcpConfig();
+    const entry = data.mcpServers?.SynaBun;
+    res.json({ ok: true, connected: !!entry && entry.disabled !== true, disabled: entry?.disabled === true, path });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
-app.post('/api/setup/gemini/mcp', (req, res) => {
+app.post('/api/setup/antigravity/mcp', (req, res) => {
   try {
-    const dir = join(getHomePath(), '.gemini');
-    const settingsPath = join(dir, 'settings.json');
     const { envPath, mcpCommand, mcpArgs } = getMcpPaths();
-    mkdirSync(dir, { recursive: true });
-    let data = {};
-    try { data = JSON.parse(readFileSync(settingsPath, 'utf-8')); } catch {}
-    data = mergeGeminiMcpConfig(data, {
+    const data = mergeAntigravityMcpConfig(readAntigravityMcpConfig(), {
       command: mcpCommand,
       args: mcpArgs,
       env: { DOTENV_PATH: envPath, SYNABUN_DATA_HOME: DATA_HOME, MEMORY_DATA_DIR: resolve(DATA_HOME, 'mcp-data') },
     });
-    writeFileSync(settingsPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
-    res.json({ ok: true, message: 'SynaBun MCP registered in Gemini CLI. Restart Gemini to connect.', rules: syncRulesWithMcp('gemini', 'install', req.body) });
+    writeAntigravityMcpConfig(data);
+    res.json({ ok: true, message: 'SynaBun MCP registered in Antigravity. New Antigravity sessions connect to it.', rules: syncRulesWithMcp('antigravity', 'install', req.body) });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
-app.delete('/api/setup/gemini/mcp', (req, res) => {
+app.delete('/api/setup/antigravity/mcp', (req, res) => {
   try {
-    const settingsPath = join(getHomePath(), '.gemini', 'settings.json');
-    if (!existsSync(settingsPath)) return res.json({ ok: true, rules: syncRulesWithMcp('gemini', 'remove') });
-    const data = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-    if (data.mcpServers && data.mcpServers.SynaBun) {
-      delete data.mcpServers.SynaBun;
-      if (Object.keys(data.mcpServers).length === 0) delete data.mcpServers;
-      writeFileSync(settingsPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
-    }
-    res.json({ ok: true, message: 'SynaBun MCP removed from Gemini CLI.', rules: syncRulesWithMcp('gemini', 'remove') });
+    if (!existsSync(antigravityMcpConfigPath())) return res.json({ ok: true, rules: syncRulesWithMcp('antigravity', 'remove') });
+    const data = readAntigravityMcpConfig();
+    if (data.mcpServers && data.mcpServers.SynaBun) writeAntigravityMcpConfig(removeAntigravityMcpServer(data));
+    res.json({ ok: true, message: 'SynaBun MCP removed from Antigravity.', rules: syncRulesWithMcp('antigravity', 'remove') });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
@@ -22516,11 +22750,11 @@ app.get('/api/setup/status', (req, res) => {
     } catch {}
     claude.cliCommand = claudeMcpAddCommand(mcpPaths);
 
-    // Gemini
-    let gemini = { connected: false };
+    // Antigravity (~/.gemini/config/mcp_config.json)
+    let antigravity = { connected: false };
     try {
-      const gj = JSON.parse(readFileSync(join(home, '.gemini', 'settings.json'), 'utf-8'));
-      gemini.connected = !!(gj.mcpServers && gj.mcpServers.SynaBun);
+      const entry = readAntigravityMcpConfig().mcpServers?.SynaBun;
+      antigravity.connected = !!entry && entry.disabled !== true;
     } catch {}
 
     // Codex
@@ -22540,7 +22774,7 @@ app.get('/api/setup/status', (req, res) => {
     let rules = null;
     try { rules = rulesetInstaller.status(); } catch (err) { rules = { ok: false, error: err.message }; }
 
-    res.json({ ok: true, claude, gemini, codex, opencode, rules, paths: { mcpIndexPath, envPath, mcpCommand, mcpArgs } });
+    res.json({ ok: true, claude, antigravity, codex, opencode, rules, paths: { mcpIndexPath, envPath, mcpCommand, mcpArgs } });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
@@ -22640,7 +22874,7 @@ skillsService = createSkillsService({
   // its skill hints); invite guests do not (broadcastSync keeps `skills:` to the owner).
   broadcast: (event) => broadcastSync({ type: 'skills:changed', event }),
   // Which assistants are installed here (the CLI resolver), for the default of "My assistants" (Settings → Skills).
-  installedRuntimes: () => ({ claude: cliFoundForWarmup('claude-code'), codex: cliFoundForWarmup('codex'), opencode: cliFoundForWarmup('opencode') }),
+  installedRuntimes: () => ({ claude: cliFoundForWarmup('claude-code'), codex: cliFoundForWarmup('codex'), opencode: cliFoundForWarmup('opencode'), antigravity: cliFoundForWarmup('antigravity') }),
   runtimeChecks: skillsRuntimeChecks,
   operationsOptions: { notify: (item) => {
     const session = _assistantRuntime?.listSessions?.().find((s) => s.status !== 'ended');
@@ -22848,9 +23082,11 @@ function skillBrowserAvailability() {
     const unreadable = browserConfigUnreadable(cfg);
     if (unreadable) return { available: false, reason: `The browser settings cannot be read (${unreadable}): fix them in Settings → Browser.` };
     if (cfg.connectMode === 'morelogin') {
-      let installed = false;
-      try { installed = !!moreLogin.isMoreLoginInstalled().installed; } catch { installed = false; }
-      return installed ? { available: true, reason: null } : { available: false, reason: 'MoreLogin is the default browser (Settings → Browser) and it is not installed.' };
+      // The exe in a known folder, or the local API answered lately (an install in a custom folder). This is read
+      // synchronously, so a miss refreshes the answer in the background for the next call.
+      const installed = moreLogin.isMoreLoginPresent();
+      if (!installed) moreLogin.probeMoreLoginApi({ savedCfg: cfg, timeout: 1500 }).catch(() => {});
+      return installed ? { available: true, reason: null } : { available: false, reason: 'MoreLogin is the default browser (Settings → Browser) and it was not found: its app is in no known folder and its local API does not answer.' };
     }
     if ([...browserSessions.values()].some((s) => s?.context)) return { available: true, reason: null };
     if (findBrowserExecutable(cfg.channel)) return { available: true, reason: null };
@@ -22941,6 +23177,19 @@ async function skillSourceSessions({ provider, project = null, q = '', limit = 4
         out.push({ provider, sessionId: row.id, title, project: proj.path, projectLabel: proj.label || basename(proj.path), modified: row.time_updated ? new Date(row.time_updated).toISOString() : null, messages: Number(row.message_count) || 0 });
       }
     }
+  } else if (provider === 'antigravity') {
+    // The user's own Antigravity conversations (the panel's and a terminal agy's), as Resume's index keeps them,
+    // titled as Antigravity titles them (refreshAntigravityCatalog).
+    refreshAntigravityCatalog();
+    for (const entry of listSessionCache('antigravity', { limit: 100000 })) {
+      if (entry.deleted || !entry.project_path) continue;
+      const dir = resolve(entry.project_path);
+      const proj = projects.find((p) => isInside(resolve(p.path), dir, { allowRoot: true }));
+      if (!proj) continue;
+      const title = String(entry.first_prompt || '');
+      if (search && !title.toLowerCase().includes(search) && !String(entry.session_id).toLowerCase().includes(search)) continue;
+      out.push({ provider, sessionId: entry.session_id, title, project: proj.path, projectLabel: proj.label || basename(proj.path), modified: entry.modified || null, messages: Number(entry.message_count) || 0 });
+    }
   }
   return out.sort((a, b) => String(b.modified || '').localeCompare(String(a.modified || ''))).slice(0, Math.max(1, Math.min(100, Number(limit) || 40)));
 }
@@ -22948,7 +23197,8 @@ async function skillSourceSessions({ provider, project = null, q = '', limit = 4
 /**
  * One session transcript as messages, read the way each runtime keeps it: Claude Code's transcript inside a
  * registered project's folder (lib/path-confine.js findSessionTranscript), Codex's rollout inside its account's home,
- * OpenCode's rows of its database. Bounded: the first messages and the last ones of a very long session.
+ * OpenCode's rows of its database, Antigravity's transcript in the user's own ~/.gemini. Bounded: the first messages
+ * and the last ones of a very long session.
  */
 async function skillSourceConversation({ provider, sessionId, project = null }) {
   const keep = (list, m) => { list.push(m); if (list.length > 2400) list.splice(300, list.length - 2100); };
@@ -22991,6 +23241,16 @@ async function skillSourceConversation({ provider, sessionId, project = null })
     const rows = db.prepare(`SELECT type, data FROM session_message WHERE session_id = ? AND type IN ('user', 'assistant') ORDER BY seq ASC LIMIT 5000`).all(sessionId);
     return { title: session.title || '', project, messages: opencodeRowsToMessages(rows) };
   }
+  if (provider === 'antigravity') {
+    // The transcript in the user's own Antigravity folder (~/.gemini/antigravity-cli/brain/<id>/…), read as
+    // lib/antigravity/transcripts.js reads it: no link followed, bounded; never the model's reasoning.
+    const found = findUserConversation(sessionId);
+    if (!found) throw Object.assign(new Error('That Antigravity conversation was not found.'), { status: 404, code: 'source_not_found' });
+    const parsed = parseAntigravityTranscript(readTranscriptText(found.transcript));
+    const messages = [];
+    for (const m of antigravityMessagesToMessages(parsed.messages)) keep(messages, m);
+    return { title: found.title || parsed.firstPrompt || '', project: found.cwd || project, messages };
+  }
   throw Object.assign(new Error('Unknown provider.'), { status: 400, code: 'source_failed' });
 }
 
@@ -23078,7 +23338,8 @@ function getOpenCodeCommandDir() {
   return xdgDefault;
 }
 
-const SKILL_TARGETS = /** @type {const} */ (['claude', 'codex', 'opencode']);
+// Antigravity reads its user skills from ~/.gemini/config/skills (lib/skills/roots.js), installed like the others.
+const SKILL_TARGETS = /** @type {const} */ (['claude', 'codex', 'opencode', 'antigravity']);
 
 /** Where the old prompt / command bridge of a skill is (Codex, OpenCode), or null (Claude Code never had one). */
 function legacyBridgePath(target, skillName) {
@@ -23340,6 +23601,7 @@ function listAvailableSkills() {
     claude: isSkillInstalled('claude', dirName),
     codex: isSkillInstalled('codex', dirName),
     opencode: isSkillInstalled('opencode', dirName),
+    antigravity: isSkillInstalled('antigravity', dirName),
   });
   // What each runtime has of it: a native skill folder ('native'; 'modified' when changed since SynaBun installed
   // it; 'other' when it is not SynaBun's), and an old bridge not moved yet. `installedTargets` stays the one flag
@@ -23724,6 +23986,11 @@ app.post('/api/sidepanel/kill-session', async (req, res) => {
           killed = true;
         }
       }
+    } else if (provider === 'antigravity') {
+      // An Antigravity session lives in the `agy acp` of the panel socket that opened it, which ends with that
+      // socket: nothing outlives a closed panel, so there is nothing to kill here. Its conversation stays in
+      // Antigravity's own history (Resume lists it).
+      killed = false;
     } else if (provider === 'opencode') {
       // OpenCode sessions live on the OpenCode SDK server, not in an orphan
       // map — DELETE them via the proxy.
@@ -25276,7 +25543,7 @@ app.get('/api/mcp/platforms', (req, res) => {
     claudeCode: existsSync(join(home, '.claude.json')) || existsSync(join(home, '.claude')),
     opencode: existsSync(getOpencodeConfigDir()),
     codex: existsSync(join(home, '.codex')),
-    gemini: existsSync(join(home, '.gemini')),
+    antigravity: existsSync(antigravityConfigDir()) || existsSync(join(home, '.gemini', 'antigravity-cli')),
   });
 });
 
@@ -25393,7 +25660,7 @@ app.post('/api/mcp/install/github', async (req, res) => {
 });
 
 // GET /api/mcp/installed-all — unified view of every externally-installed MCP
-// across Claude Code / OpenCode / Codex / Gemini + SynaBun's registry + Claude Code plugins.
+// across Claude Code / OpenCode / Codex / Antigravity + SynaBun's registry + Claude Code plugins.
 // Excludes SynaBun's built-in tool-group servers (they're baked in, not "installed").
 app.get('/api/mcp/installed-all', (req, res) => {
   try {
@@ -25440,17 +25707,17 @@ app.get('/api/mcp/installed-all', (req, res) => {
       }
     } catch {}
 
-    // Gemini
+    // Antigravity (~/.gemini/config/mcp_config.json: a remote server is `serverUrl`)
     try {
-      const p = join(home, '.gemini', 'settings.json');
-      if (existsSync(p)) {
-        const data = JSON.parse(readFileSync(p, 'utf-8'));
+      if (existsSync(antigravityMcpConfigPath())) {
+        const data = readAntigravityMcpConfig();
         for (const [name, cfg] of Object.entries(data.mcpServers || {})) {
-          touch(name, 'gemini', {
-            transport: cfg.type || (cfg.url ? 'http' : 'stdio'),
-            command: cfg.command || null,
-            args: cfg.args || null,
-            url: cfg.url || null,
+          const seen = describeAntigravityMcpEntry(cfg);
+          touch(name, 'antigravity', {
+            transport: seen.transport,
+            command: seen.command || null,
+            args: seen.args?.length ? seen.args : null,
+            url: seen.url || null,
           });
         }
       }
@@ -25666,16 +25933,11 @@ async function internalMcpSync({ name, config, platforms }) {
         content = tomlUpsertSection(content, `mcp_servers.${name}`, kvPairs);
         writeFileSync(configPath, content, 'utf-8');
         results.codex = 'ok';
-      } else if (p === 'gemini') {
-        const dir = join(home, '.gemini');
-        const settingsPath = join(dir, 'settings.json');
-        mkdirSync(dir, { recursive: true });
-        let data = {};
-        try { data = JSON.parse(readFileSync(settingsPath, 'utf-8')); } catch {}
-        if (!data.mcpServers) data.mcpServers = {};
-        data.mcpServers[name] = buildGeminiMcpEntry(config);
-        writeFileSync(settingsPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
-        results.gemini = 'ok';
+      } else if (p === 'antigravity') {
+        const data = readAntigravityMcpConfig();
+        data.mcpServers = { ...(data.mcpServers || {}), [name]: buildAntigravityMcpEntry(config) };
+        writeAntigravityMcpConfig(data);
+        results.antigravity = 'ok';
       }
     } catch (err) {
       results[p] = `error: ${err.message}`;
@@ -25733,17 +25995,12 @@ app.delete('/api/mcp/sync', (req, res) => {
         }
         results.codex = 'ok';
 
-      } else if (p === 'gemini') {
-        const settingsPath = join(home, '.gemini', 'settings.json');
-        if (existsSync(settingsPath)) {
-          const data = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-          if (data.mcpServers?.[name]) {
-            delete data.mcpServers[name];
-            if (Object.keys(data.mcpServers).length === 0) delete data.mcpServers;
-            writeFileSync(settingsPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
-          }
+      } else if (p === 'antigravity') {
+        if (existsSync(antigravityMcpConfigPath())) {
+          const data = readAntigravityMcpConfig();
+          if (data.mcpServers?.[name]) writeAntigravityMcpConfig(removeAntigravityMcpServer(data, name));
         }
-        results.gemini = 'ok';
+        results.antigravity = 'ok';
       }
     } catch (err) {
       results[p] = `error: ${err.message}`;
@@ -26160,9 +26417,11 @@ const CLI_CONFIG_PATH = resolve(DATA_HOME, 'data', 'cli-config.json');
 const CLI_DEFAULTS = {
   'claude-code': { command: 'claude' },
   'codex':       { command: 'codex' },
-  'gemini':      { command: 'gemini' },
+  'antigravity': { command: 'agy' },
   'opencode':    { command: 'opencode' },
 };
+// Profiles SynaBun no longer drives: a path saved for one (Gemini CLI, replaced by Antigravity) is never a profile.
+const RETIRED_CLI_PROFILES = new Set(['gemini']);
 
 // Parsed cli-config.json keyed by mtime — every terminal spawn resolves its
 // profile through here, so skip the read + parse when the file is unchanged.
@@ -26175,7 +26434,9 @@ function loadCliConfig() {
     if (!_cliConfigCache || _cliConfigCache.mtimeMs !== mtimeMs) {
       _cliConfigCache = { mtimeMs, raw: JSON.parse(readFileSync(CLI_CONFIG_PATH, 'utf-8')) };
     }
-    return { ...CLI_DEFAULTS, ...structuredClone(_cliConfigCache.raw) };
+    const saved = structuredClone(_cliConfigCache.raw);
+    for (const retired of RETIRED_CLI_PROFILES) delete saved?.[retired];
+    return { ...CLI_DEFAULTS, ...saved };
   } catch { return { ...CLI_DEFAULTS }; }
 }
 
@@ -26196,7 +26457,7 @@ const SHELL_PROFILE = { shell: DEFAULT_SHELL, args: interactiveShellArgs(), env:
 /**
  * Build terminal profile config dynamically from cli-config.json.
  * Re-reads config each call so changes take effect without restart.
- * @param {string} profileId - CLI profile ID (e.g. 'claude-code', 'codex', 'gemini', 'shell')
+ * @param {string} profileId - CLI profile ID (e.g. 'claude-code', 'codex', 'antigravity', 'shell')
  * @param {Object} [opts] - Optional overrides
  * @param {string} [opts.model] - Model flag for CLIs that support it (e.g. claude --model sonnet)
  */
@@ -26219,6 +26480,8 @@ function getTerminalProfile(profileId, opts = {}) {
     cmd = `${cmd} resume ${terminalArgument(opts.resume, DEFAULT_SHELL)}`;
   } else if (opts.resume && profileId === 'opencode') {
     cmd = `${cmd} -s ${terminalArgument(opts.resume, DEFAULT_SHELL)}`;
+  } else if (opts.resume && profileId === 'antigravity') {
+    cmd = `${cmd} --conversation ${terminalArgument(opts.resume, DEFAULT_SHELL)}`;
   }
   // Append model flag for CLIs that support it
   else if (opts.model) {
@@ -26236,7 +26499,7 @@ function getTerminalProfile(profileId, opts = {}) {
     const modelMap = {
       'claude-code': (m) => `${cmd} --model ${m}`,
       'codex':       (m) => `${cmd} --model ${m}`,
-      'gemini':      (m) => `${cmd} --model ${m}`,
+      'antigravity': (m) => `${cmd} --model ${m}`,
       // OpenCode's terminal app has no --model (it prints its help and exits): the model is picked in it.
       'opencode':    () => cmd,
     };
@@ -26254,6 +26517,9 @@ function getTerminalProfile(profileId, opts = {}) {
     if (codexEffort) {
       cmd = `${cmd} -c model_reasoning_effort="${codexEffort}"`;
     }
+  } else if (opts.effort && profileId === 'antigravity') {
+    // agy --effort: low | medium | high | xhigh | max (the model's own default when the flag is left out).
+    if (['low', 'medium', 'high', 'xhigh', 'max'].includes(opts.effort)) cmd = `${cmd} --effort ${opts.effort}`;
   }
   // Every Codex terminal: the Windows sandbox the Admin sandbox setting allows. A bare value
   // (Codex reads one that is not TOML as a string), so no shell can strip a quote from it.
@@ -26265,7 +26531,7 @@ function getTerminalProfile(profileId, opts = {}) {
   // The loop runs in a PTY with no human to answer prompts, so accessing
   // sibling projects or running Bash/Write would stall.
   // Scoped to opts.loopBypass so interactive terminal sessions still prompt.
-  if (opts.loopBypass && profileId === 'claude-code') {
+  if (opts.loopBypass && (profileId === 'claude-code' || profileId === 'antigravity')) {
     cmd = `${cmd} --dangerously-skip-permissions`;
   }
 
@@ -26294,7 +26560,7 @@ function getTerminalProfile(profileId, opts = {}) {
 // provider sign-in terminals. The desktop app uses this same server/PTY host.
 async function freshTerminalPath(base = process.env) {
   const os = await osPath.refresh({ force: true });
-  const launchers = ['claude-code', 'codex', 'opencode', 'gemini'].map(tool => cliResolver.launcher(tool));
+  const launchers = ['claude-code', 'codex', 'opencode', 'antigravity'].map(tool => cliResolver.launcher(tool));
   // A packaged application's runtime and npm's global bin (rememberPackagedPath above), after the user's own.
   const { last: synabunDirs, extra: extraDirs } = rememberedPackagedPath();
   return { ...composeTerminalPath({ env: base, os, launchers, synabunDirs, extraDirs }), os, launchers };
@@ -26861,7 +27127,7 @@ async function driveNextIteration(session, loopState, filename) {
   return true;
 }
 
-// ── Exec-based Loop Driver (Codex, Gemini, etc.) ──
+// ── Exec-based Loop Driver (Codex, Antigravity, etc.) ──
 // Fully isolated from Claude's hook-based driver. Runs platform-native wrapper
 // files inside a shell PTY and detects completion via sentinel echo markers.
 // The wrapper captures the CLI status before printing SYNABUN_ITER_DONE_<N>, so
@@ -27191,6 +27457,31 @@ _nativeLoopRuntime = new NativeLoopRuntime({
         policyRoots: taskBrowserPolicyRoots(state),
       });
     },
+    // Google Antigravity: one `agy acp` per run (lib/native-loop-providers.js createAntigravityNativeLoopAdapter), in
+    // the run's own Antigravity home (lib/antigravity/home.js: exactly the run's MCP servers, the policy hook that
+    // asks POST /api/antigravity/policy before every tool call, the user's rules and skills). Approvals go to the
+    // Assistant's broker under `ask`; without an installed CLI the run fails at once with the install hint.
+    antigravity: (state) => {
+      const launch = antigravityLaunch();
+      if (!launch) throw new Error('Antigravity runs need the Antigravity CLI (agy). Install it from the Antigravity side panel (one click), or run `brew install --cask antigravity-cli` (macOS) or `curl -fsSL https://antigravity.google/cli/install.sh | bash` (Windows: `irm https://antigravity.google/cli/install.ps1 | iex`), sign in by running `agy` once, then try again.');
+      // A resumed run uses the home its first start wrote (its conversation is there).
+      const homeDir = state.resumingWorker && typeof state.antigravityHome === 'string' && state.antigravityHome
+        ? validateRunHome(state.antigravityHome, antigravityHomesRoot(DATA_HOME))
+        : antigravityHomeFor('run', state.runId || state.terminalSessionId || `loop-${Date.now()}`);
+      return createAntigravityNativeLoopAdapter({
+        ...state,
+        launch,
+        // The PATH a new terminal has: Antigravity runs the user's own tools.
+        extraEnv: { PATH: antigravityChildEnv().PATH, ...(state.extraEnv || {}) },
+        serverPort: PORT,
+        homeDir,
+        synabunMcpEntry: antigravitySynabunMcpEntry(),
+        policy: defaultAntigravityPolicy,
+        policyUrl: antigravityPolicyUrl(),
+        // Assistant task runs: where the browser policy lets its test runners run besides its own project.
+        policyRoots: taskBrowserPolicyRoots(state),
+      });
+    },
     opencode: async (state) => {
       // An OpenCode SynaBun does not drive: the run fails with the sentence before its configuration folder, its
       // sandbox profile or its serve exist (a loop or a schedule was refused already; this is a worker's, a backstop).
@@ -27239,6 +27530,7 @@ _nativeLoopRuntime = new NativeLoopRuntime({
         state.model,
         {
           SYNABUN_DESKTOP_GRANT: typeof state.desktopGrantProvider === 'function' ? state.desktopGrantProvider() : null,
+          SYNABUN_RUN_MODE: state.runMode === 'task' ? 'task' : null,
         },
         // Assistant task runs: the browser policy plugin (loops and schedules unchanged) with the registered code
         // projects its test runners may run in (the sandboxed serve cannot read the registry), and the run's confinement
@@ -27819,6 +28111,17 @@ _nativeLoopRuntime = new NativeLoopRuntime({
       ClaudeSession: claudeBridgeModule.ClaudeSession,
       sdkVersion: claudeBridgeModule.SDK_VERSION,
       handleCodexSkinWebSocket, ensureIsolatedServe, stopIsolatedServe, setupOpencodeSidepanelConfig,
+      // An Antigravity brain (lib/assistant-brains/antigravity.js): `agy acp` in the brain's own home, its hook asking
+      // POST /api/antigravity/policy, SynaBun's MCP entry the Setup card writes.
+      antigravity: {
+        launch: antigravityLaunch,
+        // The PATH a new terminal has (agy runs the user's tools); never the owner's live data paths or a credential.
+        childEnv: antigravityChildEnv,
+        home: (sessionId) => antigravityHomeFor('brain', sessionId),
+        synabunMcpEntry: antigravitySynabunMcpEntry,
+        policy: defaultAntigravityPolicy,
+        policyUrl: antigravityPolicyUrl,
+      },
       broadcastSync,
       dataDir: LOOP_DATA_DIR,
       memory: assistantMemory,
@@ -28196,7 +28499,7 @@ function findLoopFileForTerminal(terminalSessionId) {
 }
 
 /**
- * Exec-based loop driver for non-Claude CLIs (Codex, Gemini, etc.).
+ * Exec-based loop driver for non-Claude CLIs (Codex, Antigravity, etc.).
  * State machine: booting → ready → running → ready → ...
  *
  * Completion detection: sentinel echo approach.
@@ -28972,7 +29275,7 @@ app.delete('/api/terminal/sessions/:id', (req, res) => {
 });
 
 app.get('/api/terminal/profiles', (req, res) => {
-  const profileIds = ['claude-code', 'codex', 'gemini', 'opencode', 'shell'];
+  const profileIds = ['claude-code', 'codex', 'antigravity', 'opencode', 'shell'];
   const profiles = profileIds.map(id => {
     const p = getTerminalProfile(id);
     return { id, shell: p.shell, args: p.args };
@@ -29056,30 +29359,15 @@ function resolveGitPath() {
 }
 
 // Cross-platform git invocation. Uses resolved absolute path when possible (spawnable
-// directly on all OSes with no shell/quoting pitfalls). Falls back to `shell: true` on
-// Windows only when path resolution fails or when the resolved target is a .cmd/.bat shim.
-function spawnGit(args, opts = {}) {
-  const baseOpts = { stdio: 'pipe', timeout: 5000, windowsHide: true, ...opts };
-  const gitPath = resolveGitPath();
-  if (gitPath) {
-    if (IS_WINDOWS && /\.(cmd|bat)$/i.test(gitPath)) {
-      const quoted = args.map(a => /[\s()%&|<>^"']/.test(a) ? `"${String(a).replace(/"/g, '\\"')}"` : a);
-      return spawnSync(gitPath, quoted, { ...baseOpts, shell: true });
-    }
-    return spawnSync(gitPath, args, baseOpts);
-  }
-  if (IS_WINDOWS) {
-    const quoted = args.map(a => /[\s()%&|<>^"']/.test(a) ? `"${String(a).replace(/"/g, '\\"')}"` : a);
-    return spawnSync('git', quoted, { ...baseOpts, shell: true });
-  }
-  return spawnSync('git', args, baseOpts);
+// directly without a shell). The runner handles a resolved Windows .cmd/.bat shim.
+async function spawnGit(args, opts = {}) {
+  const binary = await resolveGitPathInBackground();
+  return gitStatusRunner.runRaw(args, { ...opts, binary: binary || 'git', timeoutMs: opts.timeout || 5000 });
 }
 
-// spawnGit for a command that only reads, in a folder a request named: nothing the repository's own configuration
-// names is started for it (lib/git-read.js: no file system monitor program, no hook, no external diff, no fetch).
-function spawnGitRead(args, opts = {}) {
-  const read = gitReadSync(opts.cwd, args, { env: opts.env });
-  return spawnGit(read.args, { ...opts, env: read.env });
+async function spawnGitRead(args, opts = {}) {
+  const binary = await resolveGitPathInBackground();
+  return gitStatusRunner.run(args, { ...opts, binary: binary || 'git', timeoutMs: opts.timeout || 5000 });
 }
 
 function logGitFailure(where, err) {
@@ -29118,22 +29406,20 @@ function resolveGitPathInBackground() {
 
 // Startup probe — always logs git status so Windows users can see whether git works at all. Asynchronous:
 // after the lookup above, one `git --version` (no folder, no repository's configuration) off the event loop.
-setImmediate(() => {
-  resolveGitPathInBackground().then((gitPath) => new Promise((done) => {
-    const shell = IS_WINDOWS && (!gitPath || /\.(cmd|bat)$/i.test(gitPath));
-    execFile(gitPath || 'git', ['--version'], { encoding: 'utf8', timeout: 3000, windowsHide: true, shell }, (error, stdout, stderr) => {
-      if (!error) console.log(`[git] ${String(stdout || '').trim()} — OK`);
-      else console.warn(`[git] startup probe FAILED: ${String(stderr || '').trim() || error.message || 'unknown error'}. File explorer git UI will be hidden.`);
-      done();
-    });
-  })).catch(() => {});
+setImmediate(async () => {
+  try {
+    const gitPath = await resolveGitPathInBackground();
+    const result = await gitStatusRunner.run(['--version'], { binary: gitPath || 'git', timeoutMs: 3000 });
+    if (result.ok) console.log(`[git] ${String(result.stdout).trim()} — OK`);
+    else console.warn(`[git] startup probe FAILED: ${String(result.stderr).trim() || result.code}. File explorer git UI will be hidden.`);
+  } catch { /* availability is reported on the first read */ }
 });
 
 // Git "dubious ownership" detection — CVE-2022-24765 safety check refuses to operate on
 // repos owned by a different OS user/SID. Common on Windows external drives or repos
 // copied from another machine. Returns true only when git emits the specific error.
-function detectDubiousOwnership(dir) {
-  const r = spawnGitRead(['rev-parse', '--is-inside-work-tree'], { cwd: dir, timeout: 3000 });
+async function detectDubiousOwnership(dir) {
+  const r = await spawnGitRead(['rev-parse', '--is-inside-work-tree'], { cwd: dir, timeout: 3000 });
   if (r.status === 0) return false;
   const stderr = r.stderr?.toString?.() || '';
   return /dubious ownership|safe\.directory/i.test(stderr);
@@ -29146,91 +29432,27 @@ function normalizeGitPath(dir) {
 }
 
 /** Try to get git status for a directory. Returns { branch, statuses } or null. */
-function getGitInfo(dir) {
-  // Check if inside a git work tree (spawnGit for consistent path resolution)
-  const inside = spawnGitRead(['rev-parse', '--is-inside-work-tree'], { cwd: dir, timeout: 3000 });
-  if (inside.status !== 0) {
-    logGitFailure('rev-parse --is-inside-work-tree', inside.error || { stderr: inside.stderr });
-    return null;
-  }
-
-  // Get branch name — try --show-current first (git 2.22+), then fall back to
-  // --abbrev-ref HEAD (works on older git; detached HEAD returns the literal "HEAD"),
-  // then short SHA for detached HEAD. The chained fallback is essential for Windows users
-  // with older Git for Windows installs where --show-current exits non-zero.
-  let branch = '';
-  const showCurrent = spawnGitRead(['branch', '--show-current'], { cwd: dir, timeout: 3000 });
-  if (showCurrent.status === 0) {
-    branch = showCurrent.stdout.toString().trim();
-  } else {
-    logGitFailure('branch --show-current', showCurrent.error || { stderr: showCurrent.stderr });
-  }
-  if (!branch) {
-    const abbrev = spawnGitRead(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: dir, timeout: 3000 });
-    if (abbrev.status === 0) {
-      const b = abbrev.stdout.toString().trim();
-      if (b && b !== 'HEAD') branch = b;
-    }
-  }
-  if (!branch) {
-    const shortSha = spawnGitRead(['rev-parse', '--short', 'HEAD'], { cwd: dir, timeout: 3000 });
-    if (shortSha.status === 0) branch = shortSha.stdout.toString().trim();
+async function getGitInfo(dir, options = {}) {
+  const result = projectStatus(await gitStatusRunner.read(dir, options), dir);
+  if (!result.isGit) return null;
+  const statuses = new Map();
+  for (const change of result.changes) {
+    const child = change.path.split('/')[0];
+    if (gitStatusPriority(change.status) > gitStatusPriority(statuses.get(child))) statuses.set(child, change.status);
   }
+  return { branch: result.branch, statuses, scanState: result.timedOut ? 'timed-out' : result.ok ? 'ready' : 'failed' };
+}
 
-  try {
-    // Get status for this directory (porcelain v1: XY <path>)
-    const statusResult = spawnGitRead(['status', '--porcelain', '-u', '.'], { cwd: dir, maxBuffer: 256 * 1024 * 1024 });
-    if (statusResult.status !== 0) {
-      logGitFailure('status --porcelain', statusResult.error || { stderr: statusResult.stderr });
-      return { branch, statuses: new Map() };
-    }
-    const raw = statusResult.stdout.toString();
-    const statuses = new Map(); // name → status code
-
-    for (const line of raw.split('\n')) {
-      if (!line || line.length < 4) continue;
-      const xy = line.substring(0, 2); // index + worktree status
-      let filePath = line.substring(3);
-      // Handle renames: "R  old -> new"
-      const arrowIdx = filePath.indexOf(' -> ');
-      if (arrowIdx !== -1) filePath = filePath.substring(arrowIdx + 4);
-
-      // Get the immediate child name relative to this directory
-      const sep = filePath.indexOf('/');
-      const childName = sep === -1 ? filePath : filePath.substring(0, sep);
-
-      // Map XY to a simplified status
-      let status;
-      const x = xy[0], y = xy[1];
-      if (xy === '??') status = 'untracked';
-      else if (xy === '!!') continue; // ignored
-      else if (x === 'U' || y === 'U' || xy === 'DD' || xy === 'AA') status = 'conflict';
-      else if (x === 'A') status = 'added';
-      else if (x === 'D' || y === 'D') status = 'deleted';
-      else if (x === 'R') status = 'renamed';
-      else if (x !== ' ' && y !== ' ') status = 'mixed'; // staged + unstaged changes
-      else if (x !== ' ') status = 'staged';
-      else if (y !== ' ') status = 'modified';
-      else continue;
-
-      // For directories: escalate priority (conflict > modified > staged > added > untracked)
-      const existing = statuses.get(childName);
-      if (!existing || gitStatusPriority(status) > gitStatusPriority(existing)) {
-        statuses.set(childName, status);
-      }
-    }
-
-    return { branch, statuses };
-  } catch (err) {
-    logGitFailure('getGitInfo status-parse', err);
-    return { branch, statuses: new Map() };
-  }
+function gitRequestSignal(res) {
+  const controller = new AbortController();
+  res.once('close', () => controller.abort());
+  return controller.signal;
 }
 
 const GIT_STATUS_PRIORITY = { untracked: 1, added: 2, renamed: 2, staged: 3, modified: 4, mixed: 5, deleted: 5, conflict: 6 };
 function gitStatusPriority(s) { return GIT_STATUS_PRIORITY[s] || 0; }
 
-app.get('/api/terminal/files', (req, res) => {
+app.get('/api/terminal/files', async (req, res) => {
   const dir = req.query.path;
   if (!dir || typeof dir !== 'string') return res.status(400).json({ error: 'path required' });
   const search = (req.query.search || '').trim().toLowerCase();
@@ -29287,7 +29509,7 @@ app.get('/api/terminal/files', (req, res) => {
     });
 
     // Try git — gracefully ignored if unavailable
-    const git = getGitInfo(dir);
+    const git = await getGitInfo(dir, { signal: gitRequestSignal(res) });
     if (git) {
       for (const item of items) {
         const s = git.statuses.get(item.name);
@@ -29301,11 +29523,11 @@ app.get('/api/terminal/files', (req, res) => {
   }
 });
 
-app.get('/api/terminal/branches', (req, res) => {
+app.get('/api/terminal/branches', async (req, res) => {
   const dir = req.query.path;
   if (!dir || typeof dir !== 'string') return res.status(400).json({ error: 'path required' });
 
-  const inside = spawnGitRead(['rev-parse', '--is-inside-work-tree'], { cwd: dir, timeout: 3000 });
+  const inside = await spawnGitRead(['rev-parse', '--is-inside-work-tree'], { cwd: dir, timeout: 3000 });
   if (inside.status !== 0) {
     logGitFailure('branches: rev-parse', inside.error || { stderr: inside.stderr });
     return res.json({ branches: [], current: null });
@@ -29314,11 +29536,11 @@ app.get('/api/terminal/branches', (req, res) => {
   try {
     // Current branch — chained fallback (older git may not support --show-current)
     let current = '';
-    const showCurrent = spawnGitRead(['branch', '--show-current'], { cwd: dir, timeout: 3000 });
+    const showCurrent = await spawnGitRead(['branch', '--show-current'], { cwd: dir, timeout: 3000 });
     if (showCurrent.status === 0) current = showCurrent.stdout.toString().trim();
     else logGitFailure('branches: show-current', showCurrent.error || { stderr: showCurrent.stderr });
     if (!current) {
-      const abbrev = spawnGitRead(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: dir, timeout: 3000 });
+      const abbrev = await spawnGitRead(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: dir, timeout: 3000 });
       if (abbrev.status === 0) {
         const b = abbrev.stdout.toString().trim();
         if (b && b !== 'HEAD') current = b;
@@ -29327,7 +29549,7 @@ app.get('/api/terminal/branches', (req, res) => {
 
     // All local branches — plain `git branch` parsed manually; avoids --format=%(refname:short)
     // which can get mangled by cmd.exe variable expansion on Windows even with proper quoting.
-    const branchResult = spawnGitRead(['branch'], { cwd: dir });
+    const branchResult = await spawnGitRead(['branch'], { cwd: dir });
     if (branchResult.status !== 0) logGitFailure('branch list', branchResult.error || { stderr: branchResult.stderr });
     const raw = branchResult.status === 0 ? branchResult.stdout.toString() : '';
     // Plain `git branch` output: each line is "  branch" or "* branch" (current). Strip
@@ -29345,7 +29567,7 @@ app.get('/api/terminal/branches', (req, res) => {
 // Trust a workspace path with git — runs `git config --global --add safe.directory <path>`
 // so git stops refusing to operate on it (CVE-2022-24765 dubious-ownership protection).
 // Triggered by the add-project UI flows when the server detects the dubious-ownership error.
-app.post('/api/terminal/trust-workspace', (req, res) => {
+app.post('/api/terminal/trust-workspace', async (req, res) => {
   const { path: dir } = req.body || {};
   if (!dir || typeof dir !== 'string') return res.status(400).json({ ok: false, error: 'path required' });
   if (/[\x00-\x1f]/.test(dir) || dir === '*' || dir === '/' || dir === '\\') {
@@ -29361,7 +29583,7 @@ app.post('/api/terminal/trust-workspace', (req, res) => {
   }
 
   const gitPath = normalizeGitPath(abs);
-  const r = spawnGit(['config', '--global', '--add', 'safe.directory', gitPath]);
+  const r = await spawnGit(['config', '--global', '--add', 'safe.directory', gitPath]);
   if (r.status !== 0) {
     const stderr = r.stderr?.toString?.()?.trim() || r.error?.message || 'git config failed';
     logGitFailure('config --add safe.directory', r.error || { stderr: r.stderr });
@@ -29369,12 +29591,12 @@ app.post('/api/terminal/trust-workspace', (req, res) => {
   }
 
   // Confirm by re-probing
-  const stillDubious = detectDubiousOwnership(abs);
+  const stillDubious = await detectDubiousOwnership(abs);
   console.log(`[git] trusted workspace: ${gitPath}${stillDubious ? ' (but still flagged — check permissions)' : ''}`);
   res.json({ ok: true, path: gitPath, stillDubious });
 });
 
-app.post('/api/terminal/checkout', (req, res) => {
+app.post('/api/terminal/checkout', async (req, res) => {
   const { path: dir, branch } = req.body;
   if (!dir || !branch) return res.status(400).json({ error: 'path and branch required' });
 
@@ -29383,7 +29605,7 @@ app.post('/api/terminal/checkout', (req, res) => {
     return res.status(400).json({ error: 'Invalid branch name' });
   }
 
-  const inside = spawnGitRead(['rev-parse', '--is-inside-work-tree'], { cwd: dir, timeout: 3000 });
+  const inside = await spawnGitRead(['rev-parse', '--is-inside-work-tree'], { cwd: dir, timeout: 3000 });
   if (inside.status !== 0) {
     logGitFailure('checkout: rev-parse', inside.error || { stderr: inside.stderr });
     return res.status(400).json({ error: 'Not a git repository' });
@@ -29393,7 +29615,8 @@ app.post('/api/terminal/checkout', (req, res) => {
   // No '--' separator — that would make git treat the branch name as a file pathspec.
   // (The switch itself is a write and runs plainly, with the repository's post-checkout hook; the two questions
   // around it are reads.)
-  const result = spawnGit(['checkout', branch], { cwd: dir, timeout: 10000 });
+  const result = await spawnGit(['checkout', branch], { cwd: dir, timeout: 10000 });
+  gitStatusRunner.invalidate(dir);
   if (result.status !== 0) {
     const stderr = result.stderr?.toString?.()?.trim() || result.error?.message || 'Checkout failed';
     return res.status(500).json({ error: stderr });
@@ -29401,71 +29624,21 @@ app.post('/api/terminal/checkout', (req, res) => {
 
   // Return confirmed branch name + git's own output
   let current = '';
-  const showCurrent = spawnGitRead(['branch', '--show-current'], { cwd: dir, timeout: 3000 });
+  const showCurrent = await spawnGitRead(['branch', '--show-current'], { cwd: dir, timeout: 3000 });
   if (showCurrent.status === 0) current = showCurrent.stdout.toString().trim();
   else logGitFailure('checkout: show-current', showCurrent.error || { stderr: showCurrent.stderr });
   const output = result.stderr?.toString?.()?.trim() || `Switched to branch '${current}'`;
   res.json({ ok: true, branch: current, output });
 });
 
-// Polled by the file explorer — run git via async execFile (never blocks the
-// event loop) and memoize per path for 1.5s so rapid polls share one result.
-const _gitStatusCache = new Map(); // dir -> { at, promise }
-const GIT_STATUS_TTL_MS = 1500;
-
-async function computeGitStatus(dir) {
-  // Each of these only reads: run as lib/git-read.js runs a read, so nothing the folder's own git configuration
-  // names is started (the route takes any folder).
-  const read = async (args, options) => {
-    const safe = await gitRead(dir, args);
-    return execFileAsync('git', safe.args, { cwd: dir, env: safe.env, ...options });
-  };
-  try {
-    await read(['rev-parse', '--is-inside-work-tree'], { timeout: 3000 });
-  } catch {
-    return { ok: true, isGit: false, branch: null, changes: [] };
-  }
-
-  const resolveBranch = async () => {
-    try {
-      const { stdout } = await read(['branch', '--show-current'], { timeout: 3000 });
-      let branch = stdout.trim();
-      if (!branch) {
-        const { stdout: head } = await read(['rev-parse', '--short', 'HEAD'], { timeout: 3000 });
-        branch = head.trim();
-      }
-      return branch;
-    } catch { return ''; }
-  };
-
-  const [branch, statusOut] = await Promise.all([
-    resolveBranch(),
-    read(['status', '--porcelain'], { timeout: 5000, maxBuffer: 256 * 1024 * 1024 }),
-  ]);
-
-  const changes = [];
-  for (const line of statusOut.stdout.split('\n')) {
-    if (!line || line.length < 4) continue;
-    const xy = line.substring(0, 2);
-    let filePath = line.substring(3);
-    const arrowIdx = filePath.indexOf(' -> ');
-    if (arrowIdx !== -1) filePath = filePath.substring(arrowIdx + 4);
-    const x = xy[0], y = xy[1];
-    let staged = x !== ' ' && x !== '?';
-    let status;
-    if (xy === '??') status = 'untracked';
-    else if (xy === '!!') continue;
-    else if (x === 'U' || y === 'U' || xy === 'DD' || xy === 'AA') status = 'conflict';
-    else if (x === 'A') status = 'added';
-    else if (x === 'D' || y === 'D') status = 'deleted';
-    else if (x === 'R') status = 'renamed';
-    else if (x !== ' ' && y !== ' ') status = 'mixed';
-    else if (x !== ' ') status = 'staged';
-    else status = 'modified';
-    changes.push({ path: filePath, status, staged });
-  }
-
-  return { ok: true, isGit: true, branch, changes };
+// All callers share the canonical worktree's flight and last completed result.
+async function computeGitStatus(dir, options = {}) {
+  const result = projectStatus(await gitStatusRunner.read(dir, options), dir);
+  if (!result.ok || result.partial || result.stale) return { ok: false, isGit: !!result.isGit, branch: result.branch, changes: result.changes || [],
+    partial: true, stale: !!result.stale, timedOut: !!result.timedOut, retryAt: result.retryAt,
+    scanState: result.timedOut ? 'timed-out' : 'failed', error: 'Git status is incomplete. Refresh before switching branches or assuming the worktree is clean.' };
+  if (!result.isGit) return { ok: true, isGit: false, branch: null, changes: [] };
+  return { ok: true, isGit: true, branch: result.branch, changes: result.changes };
 }
 
 // The folder a git route is asked about: inside a registered folder, as the disk resolves it (the rule of
@@ -29479,11 +29652,9 @@ function registeredGitFolder(asked, res) {
 // be started, failed or took too long, as the command lines the /api/git routes used to run did. For reads only
 // (every caller is one): run as lib/git-read.js runs a read, so no program the repository's own configuration
 // names is started. `git add` and `git commit` are not run through here: a commit keeps the repository's hooks.
-function gitOutput(dir, args, { timeout = 5000, maxBuffer } = {}) {
-  const read = gitReadSync(dir, args);
-  const result = spawnSync('git', read.args, { cwd: dir, env: read.env, stdio: 'pipe', timeout, windowsHide: true, ...(maxBuffer ? { maxBuffer } : {}) });
-  if (result.error) throw result.error;
-  if (result.status !== 0) throw new Error(result.stderr?.toString?.()?.trim?.() || `git ${args[0]} failed`);
+async function gitOutput(dir, args, { timeout = 5000, maxBuffer } = {}) {
+  const result = await gitStatusRunner.run(args, { cwd: dir, timeoutMs: timeout, ...(maxBuffer ? { maxBuffer } : {}) });
+  if (!result.ok) throw new Error(result.stderr?.toString?.()?.trim?.() || `git ${args[0]} failed`);
   return result.stdout.toString();
 }
 
@@ -29493,37 +29664,17 @@ function gitOutput(dir, args, { timeout = 5000, maxBuffer } = {}) {
 app.get('/api/git/status', editorOwnerGuard, async (req, res) => {
   const dir = req.query.path;
   if (!dir || typeof dir !== 'string') return res.status(400).json({ error: 'path required' });
-
-  let entry = _gitStatusCache.get(dir);
-  if (!entry || Date.now() - entry.at >= GIT_STATUS_TTL_MS) {
-    const promise = computeGitStatus(dir);
-    entry = { at: Date.now(), promise };
-    _gitStatusCache.set(dir, entry);
-    // Failed computations shouldn't be served for the rest of the TTL.
-    promise.catch(() => {
-      if (_gitStatusCache.get(dir)?.promise === promise) _gitStatusCache.delete(dir);
-    });
-    // Keep the map bounded across many distinct paths.
-    if (_gitStatusCache.size > 100) {
-      const cutoff = Date.now() - 60_000;
-      for (const [k, v] of _gitStatusCache) if (v.at < cutoff) _gitStatusCache.delete(k);
-    }
-  }
-
-  try {
-    res.json(await entry.promise);
-  } catch (err) {
-    res.status(500).json({ error: err.stderr?.toString?.()?.trim?.() || err.message });
-  }
+  if (req.query.refresh === '1') gitStatusRunner.invalidate(dir, { refresh: true });
+  res.json(await computeGitStatus(dir, { signal: gitRequestSignal(res) }));
 });
 
-app.post('/api/git/commit', editorOwnerGuard, (req, res) => {
+app.post('/api/git/commit', editorOwnerGuard, async (req, res) => {
   const { path: dir, message, files } = req.body;
   if (!dir || typeof dir !== 'string' || !message) return res.status(400).json({ error: 'path and message required' });
   if (typeof message !== 'string' || message.trim().length === 0) return res.status(400).json({ error: 'Commit message cannot be empty' });
 
   try {
-    gitOutput(dir, ['rev-parse', '--is-inside-work-tree'], { timeout: 3000 });
+    await gitOutput(dir, ['rev-parse', '--is-inside-work-tree'], { timeout: 3000 });
   } catch {
     return res.status(400).json({ error: 'Not a git repository' });
   }
@@ -29535,16 +29686,19 @@ app.post('/api/git/commit', editorOwnerGuard, (req, res) => {
       for (const f of files) {
         if (typeof f !== 'string' || f.includes('..')) return res.status(400).json({ error: 'Invalid file path' });
       }
-      const result = spawnSync('git', ['add', '--', ...files], { cwd: dir, env: withGitFallback(process.env), stdio: 'pipe', timeout: 10000 });
+      const result = await gitStatusRunner.runRaw(['add', '--', ...files], { cwd: dir, timeoutMs: 10000 });
+      gitStatusRunner.invalidate(dir);
       if (result.status !== 0) return res.status(500).json({ error: result.stderr?.toString?.()?.trim() || 'Stage failed' });
     } else {
       // Stage all changes
-      const result = spawnSync('git', ['add', '-A'], { cwd: dir, env: withGitFallback(process.env), stdio: 'pipe', timeout: 10000 });
+      const result = await gitStatusRunner.runRaw(['add', '-A'], { cwd: dir, timeoutMs: 10000 });
+      gitStatusRunner.invalidate(dir);
       if (result.status !== 0) return res.status(500).json({ error: result.stderr?.toString?.()?.trim() || 'Stage failed' });
     }
 
     // Commit
-    const result = spawnSync('git', ['commit', '-m', message.trim()], { cwd: dir, env: withGitFallback(process.env), stdio: 'pipe', timeout: 15000 });
+    const result = await gitStatusRunner.runRaw(['commit', '-m', message.trim()], { cwd: dir, timeoutMs: 15000 });
+    gitStatusRunner.invalidate(dir);
     if (result.status !== 0) {
       const stderr = result.stderr?.toString?.()?.trim() || '';
       const stdout = result.stdout?.toString?.()?.trim() || '';
@@ -29558,32 +29712,32 @@ app.post('/api/git/commit', editorOwnerGuard, (req, res) => {
   }
 });
 
-app.get('/api/git/diff-summary', editorOwnerGuard, (req, res) => {
+app.get('/api/git/diff-summary', editorOwnerGuard, async (req, res) => {
   const asked = req.query.path;
   if (!asked || typeof asked !== 'string') return res.status(400).json({ error: 'path required' });
   const dir = registeredGitFolder(asked, res);
   if (!dir) return;
 
   try {
-    gitOutput(dir, ['rev-parse', '--is-inside-work-tree'], { timeout: 3000 });
+    await gitOutput(dir, ['rev-parse', '--is-inside-work-tree'], { timeout: 3000 });
   } catch {
     return res.status(400).json({ error: 'Not a git repository' });
   }
 
   try {
     // Get diff stat for tracked files
-    const stat = gitOutput(dir, ['diff', '--stat', '--stat-width=120']).trim();
+    const stat = (await gitOutput(dir, ['diff', '--stat', '--stat-width=120'])).trim();
 
     // Get diff stat for staged files
-    const stagedStat = gitOutput(dir, ['diff', '--cached', '--stat', '--stat-width=120']).trim();
+    const stagedStat = (await gitOutput(dir, ['diff', '--cached', '--stat', '--stat-width=120'])).trim();
 
     // Get untracked files
-    const untracked = gitOutput(dir, ['ls-files', '--others', '--exclude-standard']).trim();
+    const untracked = (await gitOutput(dir, ['ls-files', '--others', '--exclude-standard'])).trim();
 
     // Get short diff for context (limited to avoid huge payloads)
-    const diff = gitOutput(dir, ['diff', '-U1', '--no-color'], { timeout: 8000, maxBuffer: 64 * 1024 }).substring(0, 4000);
+    const diff = (await gitOutput(dir, ['diff', '-U1', '--no-color'], { timeout: 8000, maxBuffer: 64 * 1024 })).substring(0, 4000);
 
-    const stagedDiff = gitOutput(dir, ['diff', '--cached', '-U1', '--no-color'], { timeout: 8000, maxBuffer: 64 * 1024 }).substring(0, 4000);
+    const stagedDiff = (await gitOutput(dir, ['diff', '--cached', '-U1', '--no-color'], { timeout: 8000, maxBuffer: 64 * 1024 })).substring(0, 4000);
 
     // Build a commit message from the changes
     const changedFiles = [];
@@ -29651,7 +29805,7 @@ app.use(createGitDiffRouter({ fileRoots: allowedFileRoots, guard: editorOwnerGua
 
 // ── Git Log ──
 
-app.get('/api/git/log', editorOwnerGuard, (req, res) => {
+app.get('/api/git/log', editorOwnerGuard, async (req, res) => {
   const asked = req.query.path;
   if (!asked || typeof asked !== 'string') return res.status(400).json({ error: 'path required' });
   const dir = registeredGitFolder(asked, res);
@@ -29659,13 +29813,13 @@ app.get('/api/git/log', editorOwnerGuard, (req, res) => {
   const count = Math.min(Math.max(parseInt(req.query.count) || 10, 1), 50);
 
   try {
-    gitOutput(dir, ['rev-parse', '--is-inside-work-tree'], { timeout: 3000 });
+    await gitOutput(dir, ['rev-parse', '--is-inside-work-tree'], { timeout: 3000 });
   } catch {
     return res.status(400).json({ error: 'Not a git repository' });
   }
 
   try {
-    const raw = gitOutput(dir, ['log', '--oneline', '--no-decorate', '-n', String(count)]).trim();
+    const raw = (await gitOutput(dir, ['log', '--oneline', '--no-decorate', '-n', String(count)])).trim();
     const commits = raw ? raw.split('\n').map(line => {
       const spaceIdx = line.indexOf(' ');
       return { hash: line.substring(0, spaceIdx), message: line.substring(spaceIdx + 1) };
@@ -29683,17 +29837,17 @@ app.post('/api/git/generate-message', editorOwnerGuard, async (req, res) => {
   if (!dir || typeof dir !== 'string') return res.status(400).json({ error: 'path required' });
 
   try {
-    gitOutput(dir, ['rev-parse', '--is-inside-work-tree'], { timeout: 3000 });
+    await gitOutput(dir, ['rev-parse', '--is-inside-work-tree'], { timeout: 3000 });
   } catch {
     return res.status(400).json({ error: 'Not a git repository' });
   }
 
   // Gather diff data — separate try/catch per command so one failure doesn't skip the rest
   let diffText = '', stagedText = '', untrackedList = '', recentCommits = '';
-  try { diffText = gitOutput(dir, ['diff', '--no-color'], { timeout: 8000, maxBuffer: 2 * 1024 * 1024 }).substring(0, 4000); } catch {}
-  try { stagedText = gitOutput(dir, ['diff', '--cached', '--no-color'], { timeout: 8000, maxBuffer: 2 * 1024 * 1024 }).substring(0, 4000); } catch {}
-  try { untrackedList = gitOutput(dir, ['ls-files', '--others', '--exclude-standard']).trim(); } catch {}
-  try { recentCommits = gitOutput(dir, ['log', '--oneline', '--no-decorate', '-n', '5'], { timeout: 3000 }).trim(); } catch {}
+  try { diffText = (await gitOutput(dir, ['diff', '--no-color'], { timeout: 8000, maxBuffer: 2 * 1024 * 1024 })).substring(0, 4000); } catch {}
+  try { stagedText = (await gitOutput(dir, ['diff', '--cached', '--no-color'], { timeout: 8000, maxBuffer: 2 * 1024 * 1024 })).substring(0, 4000); } catch {}
+  try { untrackedList = (await gitOutput(dir, ['ls-files', '--others', '--exclude-standard'])).trim(); } catch {}
+  try { recentCommits = (await gitOutput(dir, ['log', '--oneline', '--no-decorate', '-n', '5'], { timeout: 3000 })).trim(); } catch {}
 
   const allDiff = (diffText + '\n' + stagedText).trim();
   if (!allDiff && !untrackedList) {
@@ -29744,8 +29898,8 @@ app.post('/api/git/generate-message', editorOwnerGuard, async (req, res) => {
   // Fallback: heuristic (same logic as /api/git/diff-summary)
   try {
     let stat = '', stagedStat = '';
-    try { stat = gitOutput(dir, ['diff', '--stat', '--stat-width=120'], { maxBuffer: 2 * 1024 * 1024 }).trim(); } catch {}
-    try { stagedStat = gitOutput(dir, ['diff', '--cached', '--stat', '--stat-width=120'], { maxBuffer: 2 * 1024 * 1024 }).trim(); } catch {}
+    try { stat = (await gitOutput(dir, ['diff', '--stat', '--stat-width=120'], { maxBuffer: 2 * 1024 * 1024 })).trim(); } catch {}
+    try { stagedStat = (await gitOutput(dir, ['diff', '--cached', '--stat', '--stat-width=120'], { maxBuffer: 2 * 1024 * 1024 })).trim(); } catch {}
     const changedFiles = [];
     for (const line of (stat + '\n' + stagedStat).split('\n').filter(l => l.includes('|'))) {
       const m = line.match(/^\s*(.+?)\s*\|/);
@@ -29823,7 +29977,7 @@ app.put('/api/cli/config', (req, res) => {
 app.post('/api/cli/detect/:profileId', async (req, res) => {
   try {
     const { profileId } = req.params;
-    if (!['claude-code', 'codex', 'gemini', 'opencode'].includes(profileId)) return res.status(400).json({ ok: false, error: 'Unknown profile' });
+    if (!['claude-code', 'codex', 'antigravity', 'opencode'].includes(profileId)) return res.status(400).json({ ok: false, error: 'Unknown profile' });
     const status = await cliResolver.resolve(profileId, { force: true, configured: null });
     res.json({
       ok: true,
@@ -29873,7 +30027,7 @@ function stripAnsi(str) {
 // stdin: false — message appended as the last CLI arg (flag takes a value)
 const CLI_SIDECAR_CONFIG = {
   'claude-code': { args: ['-p', '--verbose'], stdin: true },   // -p = non-interactive mode; reads prompt from stdin
-  'gemini':      { args: ['-p'],              stdin: false },   // -p <value>; PowerShell passes correctly on Windows
+  'antigravity': { args: ['-p'],              stdin: false },   // agy -p <prompt>: one print-mode turn
   'codex':       { args: ['-q'],              stdin: false },   // -q <msg>; flag takes a value
   'shell':       null,
 };
@@ -29888,7 +30042,7 @@ const CLI_LIVE_CONFIG = {
     maxIdleMs: 120000,                      // 2 min absolute max wait
     useBracketedPaste: true,
   },
-  'gemini': {
+  'antigravity': {
     promptPatterns: [/>\s*$/m, /\u276F\s*$/m],
     idleMs: 3000,
     maxIdleMs: 120000,
@@ -30005,7 +30159,7 @@ function spawnSidecarProcess(linkId, sessionId, message) {
   const sidecarConfig = CLI_SIDECAR_CONFIG[profile];
   if (!sidecarConfig) throw new Error(`No sidecar config for profile: ${profile}`);
 
-  // Get the CLI command from config (e.g. 'claude', 'gemini', 'codex')
+  // Get the CLI command from config (e.g. 'claude', 'agy', 'codex')
   const cliConfig = loadCliConfig();
   const command = (cliConfig[profile]?.command || '').trim();
   if (!command) throw new Error(`No CLI command configured for ${profile}`);
@@ -30025,7 +30179,7 @@ function spawnSidecarProcess(linkId, sessionId, message) {
     // stdin-based: args are fixed, message piped after spawn (e.g. Claude Code)
   } else if (IS_WIN) {
     // Windows: cmd.exe shell quoting mangles multi-word args (splits by spaces),
-    // causing CLIs like Gemini to misparse -p "hello world" as -p + positional "hello" "world".
+    // causing CLIs that take a value after -p (agy) to misparse -p "hello world" as -p + positional "hello" "world".
     // Use PowerShell which correctly passes $msg as a single argument value.
     tmpFile = join(os.tmpdir(), `synabun-relay-${randomBytes(4).toString('hex')}.txt`);
     writeFileSync(tmpFile, message, 'utf-8');
@@ -32391,8 +32545,10 @@ async function createBrowserSession(options = {}) {
     || savedCfg.connectMode === 'morelogin';
   if (_wantMoreLogin) {
     try {
-      if (!moreLogin.isMoreLoginInstalled().installed) {
-        throw new Error('MoreLogin desktop app is not installed');
+      // An install outside the known folders (a custom folder on Windows) still
+      // counts when its local API answers.
+      if (!moreLogin.isMoreLoginInstalled().installed && !(await moreLogin.probeMoreLoginApi({ savedCfg })).running) {
+        throw new Error(`MoreLogin desktop app was not found and its local API does not answer on port ${moreLogin.getMoreLoginPort(savedCfg)}`);
       }
       // Installed but possibly not running (e.g. an autonomous schedule fires with
       // nobody at the machine to open it) — auto-launch and wait for its local API
@@ -33730,30 +33886,41 @@ app.use('/api/browser', (req, res, next) => { res.setHeader('X-Synabun-Browser-D
 // action, a new tab, CDP). Closing it, or listing its tabs, stays allowed.
 app.use('/api/browser/sessions/:id', (req, res, next) => {
   const protectedContext = browserSessions.get(req.params.id)?.context;
-  const unsafe = protectedContext?.__browserNetworkGuardError;
-  if (unsafe && req.method !== 'DELETE' && !(req.method === 'GET' && req.path === '/tabs')) {
-    return res.status(503).json({ error: `Browser network protection unavailable: ${unsafe}`, networkGuard: true });
-  }
-  // Also cancel requests already waiting/probing when the protection disappears.
-  // Cancellation prevents their next page action; an action that already began
-  // retains the existing truthful "outcome uncertain" response semantics.
-  if (req.method !== 'DELETE' && protectedContext?.on) {
-    const cancel = reason => req.browserRequest?.cancelForProtection?.(reason);
-    protectedContext.on('synabun-network-guard-fault', cancel);
-    const release = () => protectedContext.removeListener('synabun-network-guard-fault', cancel);
-    res.once('finish', release);
-    res.once('close', release);
-  }
-  if (!req.get('X-Synabun-Terminal') || req.method === 'DELETE' || (req.method === 'GET' && req.path === '/tabs')) return next();
-  const session = browserSessions.get(req.params.id);
-  if (!session) return next();
-  const cfg = loadBrowserConfig();
-  if (cfg.connectMode !== 'morelogin' || sessionServesMoreLoginDefault(session, cfg)) return next();
-  const envId = moreLoginDefaultEnvId(cfg);
-  res.status(409).json({
-    error: `Session ${req.params.id} is not the default browser (${session._profileMode || 'unknown'} mode${session._mlEnvId ? `, MoreLogin env ${session._mlEnvId}` : ''}; the default is MoreLogin${envId ? ` env ${envId}` : ''}), so SynaBun's browser tools do not act on it. Leave sessionId out: browser_navigate opens the page in the default browser.`,
-    code: 'NOT_DEFAULT_BROWSER',
-  });
+  const exempt = req.method === 'DELETE' || (req.method === 'GET' && req.path === '/tabs');
+  const gate = () => {
+    const unsafe = protectedContext?.__browserNetworkGuardError;
+    if (unsafe && !exempt) {
+      return res.status(503).json({ error: `Browser network protection unavailable: ${unsafe}`, networkGuard: true });
+    }
+    // Also cancel requests already waiting/probing when the protection disappears.
+    // Cancellation prevents their next page action; an action that already began
+    // retains the existing truthful "outcome uncertain" response semantics.
+    if (req.method !== 'DELETE' && protectedContext?.on) {
+      const cancel = reason => req.browserRequest?.cancelForProtection?.(reason);
+      protectedContext.on('synabun-network-guard-fault', cancel);
+      const release = () => protectedContext.removeListener('synabun-network-guard-fault', cancel);
+      res.once('finish', release);
+      res.once('close', release);
+    }
+    if (!req.get('X-Synabun-Terminal') || exempt) return next();
+    const session = browserSessions.get(req.params.id);
+    if (!session) return next();
+    const cfg = loadBrowserConfig();
+    if (cfg.connectMode !== 'morelogin' || sessionServesMoreLoginDefault(session, cfg)) return next();
+    const envId = moreLoginDefaultEnvId(cfg);
+    res.status(409).json({
+      error: `Session ${req.params.id} is not the default browser (${session._profileMode || 'unknown'} mode${session._mlEnvId ? `, MoreLogin env ${session._mlEnvId}` : ''}; the default is MoreLogin${envId ? ` env ${envId}` : ''}), so SynaBun's browser tools do not act on it. Leave sessionId out: browser_navigate opens the page in the default browser.`,
+      code: 'NOT_DEFAULT_BROWSER',
+    });
+  };
+  // A faulted network guard re-arms on demand: a fresh protected attachment replaces
+  // the broken one before this request runs, so a session never needs a server
+  // restart to recover. Until a re-arm succeeds every action stays refused.
+  if (protectedContext?.__browserNetworkGuardError && !exempt) {
+    recoverBrowserNetworkGuard(protectedContext).then(gate).catch(next);
+    return;
+  }
+  return gate();
 });
 // Read-only semantic context for the browser judgments (the judgments themselves run in the MCP layer).
 app.use('/api/browser', createBrowserAssistRouter({ browserSessions, getTargetPage, normalizeSelector }));
@@ -35560,7 +35727,7 @@ app.post('/api/browser/sessions/:id/upload', async (req, res) => {
 });
 
 // Browser config endpoint
-app.get('/api/browser/config', (req, res) => {
+app.get('/api/browser/config', async (req, res) => {
   const config = loadBrowserConfig();
   const detected = findBrowserExecutable();
   // Check if Chrome is currently running (informs profile mirroring warnings)
@@ -35581,7 +35748,11 @@ app.get('/api/browser/config', (req, res) => {
   let attachSeeded = false;
   try { attachSeeded = existsSync(getAttachProfileRoot()); } catch {}
   let moreloginInstalled = false;
-  try { moreloginInstalled = moreLogin.isMoreLoginInstalled().installed; } catch {}
+  // The exe in a known folder, or a local API that answers (a custom install folder): a short probe only when needed.
+  try {
+    moreloginInstalled = moreLogin.isMoreLoginPresent()
+      || (await moreLogin.probeMoreLoginApi({ savedCfg: config, timeout: 1500 })).running;
+  } catch {}
   const unreadable = browserConfigUnreadable(config);
   res.json({ config, detectedPath: detected, chromeRunning, attachSeeded, moreloginInstalled, ...(unreadable && { configError: `browser-config.json is unreadable (${unreadable}); saving these settings replaces it` }) });
 });
@@ -35626,12 +35797,20 @@ app.get('/api/browser/detect-profiles', (req, res) => {
 app.get('/api/browser/morelogin-envs', async (req, res) => {
   try {
     const cfg = loadBrowserConfig();
-    const installed = moreLogin.isMoreLoginInstalled().installed;
     const port = moreLogin.getMoreLoginPort(cfg);
-    if (!installed) return res.json({ ok: true, installed: false, running: false, port, envs: [] });
+    // Probe first: the install-folder check knows only the default folders, and an
+    // answering local API proves the app is there wherever it was installed.
     const probe = await moreLogin.probeMoreLoginApi({ savedCfg: cfg, port });
+    const installed = probe.running || moreLogin.isMoreLoginInstalled().installed;
+    if (!installed) return res.json({ ok: true, installed: false, running: false, port, envs: [], error: probe.error || null });
     if (!probe.running) return res.json({ ok: true, installed: true, running: false, port, envs: [], error: probe.error || null });
+    // The API answered with an error (signature required, API off): say why, never an empty list.
+    if (probe.apiError) return res.json({ ok: false, installed: true, running: true, port, envs: [], error: probe.apiError });
     const envs = await moreLogin.listProfiles({ savedCfg: cfg, port });
+    // The API counted profiles but none could be read: a shape problem, never "no profiles yet".
+    if (probe.count > 0 && !envs.length) {
+      return res.json({ ok: false, installed: true, running: true, port, envs: [], error: `MoreLogin reports ${probe.count} profile(s) but SynaBun could not read them from its answer; a newer MoreLogin may have changed its API.` });
+    }
     res.json({
       ok: true, installed: true, running: true, port, envs,
       // Observed website-policy blocks — MoreLogin's local API never exposes the
@@ -35882,10 +36061,11 @@ const httpServer = app.listen(PORT, async () => {
   // Activation is an explicit user choice via Settings → Browser / the MoreLogin tab.
   setTimeout(async () => {
     try {
-      if (!moreLogin.isMoreLoginInstalled().installed) return;
-      const cfg = loadBrowserConfig();
+      const mlBootCfg = loadBrowserConfig();
+      const cfg = mlBootCfg;
       const port = moreLogin.getMoreLoginPort(cfg);
       const probe = await moreLogin.probeMoreLoginApi({ savedCfg: cfg, port });
+      if (!probe.running && !moreLogin.isMoreLoginInstalled().installed) return;
       const isDefault = cfg.connectMode === 'morelogin';
       console.log(`  MoreLogin:  detected${probe.running ? ` · API on :${port} (${probe.count} profile(s))` : ' · app not running'}${isDefault ? ' · default AI browser' : ''}`);
     } catch { /* best-effort */ }
@@ -35949,6 +36129,12 @@ const httpServer = app.listen(PORT, async () => {
           if (oc.updated > 0) console.log(`  Session cache (opencode): indexed ${oc.updated}/${oc.sessions}`);
         } catch (err) { console.warn('  Session cache (opencode) error:', err.message); }
       },
+      () => {
+        const agy = refreshAntigravityCatalog({ force: true });
+        if (agy?.updated > 0) console.log(`  Session cache (antigravity): indexed ${agy.updated}/${agy.sessions}`);
+        // Runs and brains end on their own: their conversations are picked up by this pass, every five minutes.
+        setInterval(() => refreshAntigravityCatalog({ force: true }), 5 * 60 * 1000).unref?.();
+      },
     ];
     const next = () => {
       const pass = passes.shift();
@@ -35988,6 +36174,18 @@ const httpServer = app.listen(PORT, async () => {
     console.warn('  Hook dedup warning:', err.message);
   }
 
+  // Antigravity replaced Gemini CLI: what was saved under `gemini` (a CLI path, a keybind, loop templates and
+  // schedules, the launch profile and resume tab in the UI state) is read as Antigravity's from this boot on
+  // (lib/antigravity/migrate-gemini.js). Idempotent; a file it cannot read is left as it is. Never stops the boot.
+  try {
+    const migrated = migrateGeminiFiles({ dataHome: DATA_HOME, log: (line) => console.log(`  ${line}`) });
+    if (migrated.changed.includes('cli-config.json')) { _cliConfigCache = null; cliResolver.invalidate(); }
+    const ui = loadUiState();
+    if (migrateGeminiUiState(ui)) saveUiState(ui);
+  } catch (err) {
+    console.warn('  Antigravity migration warning:', err.message);
+  }
+
   // Keep the installed SynaBun rules current: an untouched copy of an older
   // ruleset is rewritten (unless the user switched that off), an edited copy is
   // left alone, a deleted one counts as an opt-out. Never installs for a tool
@@ -36003,6 +36201,16 @@ const httpServer = app.listen(PORT, async () => {
     console.warn('  Rules reconcile warning:', err.message);
   }
 
+  // SynaBun's Antigravity homes (lib/antigravity/home.js): a run's home lives a week past its last use (a run resumes
+  // within minutes of a restart), an Assistant brain's two months (its conversation can be picked up later).
+  try {
+    const root = antigravityHomesRoot(DATA_HOME);
+    const removed = [...pruneAntigravityHomes(root, { kinds: ['run', 'models'], keep: antigravityPanel.activeHomes() }), ...pruneAntigravityHomes(root, { kinds: ['brain'], maxAgeMs: 60 * 24 * 60 * 60_000 })];
+    if (removed.length) console.log(`  Antigravity: removed ${removed.length} unused SynaBun home${removed.length === 1 ? '' : 's'}`);
+  } catch (err) {
+    console.warn('  Antigravity homes warning:', err.message);
+  }
+
   // Clean up orphaned loop state files from previous server runs.
   // After a restart, PTY sessions are gone but loop files remain with awaitingNext: true.
   // No terminal session exists to drive them, so delete them to prevent ghost loops.
@@ -36134,7 +36342,7 @@ httpServer.on('upgrade', function onUpgrade(req, socket, head) {
   if (guest) {
     if (url.pathname.startsWith('/ws/terminal/') && !invitePermissions.terminal) { socket.destroy(); return; }
     if (url.pathname.startsWith('/ws/browser/') && !invitePermissions.browser) { socket.destroy(); return; }
-    if (['/ws/claude-skin', '/ws/codex-skin', '/ws/opencode-v2'].includes(url.pathname) || url.pathname.startsWith('/ws/assistant/')) {
+    if (['/ws/claude-skin', '/ws/codex-skin', '/ws/opencode-v2', '/ws/antigravity'].includes(url.pathname) || url.pathname.startsWith('/ws/assistant/')) {
       socket.destroy();
       return;
     }
@@ -36165,7 +36373,7 @@ httpServer.on('upgrade', function onUpgrade(req, socket, head) {
     return;
   }
 
-  if (url.pathname.startsWith('/ws/browser/') || url.pathname.startsWith('/ws/assistant/') || url.pathname === '/ws/whiteboard' || url.pathname === '/ws/cards' || url.pathname === '/ws/sync' || url.pathname === '/ws/claude-skin' || url.pathname === '/ws/codex-skin' || url.pathname === '/ws/opencode-v2' || url.pathname === '/ws/sessions') {
+  if (url.pathname.startsWith('/ws/browser/') || url.pathname.startsWith('/ws/assistant/') || url.pathname === '/ws/whiteboard' || url.pathname === '/ws/cards' || url.pathname === '/ws/sync' || url.pathname === '/ws/claude-skin' || url.pathname === '/ws/codex-skin' || url.pathname === '/ws/opencode-v2' || url.pathname === '/ws/antigravity' || url.pathname === '/ws/sessions') {
     wss.handleUpgrade(req, socket, head, (ws) => {
       wss.emit('connection', ws, req);
     });
@@ -36232,6 +36440,12 @@ wss.on('connection', (ws, req) => {
     return;
   }
 
+  // ── Route: Antigravity side panel (Google's agy over ACP) ──
+  if (url.pathname === '/ws/antigravity') {
+    antigravityPanel.handleSocket(ws);
+    return;
+  }
+
   // ── Terminal sessions ── are handed off to the pty-host in the upgrade
   // handler (lib/pty-host); nothing else should reach this point.
   try { ws.close(1008, 'Unsupported WebSocket path'); } catch {}
@@ -36816,11 +37030,15 @@ process.on('exit', () => {
   try { stopOpencodeServer(); } catch {}
   try { editorCompletionServe.stop('exit'); } catch {}
   try { _claudeBridge?.shutdownAllBridges?.(); } catch {}
+  try { antigravityPanel.closeAll(); } catch {}
   try { saveSessionSnapshot(); } catch {}
   try { flushUiStateSync(); } catch {}
   try { flushWhiteboardSync(); } catch {}
   try { flushCostDataSync(); } catch {}
   try { memoryMap.flushSync(); } catch {}
+  // The Assistant's session records (a rename among them): this handler runs before the Assistant's own
+  // exit handler, which the SIGKILL below never lets run.
+  try { _assistantRuntime?.flushIndex?.(); } catch {}
   if (_preserveExitCode) return;
   try { process.kill(process.pid, 'SIGKILL'); } catch {}
 });