synabun 2.1.0 → 2.2.0

package/neural-interface/lib/claude-history-cache.js

@@ -0,0 +1,210 @@
+// ── Claude Code transcripts, parsed once ──
+// GET /api/claude-code/sessions/:id/messages used to read and JSON.parse a
+// session's whole JSONL on every request, and one session open makes several:
+// the panel's snapshot probe (limit=1), the rebuild (limit=500), "load earlier",
+// "show all" of a clipped result (?tool=). A transcript runs to tens of MB, and
+// on Windows (slower file reads, every read scanned by the antivirus) each pass
+// costs seconds. This keeps the collector of the last few transcripts read and,
+// when the file grew, parses only what was appended.
+//
+// A kept collector is used only for the same file (device and inode) when
+// everything it read is still there unchanged. Same size and time: reused as it
+// is. Grown: the first HEAD_BYTES of the file and the last TAIL_BYTES before
+// where the last read stopped must still be what was read (a rewrite followed by
+// growth changes one of them). Any other change (shorter, same size with a new
+// time, an edit in place) reads the file again from the start. Only whole lines are taken: a last line
+// still being written (no newline yet, and not JSON yet) is read next time.
+// The file is always opened through openConfinedStream, from the canonical
+// paths findSessionTranscript checked.
+
+import { statSync } from 'node:fs';
+import { openConfinedStream } from './confined-fs.js';
+import { createHistoryCollector } from './claude-history.js';
+
+const NEWLINE = 0x0a;
+const TAIL_BYTES = 4096;
+const HEAD_BYTES = 4096;
+export const HISTORY_CACHE_LIMITS = Object.freeze({
+  maxEntries: 4,
+  maxIdleMs: 10 * 60_000,
+  // A bigger transcript is still answered, from a fresh read each time: it is not kept in memory.
+  maxCachedBytes: 256 * 1024 * 1024,
+  // All kept transcripts together (bytes parsed, a stand-in for the rows they hold): the least recently used go first.
+  maxTotalBytes: 384 * 1024 * 1024,
+});
+
+function parseLine(buf, collector) {
+  let text = buf.toString('utf-8');
+  if (text.endsWith('\r')) text = text.slice(0, -1);
+  if (!text.trim()) return true;
+  try { collector.add(JSON.parse(text)); return true; } catch { return false; }
+}
+
+/**
+ * Read `found.realPath` from `from` (an offset at a line start), feeding whole
+ * lines to `collector`. With `expectTail`, the first bytes read must equal it
+ * (the bytes before the old end); otherwise nothing is added and `null` is
+ * returned. Returns `{ offset, tail }`: where the next read starts, and the
+ * bytes before it.
+ */
+async function readFrom(found, collector, { from = 0, expectTail = null, open }) {
+  const skip = expectTail ? expectTail.length : 0;
+  const stream = open(found.realFolder, found.realPath, { start: Math.max(0, from - skip) });
+  let head = skip ? Buffer.alloc(0) : null; // collects the bytes to compare
+  let carry = Buffer.alloc(0);
+  let offset = from;
+  let tail = expectTail || Buffer.alloc(0);
+  let fileHead = from === 0 ? Buffer.alloc(0) : null; // the first bytes of the file, taken on a read from the start
+  const consumed = (bytes) => {
+    if (fileHead && fileHead.length < HEAD_BYTES) fileHead = Buffer.concat([fileHead, bytes.subarray(0, HEAD_BYTES - fileHead.length)]);
+    offset += bytes.length;
+    tail = Buffer.concat([tail, bytes.subarray(Math.max(0, bytes.length - TAIL_BYTES))]);
+    if (tail.length > TAIL_BYTES) tail = tail.subarray(tail.length - TAIL_BYTES);
+  };
+  try {
+    for await (const raw of stream) {
+      let chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(String(raw), 'utf-8');
+      if (head) {
+        const need = skip - head.length;
+        head = Buffer.concat([head, chunk.subarray(0, need)]);
+        chunk = chunk.subarray(need);
+        if (head.length < skip) continue;
+        if (!head.equals(expectTail)) return null; // the file changed under what was read
+        head = null;
+      }
+      let data = carry.length ? Buffer.concat([carry, chunk]) : chunk;
+      let start = 0;
+      let index;
+      while ((index = data.indexOf(NEWLINE, start)) !== -1) {
+        parseLine(data.subarray(start, index), collector);
+        consumed(data.subarray(start, index + 1));
+        start = index + 1;
+      }
+      carry = Buffer.from(data.subarray(start));
+    }
+  } finally {
+    stream.destroy?.();
+  }
+  if (head) return null; // the file ends before the bytes that were read last time
+  // A last line without its newline: taken when it is whole JSON already, else read next time.
+  if (carry.length && parseLine(carry, collector)) consumed(carry);
+  return { offset, tail, head: fileHead };
+}
+
+/** The first `length` bytes of the file, or less when it is shorter. */
+async function readHead(found, length, open) {
+  if (!length) return Buffer.alloc(0);
+  const stream = open(found.realFolder, found.realPath, { start: 0, end: length - 1 });
+  const parts = [];
+  let got = 0;
+  try {
+    for await (const raw of stream) {
+      const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(String(raw), 'utf-8');
+      parts.push(chunk); got += chunk.length;
+      if (got >= length) break;
+    }
+  } finally { stream.destroy?.(); }
+  return Buffer.concat(parts).subarray(0, length);
+}
+
+/**
+ * @param o.open     (folder, file, options) => readable stream (openConfinedStream)
+ * @param o.stat     (path) => fs.Stats
+ * @param o.newCollector () => a history collector (lib/claude-history.js)
+ */
+export function createHistoryCache({
+  open = openConfinedStream,
+  stat = statSync,
+  newCollector = createHistoryCollector,
+  now = Date.now,
+  limits = HISTORY_CACHE_LIMITS,
+} = {}) {
+  const entries = new Map(); // realPath → { dev, ino, size, mtimeMs, offset, tail, collector, usedAt }
+  const running = new Map(); // realPath → promise of the collector being brought up to date
+  const stats = { fresh: 0, appended: 0, reused: 0, reread: 0 };
+
+  const evict = (keep = null) => {
+    const at = now();
+    for (const [key, entry] of entries) if (key !== keep && at - entry.usedAt > limits.maxIdleMs) entries.delete(key);
+    while (entries.size > limits.maxEntries) entries.delete(entries.keys().next().value);
+    const maxTotal = limits.maxTotalBytes ?? Infinity;
+    let total = 0;
+    for (const entry of entries.values()) total += entry.offset;
+    for (const [key, entry] of entries) { // oldest first
+      if (total <= maxTotal) break;
+      entries.delete(key); total -= entry.offset;
+    }
+  };
+  const touch = (key, entry) => {
+    entry.usedAt = now();
+    entries.delete(key); entries.set(key, entry); // most recently used last
+    evict(key);
+  };
+  // Kept only while it fits: a transcript that grew past the limit is answered this once, then dropped.
+  const fits = (size) => size <= limits.maxCachedBytes;
+
+  async function update(found) {
+    const key = found.realPath;
+    evict(); // an idle entry goes before it could be reused
+    const st = stat(key);
+    let entry = entries.get(key) || null;
+    if (entry && (entry.dev !== st.dev || entry.ino !== st.ino || st.size < entry.offset)) entry = null;
+    if (entry && st.size === entry.size && st.mtimeMs === entry.mtimeMs) {
+      stats.reused++;
+      touch(key, entry);
+      return entry.collector;
+    }
+    // Changed without growing (same size with a new time, an edit in place): nothing tells what changed.
+    if (entry && st.size <= entry.size) { stats.reread++; entry = null; }
+    if (entry) {
+      let read = null;
+      const head = entry.head.length ? await readHead(found, entry.head.length, open) : entry.head;
+      if (head.equals(entry.head)) {
+        read = await readFrom(found, entry.collector, { from: entry.offset, expectTail: entry.offset ? entry.tail : null, open });
+      }
+      if (read) {
+        stats.appended++;
+        Object.assign(entry, { size: st.size, mtimeMs: st.mtimeMs, offset: read.offset, tail: read.tail });
+        if (fits(st.size)) touch(key, entry); else entries.delete(key);
+        return entry.collector;
+      }
+      stats.reread++;
+    }
+    entries.delete(key);
+    const collector = newCollector();
+    const read = await readFrom(found, collector, { from: 0, open });
+    stats.fresh++;
+    if (read && fits(st.size)) {
+      entries.set(key, { dev: st.dev, ino: st.ino, size: st.size, mtimeMs: st.mtimeMs, offset: read.offset, tail: read.tail, head: read.head, collector, usedAt: now() });
+      evict(key);
+    }
+    return collector;
+  }
+
+  return {
+    /** The collector of the transcript `found` names, with every whole line it holds now. */
+    async collectorFor(found) {
+      const key = found?.realPath;
+      if (!key || !found.realFolder) throw new Error('A checked transcript path is required.');
+      // One read per file at a time: a second request waits for it and then checks again.
+      while (running.has(key)) { try { await running.get(key); } catch {} }
+      const job = update(found);
+      running.set(key, job);
+      try { return await job; } catch (err) { entries.delete(key); throw err; } finally { if (running.get(key) === job) running.delete(key); }
+    },
+    forget(realPath) { entries.delete(realPath); },
+    /** Drop every kept transcript of a session (its file is `<sessionId>.jsonl`, in any project folder). */
+    forgetSession(sessionId) {
+      if (typeof sessionId !== 'string' || !sessionId) return 0;
+      let dropped = 0;
+      for (const key of [...entries.keys()]) {
+        const name = key.split(/[\\/]/).pop();
+        if (name === `${sessionId}.jsonl`) { entries.delete(key); dropped++; }
+      }
+      return dropped;
+    },
+    clear() { entries.clear(); },
+    get size() { return entries.size; },
+    get stats() { return { ...stats }; },
+  };
+}

package/neural-interface/lib/claude-model-catalog.js

@@ -324,7 +324,7 @@ export function queryClaudeCliModels(claudeBin, { cwd, timeoutMs = DISCOVERY_TIM
 // re-discovers. A list that is merely old is still given at once, and the CLI is
 // asked again in the background (one discovery at a time): only a first read, a
 // changed key or `force` waits for the CLI.
-export async function discoverClaudeModels(claudeBin, { force = false, cwd, query = queryClaudeCliModels, account = '' } = {}) {
+export async function discoverClaudeModels(claudeBin, { force = false, nonBlocking = false, cwd, query = queryClaudeCliModels, account = '' } = {}) {
   const bin = String(claudeBin || '');
   const key = cacheKeyOf(bin, account);
   adoptStoredModels(key);
@@ -333,6 +333,10 @@ export async function discoverClaudeModels(claudeBin, { force = false, cwd, quer
     if (Date.now() - _cache.at >= CACHE_TTL_MS) discover(bin, key, cwd, query).catch(() => {});
     return { source: 'cache', models: _cache.models };
   }
+  if (!force && nonBlocking) {
+    discover(bin, key, cwd, query).catch(() => {});
+    return { source: 'fallback', models: [...CLAUDE_FALLBACK_MODELS] };
+  }
   return discover(bin, key, cwd, query);
 }
 

package/neural-interface/lib/cli-install-api.js

@@ -24,7 +24,7 @@ import { Router } from 'express';
 import { guestForbidden, noStore, requireLocal, requireLocalHost, requireSameOriginJson, sendGuardError, uiOnly } from './http-guards.js';
 import { openNdjsonStream } from './whatsapp/api.js';
 
-export const INSTALLABLE_TOOLS = Object.freeze(['claude-code', 'codex', 'opencode']);
+export const INSTALLABLE_TOOLS = Object.freeze(['claude-code', 'codex', 'opencode', 'antigravity']);
 
 /**
  * @param {object} deps

package/neural-interface/lib/cli-install.js

@@ -3,10 +3,12 @@
 // ═══════════════════════════════════════════
 //
 // What the side panels' Install button runs (POST /api/cli/install/:tool,
-// lib/cli-install-api.js) when Claude Code, Codex or OpenCode is not installed.
-// Each tool is installed the way its vendor documents for the system, from the
-// vendor's own source, with nothing else needed (no Node, npm, Homebrew or
-// Scoop). The sources are fixed here; a request only names the tool.
+// lib/cli-install-api.js) when Claude Code, Codex, OpenCode or the Antigravity
+// CLI is not installed. Each tool is installed the way its vendor documents for
+// the system, from the vendor's own source, with nothing else needed (no Node,
+// npm or Scoop; Homebrew only where it is installed already, for the
+// Antigravity CLI's cask on macOS). The sources are fixed here; a request only
+// names the tool.
 //
 //   Claude Code  Anthropic's native installer: https://claude.ai/install.sh
 //                (bash) on macOS and Linux, https://claude.ai/install.ps1
@@ -24,21 +26,32 @@
 //                runs (it puts opencode in ~/.opencode/bin). Windows has no
 //                one-click install: OpenCode 2 comes from WinGet there
 //                (Anomaly.OpenCode), and the banner shows that command.
+//   Antigravity  Google's Antigravity CLI (agy). On a Mac with Homebrew, the
+//                cask antigravity-cli (Google's signed binary, linked as agy):
+//                `brew install --cask antigravity-cli`. Otherwise Google's
+//                installer https://antigravity.google/cli/install.sh (bash) on
+//                macOS and Linux, https://antigravity.google/cli/install.ps1
+//                (powershell.exe -NoProfile -ExecutionPolicy Bypass -File) on
+//                Windows, from antigravity.google only. The script checks the
+//                binary against the SHA-512 of Google's release manifest and
+//                puts agy in ~/.local/bin (%LOCALAPPDATA%\agy\bin on Windows).
 //
 // Every download is HTTPS, every redirect too, and only to the vendor's own
-// hosts. Nothing runs as administrator; everything lands in the user's own
+// hosts (Homebrew downloads a cask itself and checks it against the cask's
+// SHA-256). Nothing runs as administrator; everything lands in the user's own
 // folders. Install consents to adding the resolved CLI's folder to persistent
 // PATH when the vendor did not do so. That is a visible final step, using the
 // same writer as Add to PATH; a failed PATH write leaves the CLI installed and
 // reports a warning. Installers run without a terminal and without questions
-// (CODEX_NON_INTERACTIVE=1, PowerShell -NonInteractive).
+// (CODEX_NON_INTERACTIVE=1, PowerShell -NonInteractive; NONINTERACTIVE=1 and
+// no auto-update for Homebrew).
 //
 // One install per tool at a time. Every failure is a CliInstallError with a
 // `code` the page has words for. Nothing here throws to a caller of start().
 
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { existsSync, rmSync } from 'node:fs';
+import { accessSync, constants as fsConstants, existsSync, rmSync, statSync } from 'node:fs';
 import { mkdtemp, open } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -74,7 +87,7 @@ export const CLI_INSTALL_GUIDES = Object.freeze({
   'claude-code': 'https://code.claude.com/docs/en/setup',
   codex: 'https://learn.chatgpt.com/docs/codex/cli',
   opencode: 'https://opencode.ai/v2/docs',
-  gemini: 'https://github.com/google-gemini/gemini-cli',
+  antigravity: 'https://antigravity.google/docs/getting-started',
 });
 
 const GITHUB_DOWNLOAD_HOSTS = ['github.com', 'objects.githubusercontent.com', 'release-assets.githubusercontent.com', 'github-releases.githubusercontent.com'];
@@ -88,10 +101,13 @@ const hostIs = (...hosts) => (url) => hosts.includes(url.hostname);
 
 /**
  * The one-click method for a tool on this system, or null when there is none
- * (Gemini CLI, OpenCode on Windows, a 32-bit or other system). Pure: tests ask
- * it for every OS.
+ * (OpenCode on Windows, a 32-bit or other system). `brew` is the path of a
+ * Homebrew this process can run (findBrew), or null: on macOS the Antigravity
+ * CLI is installed through it (its cask), else with Google's installer.
+ * `manualCommand`, when a plan has one, is what to type for the same install.
+ * Pure: tests ask it for every OS.
  */
-export function installPlanFor(toolKey, { platform = process.platform, arch = process.arch, env = process.env, home } = {}) {
+export function installPlanFor(toolKey, { platform = process.platform, arch = process.arch, env = process.env, home, brew = null } = {}) {
   if (!(SUPPORTED[platform] || []).includes(arch)) return null;
   const windows = platform === 'win32';
   switch (toolKey) {
@@ -131,19 +147,77 @@ export function installPlanFor(toolKey, { platform = process.platform, arch = pr
         label: 'OpenCode 2 install script',
         env: {},
       };
+    case 'antigravity':
+      // Homebrew's cask on a Mac that has Homebrew: the CLI then updates with the user's other casks.
+      if (platform === 'darwin' && brew) {
+        return {
+          tool: toolKey,
+          kind: 'brew',
+          brew,
+          args: ['install', '--cask', 'antigravity-cli'],
+          source: 'https://formulae.brew.sh/cask/antigravity-cli',
+          label: 'Homebrew cask antigravity-cli',
+          manualCommand: 'brew install --cask antigravity-cli',
+          env: { HOMEBREW_NO_AUTO_UPDATE: '1', HOMEBREW_NO_ENV_HINTS: '1', NONINTERACTIVE: '1' },
+        };
+      }
+      return {
+        tool: toolKey,
+        kind: 'script',
+        interpreter: windows ? 'powershell' : 'bash',
+        url: windows ? 'https://antigravity.google/cli/install.ps1' : 'https://antigravity.google/cli/install.sh',
+        allow: hostIs('antigravity.google'),
+        source: windows ? 'https://antigravity.google/cli/install.ps1' : 'https://antigravity.google/cli/install.sh',
+        label: 'Google Antigravity CLI installer',
+        manualCommand: windows ? 'irm https://antigravity.google/cli/install.ps1 | iex' : 'curl -fsSL https://antigravity.google/cli/install.sh | bash',
+        env: {},
+      };
     default:
       return null;
   }
 }
 
-/** What the status of a tool says about its one-click install. */
-export function describeInstall(toolKey, options) {
-  const plan = installPlanFor(toolKey, options);
+/** A file this process may run (a link is followed). */
+function isExecutableFile(file) {
+  try {
+    if (!statSync(file).isFile()) return false;
+    accessSync(file, fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Homebrew's brew on macOS: /opt/homebrew/bin (Apple silicon), /usr/local/bin
+ * (Intel), then each folder of PATH; the first executable file. A relative
+ * PATH folder is never looked in. Null on any other system, and on a Mac
+ * without Homebrew.
+ */
+export function findBrew({ platform = process.platform, env = process.env, isExecutable = isExecutableFile } = {}) {
+  if (platform !== 'darwin') return null;
+  const asked = new Set();
+  for (const folder of ['/opt/homebrew/bin', '/usr/local/bin', ...String(env.PATH || '').split(':')]) {
+    if (!folder || !path.posix.isAbsolute(folder)) continue;
+    const file = path.posix.join(folder, 'brew');
+    if (asked.has(file)) continue;
+    asked.add(file);
+    if (isExecutable(file)) return file;
+  }
+  return null;
+}
+
+function describePlan(plan) {
   return plan
-    ? { available: true, method: plan.kind, source: plan.source, interpreter: plan.interpreter, label: plan.label }
+    ? { available: true, method: plan.kind, source: plan.source, interpreter: plan.interpreter || null, label: plan.label }
     : { available: false, method: null, source: null, interpreter: null, label: null };
 }
 
+/** What the status of a tool says about its one-click install. */
+export function describeInstall(toolKey, options) {
+  return describePlan(installPlanFor(toolKey, options));
+}
+
 // ── Transfers ───────────────────────────────────────────────────────────────
 
 function errorCode(error) {
@@ -353,6 +427,19 @@ export function createLineSplitter(onLine) {
   };
 }
 
+/**
+ * The step a line of Homebrew's output begins, or null: its download (and its
+ * download queue's "Fetching"), the check of what it downloaded against the
+ * cask's checksum, and the install itself (moving and linking the binary).
+ */
+export function brewStepOf(line) {
+  const text = String(line ?? '').trim();
+  if (/^==> (?:Downloading|Fetching)\b/.test(text)) return 'download';
+  if (/^==> Verifying\b/.test(text) || /checksum|sha-?256/i.test(text)) return 'verify';
+  if (/^==> (?:Installing|Moving|Linking)\b/.test(text)) return 'run';
+  return null;
+}
+
 function sameDir(a, b, platform) {
   const clean = (value) => {
     const text = String(value || '').replace(/[\\/]+$/, '');
@@ -372,6 +459,7 @@ export function onPathList(dir, entries, platform = process.platform) {
  * @param {object} deps
  * @param {{ resolve: Function }} deps.resolver  cli-resolver.js: the final check (force)
  * @param {() => Promise<string[]>} [deps.readOsPath]  the OS PATH a new terminal gets, read afresh
+ * @param {(o: { platform: string, env: object }) => string|null} [deps.findBrew]  Homebrew's brew, or null (findBrew)
  * @param {(tool: string, ok: boolean, status: object|null) => void} [deps.onFinished]
  */
 export function createCliInstaller({
@@ -383,6 +471,7 @@ export function createCliInstaller({
   tmpRoot = os.tmpdir(),
   fetchImpl = fetch,
   spawnImpl = spawn,
+  findBrew: lookForBrew = findBrew,
   readOsPath = async () => [],
   addToPath = null,
   installerPath = null,
@@ -394,9 +483,12 @@ export function createCliInstaller({
   if (!resolver?.resolve) throw new Error('createCliInstaller needs the CLI resolver');
   const jobs = new Map();
   const windows = platform === 'win32';
-  const planFor = (toolKey) => installPlanFor(toolKey, { platform, arch, env, home });
+  // Homebrew is looked for at every ask: one installed meanwhile counts from the next check on.
+  const brewOf = () => { try { return lookForBrew({ platform, env }) || null; } catch { return null; } };
+  const planFor = (toolKey) => installPlanFor(toolKey, { platform, arch, env, home, brew: brewOf() });
   const guideOf = (toolKey) => CLI_INSTALL_GUIDES[toolKey] || null;
-  const manualOf = (toolKey) => buildInstallCommand(toolKey, 'unknown', { platform });
+  // The command for the very install the button runs here, when its plan names one; else the vendor's for this system.
+  const manualOf = (toolKey) => planFor(toolKey)?.manualCommand || buildInstallCommand(toolKey, 'unknown', { platform });
 
   function publicJob(job) {
     return {
@@ -510,15 +602,19 @@ export function createCliInstaller({
     return file;
   }
 
-  function runScript(job, plan, scriptFile, workDir, osEntries, { line }) {
-    const interpreter = interpreterFor(plan);
+  /**
+   * Run an installer to its end: no stdin, every line of its output to `onLine`, stopped with everything it
+   * started when it runs longer than timeoutMs or the job is stopped. Resolves on exit code 0. `name` is what
+   * the sentence of a failure calls it (`slowName`, the one of a timeout).
+   */
+  function runChild(job, plan, { file, args, cwd, osEntries, onLine, name, slowName = name }) {
     const childEnv = { ...withPathEnv({ ...env, ...plan.env }, installerPathValue(osEntries), platform), TERM: 'dumb', NO_COLOR: '1' };
     delete childEnv.FORCE_COLOR;
     return new Promise((resolve, reject) => {
       let child;
       try {
-        child = spawnImpl(interpreter.file, interpreter.args(scriptFile), {
-          cwd: workDir,
+        child = spawnImpl(file, args, {
+          cwd,
           env: childEnv,
           stdio: ['ignore', 'pipe', 'pipe'],
           windowsHide: true,
@@ -527,18 +623,18 @@ export function createCliInstaller({
           detached: !windows,
         });
       } catch (error) {
-        reject(asInstallError(error, 'installer-failed', `${interpreter.file} could not be started.`));
+        reject(asInstallError(error, 'installer-failed', `${file} could not be started.`));
         return;
       }
       job.child = child;
-      const out = createLineSplitter(line);
-      const err = createLineSplitter(line);
+      const out = createLineSplitter(onLine);
+      const err = createLineSplitter(onLine);
       child.stdout?.on('data', chunk => out.push(chunk.toString('utf8')));
       child.stderr?.on('data', chunk => err.push(chunk.toString('utf8')));
       let settled = false;
       const timer = setTimeout(() => {
         stopChild(child, windows, spawnImpl);
-        finish(new CliInstallError('timeout', `The installer was still running after ${Math.round(timeoutMs / 60_000)} minutes and was stopped.`));
+        finish(new CliInstallError('timeout', `${slowName} was still running after ${Math.round(timeoutMs / 60_000)} minutes and was stopped.`));
       }, timeoutMs);
       timer.unref?.();
       const onAbort = () => { stopChild(child, windows, spawnImpl); finish(new CliInstallError('cancelled', 'The install was stopped.')); };
@@ -552,14 +648,43 @@ export function createCliInstaller({
         err.end();
         job.child = null;
         if (error) reject(error);
-        else if (code !== 0) reject(new CliInstallError('installer-failed', `The ${plan.label} stopped with exit code ${code}.`, { detail: code }));
+        else if (code !== 0) reject(new CliInstallError('installer-failed', `${name} stopped with exit code ${code}.`, { detail: code }));
         else resolve();
       }
-      child.on('error', error => finish(asInstallError(error, 'installer-failed', `${interpreter.file} could not be started (${errorCode(error) || error?.message}).`)));
+      child.on('error', error => finish(asInstallError(error, 'installer-failed', `${file} could not be started (${errorCode(error) || error?.message}).`)));
       child.on('close', (code, signal) => finish(null, code ?? (signal ? 128 : 1)));
     });
   }
 
+  function runScript(job, plan, scriptFile, workDir, osEntries, { line }) {
+    const interpreter = interpreterFor(plan);
+    return runChild(job, plan, {
+      file: interpreter.file, args: interpreter.args(scriptFile), cwd: workDir, osEntries, onLine: line,
+      name: `The ${plan.label}`, slowName: 'The installer',
+    });
+  }
+
+  /**
+   * Homebrew installs the cask (`brew install --cask …`, never auto-updating first). It downloads and checks the
+   * cask itself: its own lines move the steps (brewStepOf), from 'run' on.
+   */
+  function runBrew(job, plan, workDir, osEntries, { step, line }) {
+    let at = 'run';
+    step(at);
+    return runChild(job, plan, {
+      file: plan.brew, args: plan.args, cwd: workDir, osEntries,
+      onLine: (text) => {
+        const next = brewStepOf(text);
+        if (next && next !== at) {
+          at = next;
+          step(next);
+        }
+        line(text);
+      },
+      name: `brew ${plan.args.join(' ')}`,
+    });
+  }
+
   async function run(job) {
     const { plan, tool } = job;
     const io = stepper(job);
@@ -569,9 +694,13 @@ export function createCliInstaller({
       emit(job, { type: 'start', tool, method: plan.kind, source: plan.source, label: plan.label, platform, arch });
       try { before = await readOsPath(); } catch { before = []; }
       workDir = await mkdtemp(path.join(tmpRoot, `synabun-cli-install-${tool}-`));
-      const script = await fetchScript(job, plan, workDir, io);
-      io.step('run');
-      await runScript(job, plan, script, workDir, before, io);
+      if (plan.kind === 'brew') {
+        await runBrew(job, plan, workDir, before, io);
+      } else {
+        const script = await fetchScript(job, plan, workDir, io);
+        io.step('run');
+        await runScript(job, plan, script, workDir, before, io);
+      }
       io.step('check');
       const status = await resolver.resolve(tool, { force: true });
       if (status?.state !== 'installed') {
@@ -618,7 +747,7 @@ export function createCliInstaller({
   }
 
   return {
-    describe: (toolKey) => describeInstall(toolKey, { platform, arch, env, home }),
+    describe: (toolKey) => describePlan(planFor(toolKey)),
     guideUrl: guideOf,
     manualCommand: manualOf,
     jobs() {

package/neural-interface/lib/cli-resolver.js

@@ -1,5 +1,5 @@
 // ═══════════════════════════════════════════
-// SynaBun — where the user's Claude Code, Codex and OpenCode are
+// SynaBun — where the user's Claude Code, Codex, OpenCode and Antigravity (agy) are
 // ═══════════════════════════════════════════
 //
 // One answer for every place that looks for one of these CLIs: the version
@@ -55,7 +55,7 @@ export const CLI_TOOLS = Object.freeze({
   'claude-code': Object.freeze({ key: 'claude-code', command: 'claude', label: 'Claude Code' }),
   codex: Object.freeze({ key: 'codex', command: 'codex', label: 'Codex' }),
   opencode: Object.freeze({ key: 'opencode', command: 'opencode', label: 'OpenCode' }),
-  gemini: Object.freeze({ key: 'gemini', command: 'gemini', label: 'Gemini CLI' }),
+  antigravity: Object.freeze({ key: 'antigravity', command: 'agy', label: 'Antigravity CLI' }),
 });
 
 const PROBE_TIMEOUT_MS = 15_000;
@@ -134,6 +134,10 @@ function wingetPackageFiles({ localAppData, prefixes, exe, readdir, pathImpl })
  *   OpenCode      install script: ~/.opencode/bin/opencode (older scripts:
  *                 $OPENCODE_INSTALL_DIR, $XDG_BIN_DIR); on Windows the folder
  *                 SynaBun's own install uses, %USERPROFILE%\.opencode\bin
+ *   Antigravity   Google's installer (antigravity.google/cli/install.sh, checked
+ *                 2026-10-30): ~/.local/bin/agy; install.ps1 on Windows:
+ *                 %LOCALAPPDATA%\agy\bin\agy.exe. Homebrew's cask links agy
+ *                 into Homebrew's bin, which the package-manager folders cover.
  */
 export function toolSpecificFiles(toolKey, {
   platform = process.platform,
@@ -168,6 +172,9 @@ export function toolSpecificFiles(toolKey, {
       if (env.XDG_BIN_DIR) add(join(env.XDG_BIN_DIR, exe('opencode')), 'standalone');
       if (windows) for (const file of wingetPackageFiles({ localAppData, prefixes: ['sst.opencode', 'anomalyco.opencode', 'opencode.'], exe: 'opencode.exe', readdir, pathImpl })) add(file, 'winget');
       break;
+    case 'antigravity':
+      add(windows ? join(localAppData, 'agy', 'bin', 'agy.exe') : join(home, '.local', 'bin', 'agy'), 'standalone');
+      break;
     default:
       break;
   }