synabun 2.1.0 → 2.2.1

package/neural-interface/lib/pty-host/manager.js

@@ -10,6 +10,7 @@ import { fork } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { EV, OP, UPGRADE_HEADER_WHITELIST } from './protocol.js';
 import { createPtyHostCore } from './core.js';
+import { killOwnedPty } from './lifetime.js';
 
 const HOST_PATH = fileURLToPath(new URL('./host.js', import.meta.url));
 const BACKOFF_MS = [0, 1000, 2000, 4000, 8000, 16000, 30000];
@@ -39,6 +40,7 @@ export function createPtyHostManager({
   const handlers = new Map();     // id → { onSpawned, onTap, onResized, onClients, onExit }
   const spawnWaiters = new Map(); // id → waiter
   const preparing = new Map();   // id → operations queued while PATH is read
+  const ptyPids = new Map();     // id → live PTY PID owned by the current host
   const requests = new Map();     // reqId → { resolve, reject, timer }
   let reqSeq = 0;
   let child = null;
@@ -76,6 +78,7 @@ export function createPtyHostManager({
         releaseHeldSockets();
         break;
       case EV.SPAWNED:
+        ptyPids.set(m.id, m.pid);
         try { handlers.get(m.id)?.onSpawned?.(m); } catch (err) { log.warn?.('[pty-host] onSpawned', err?.message); }
         settleSpawn(m.id, null, m);
         break;
@@ -97,6 +100,7 @@ export function createPtyHostManager({
         try { handlers.get(m.id)?.onClients?.(m); } catch {}
         break;
       case EV.EXIT: {
+        ptyPids.delete(m.id);
         const h = handlers.get(m.id);
         handlers.delete(m.id);
         spawnWaiters.delete(m.id);
@@ -150,6 +154,11 @@ export function createPtyHostManager({
   }
 
   function onChildExit(code, signal) {
+    // A SIGKILL cannot run host.js's disconnect/shutdown handlers. In
+    // particular, a macOS helper still attaching its terminal may survive
+    // closing the PTY master. Reap only this host's still-owned children.
+    for (const pid of ptyPids.values()) killOwnedPty(pid);
+    ptyPids.clear();
     child = null;
     ready = false;
     hostPid = null;
@@ -358,8 +367,10 @@ export function createPtyHostManager({
     for (const id of preparing.keys()) settleSpawn(id, new Error('Terminal host is shutting down'));
     preparing.clear();
     if (restartTimer) { clearTimeout(restartTimer); restartTimer = null; }
+    for (const pid of ptyPids.values()) killOwnedPty(pid);
+    ptyPids.clear();
     try { child?.kill('SIGTERM'); } catch {}
-    try { core?.shutdownAll(); } catch {}
+    try { core?.shutdownAll({ force: true }); } catch {}
   }
 
   return {

package/neural-interface/lib/remote-policy.js

@@ -49,7 +49,7 @@ const RANK = Object.freeze({ 'read-only': 0, ask: 1, autonomous: 2 });
 
 /** Brain providers that can hold a remote session at Ask and Autonomous (the in-process hook). */
 export const REMOTE_ENFORCING_PROVIDERS = Object.freeze(['claude-code']);
-const PROVIDER_LABELS = Object.freeze({ 'claude-code': 'Claude', codex: 'Codex', opencode: 'OpenCode' });
+const PROVIDER_LABELS = Object.freeze({ 'claude-code': 'Claude', codex: 'Codex', opencode: 'OpenCode', antigravity: 'Antigravity' });
 export function providerLabel(provider) { return PROVIDER_LABELS[provider] || String(provider || 'this brain'); }
 /** True for a known brain other than Claude: a remote session on it is read-only. */
 export function remoteBrainLimited(provider) {

package/neural-interface/lib/request-gate.js

@@ -96,6 +96,9 @@ export const ADMIN_ONLY_PREFIXES = Object.freeze([
   '/api/project-files',
   '/api/browse-folder',
   '/api/codex/plans',
+  // Antigravity's own conversations and models: each uncached answer starts the owner's `agy` (its side panel
+  // socket is refused to guests too).
+  '/api/antigravity',
   '/api/sidepanel',
   '/api/sidepanel-runs',
   '/api/loop',

package/neural-interface/lib/rulesets/api.js

@@ -41,9 +41,10 @@
 
 import { isRulesetHost, readRulesetManifest, renderCoexistenceSnippet, renderRuleset, RULESET_HOSTS } from './render.js';
 
-// The pre-2.0 `format` names, as the onboarding wizard and Settings still send them.
-const LEGACY_FORMATS = Object.freeze({ claude: 'claude', codex: 'codex', cursor: 'cursor', generic: 'opencode', opencode: 'opencode', gemini: 'gemini' });
-const LEGACY_VERSION_FORMATS = Object.freeze(['claude', 'codex', 'cursor', 'generic', 'gemini']);
+// The pre-2.0 `format` names, as the onboarding wizard and Settings still send them. `gemini` is what a page from
+// before Antigravity replaced Gemini CLI asks for: Antigravity's text, which reads the same files.
+const LEGACY_FORMATS = Object.freeze({ claude: 'claude', codex: 'codex', cursor: 'cursor', generic: 'opencode', opencode: 'opencode', antigravity: 'antigravity', gemini: 'antigravity' });
+const LEGACY_VERSION_FORMATS = Object.freeze(['claude', 'codex', 'cursor', 'generic', 'antigravity']);
 // A copy someone edited, damaged markers, a CLI that is not there: the request was fine, the files said no.
 const REFUSED_STATES = new Set(['not-installed', 'modified', 'conflict', 'error']);
 const REFUSED_CODES = new Set(['REMOVE_INCOMPLETE', 'CHANGED_UNDERNEATH', 'BUSY']);
@@ -133,7 +134,7 @@ export function legacyRulesetPayload(format, { render = renderRuleset } = {}) {
   const name = String(format || 'claude').toLowerCase();
   if (name === 'coexistence') return { ok: true, ruleset: renderCoexistenceSnippet().text, format: name };
   const host = LEGACY_FORMATS[name];
-  if (!host) return { status: 400, error: `Invalid format: ${name}. Use claude, cursor, generic, gemini, codex, or coexistence.` };
+  if (!host) return { status: 400, error: `Invalid format: ${name}. Use claude, cursor, generic, antigravity, codex, or coexistence.` };
   return { ok: true, ruleset: render(host).text, format: name };
 }
 
@@ -155,7 +156,7 @@ export function legacyRulesetVersionsPayload() {
 
 /** The two endpoints the pre-2.0 UI reads. Same shapes as before, served from the renderer. */
 export function registerLegacyRulesetRoutes(app, { render = renderRuleset } = {}) {
-  // Supports ?format=claude (default) | cursor | generic | gemini | codex | coexistence
+  // Supports ?format=claude (default) | cursor | generic | antigravity | codex | coexistence
   app.get('/api/claude-code/ruleset', (req, res) => {
     try {
       const payload = legacyRulesetPayload(req.query.format, { render });

package/neural-interface/lib/rulesets/fs-safe.js

@@ -3,7 +3,7 @@
 // ═══════════════════════════════════════════
 //
 // The rules installer edits files that belong to the user and to other CLIs
-// (~/.codex/AGENTS.md, ~/.gemini/GEMINI.md, OpenCode's opencode.json). These
+// (~/.codex/AGENTS.md, ~/.gemini/config/GEMINI.md, OpenCode's opencode.json). These
 // helpers make each write all-or-nothing, keep a symlinked file a symlink,
 // refuse to write through a link that points at nothing, keep a copy of what
 // was there before, never read a corrupt JSON file as `{}`, and never write

package/neural-interface/lib/rulesets/installer.js

@@ -8,7 +8,9 @@
 //   claude    owned file  ~/.claude/rules/synabun.md (and each Claude account's config dir)
 //   opencode  owned file  <opencode config dir>/synabun.md + one `instructions` entry in opencode.json
 //   codex     block       ~/.codex/AGENTS.md (account homes link to it, or get their own block)
-//   gemini    block       ~/.gemini/GEMINI.md
+//   antigravity block     ~/.gemini/config/GEMINI.md (Antigravity's global customization root; the block an
+//                         older SynaBun wrote for Gemini CLI in ~/.gemini/GEMINI.md, which Antigravity also
+//                         reads, is moved here so the rules are never loaded twice)
 //   cursor    none        User Rules live inside the app: copy and paste ("manual")
 //
 // What it will not do: create the config directory of a CLI that is not
@@ -83,11 +85,18 @@ const HOSTS = Object.freeze({
   claude: { label: 'Claude Code', carrier: 'file' },
   codex: { label: 'Codex CLI', carrier: 'block' },
   opencode: { label: 'OpenCode', carrier: 'file' },
-  gemini: { label: 'Gemini CLI', carrier: 'block' },
+  // `legacyHosts`: the stamps an earlier SynaBun wrote for what this host replaced (Gemini CLI's rules, host=gemini).
+  antigravity: { label: 'Antigravity', carrier: 'block', legacyHosts: Object.freeze(['gemini']) },
   cursor: { label: 'Cursor', carrier: 'none' },
 });
 const MANAGED_HOSTS = Object.freeze(RULESET_HOSTS.filter((host) => HOSTS[host].carrier !== 'none'));
-const PROJECT_FILES = Object.freeze([['CLAUDE.md', 'claude'], ['AGENTS.md', 'codex'], ['GEMINI.md', 'gemini']]);
+const PROJECT_FILES = Object.freeze([['CLAUDE.md', 'claude'], ['AGENTS.md', 'codex'], ['GEMINI.md', 'antigravity']]);
+// State rows an earlier SynaBun kept under a host this one replaced: read as the new host's row (readState).
+const RENAMED_HOSTS = Object.freeze({ gemini: 'antigravity' });
+/** Whether a block's stamp is this host's own: its name, or one it replaced. */
+function ownStamp(host, stamped) {
+  return stamped === host || (HOSTS[host]?.legacyHosts || []).includes(stamped);
+}
 const RANK = Object.freeze({ missing: 0, current: 1, newer: 2, outdated: 3, modified: 4, conflict: 5, error: 6 });
 const MAX_SCAN_BYTES = 2 * 1024 * 1024;
 
@@ -259,6 +268,17 @@ export function createRulesetInstaller({
       return view();
     }
     if (!isPlainObject(saved)) return view();
+    // A row kept under a host this SynaBun replaced (Gemini CLI → Antigravity) is the new host's row, marked
+    // `movedFrom` until reconcile has put the rules where the new host reads them (see reconcileHosts).
+    for (const [old, now] of Object.entries(RENAMED_HOSTS)) {
+      const hosts = isPlainObject(saved.hosts) ? saved.hosts : null;
+      if (hosts && isPlainObject(hosts[old]) && !isPlainObject(hosts[now])) {
+        saved.hosts = { ...hosts, [now]: { ...hosts[old], ...(hosts[old].managed === true ? { movedFrom: old } : {}) } };
+        delete saved.hosts[old];
+      }
+      if (Array.isArray(saved.offerAcked)) saved.offerAcked = saved.offerAcked.map((host) => (host === old ? now : host));
+      if (isPlainObject(saved.notice) && Array.isArray(saved.notice.hosts)) saved.notice = { ...saved.notice, hosts: unique(saved.notice.hosts.map((host) => (host === old ? now : host))) };
+    }
     if (Number.isSafeInteger(saved.revision) && saved.revision > 0) state.revision = saved.revision;
     if (typeof saved.autoUpdate === 'boolean') state.autoUpdate = saved.autoUpdate;
     if (isPlainObject(saved.notice)) state.notice = saved.notice;
@@ -352,7 +372,7 @@ export function createRulesetInstaller({
 
   // ── Where things live ──────────────────────────────────────────────────────
   // Resolved the way the MCP toggle routes resolve them: Claude, Codex and
-  // Gemini under the home directory, OpenCode in its configuration folder
+  // Antigravity under the home directory, OpenCode in its configuration folder
   // (OPENCODE_CONFIG_DIR, else XDG_CONFIG_HOME/opencode, else ~/.config/opencode),
   // whose opencode.json OpenCode 2 reads (lib/opencode-config.js).
   function layout() {
@@ -363,6 +383,9 @@ export function createRulesetInstaller({
     return {
       claudeDir: join(home, '.claude'),
       codexHome: join(home, '.codex'),
+      // Antigravity's global customization root (rules, skills, mcp_config.json), and the folder above it, where
+      // Gemini CLI's GEMINI.md lives (Antigravity reads that file too).
+      antigravityDir: join(home, '.gemini', 'config'),
       geminiDir: join(home, '.gemini'),
       opencodeDir: dirname(opencodeConfig),
       opencodeConfig,
@@ -416,7 +439,7 @@ export function createRulesetInstaller({
         ...codexAccounts().filter((account) => account.kind === 'file').map(({ path, dir }) => ({ path, dir })),
       ];
     }
-    if (host === 'gemini') return [{ path: join(where.geminiDir, 'GEMINI.md'), dir: where.geminiDir }];
+    if (host === 'antigravity') return [{ path: join(where.antigravityDir, 'GEMINI.md'), dir: where.antigravityDir, legacyBlock: join(where.geminiDir, 'GEMINI.md') }];
     return [];
   }
   function projectPaths() {
@@ -428,7 +451,10 @@ export function createRulesetInstaller({
     const where = layout();
     try {
       if (host === 'claude') return !!JSON.parse(readFileSync(join(home, '.claude.json'), 'utf8'))?.mcpServers?.SynaBun;
-      if (host === 'gemini') return !!JSON.parse(readFileSync(join(where.geminiDir, 'settings.json'), 'utf8'))?.mcpServers?.SynaBun;
+      if (host === 'antigravity') {
+        const text = readFileSync(join(where.antigravityDir, 'mcp_config.json'), 'utf8').replace(/^\uFEFF/, '');
+        return text.trim() ? !!JSON.parse(text)?.mcpServers?.SynaBun : false;
+      }
       if (host === 'codex') return /^\[mcp_servers\.SynaBun\]/m.test(readFileSync(join(where.codexHome, 'config.toml'), 'utf8'));
       if (host === 'opencode') return !!mcpServersOf(mergedOpencodeConfig(readOpencodeConfigDocuments(where.opencodeDir))).SynaBun;
     } catch { /* no config, no registration */ }
@@ -481,7 +507,7 @@ export function createRulesetInstaller({
     }
     const block = blocks[0] || null;
     // A stamp for another tool is not this host's copy, however untouched it is: never updated, never removed.
-    if (block && block.host !== host) return { status: 'conflict', text, bytes, detail: `${foreignBlock(host, block, target.path)} Replace does not apply here: take that block out by hand, then install again.` };
+    if (block && !ownStamp(host, block.host)) return { status: 'conflict', text, bytes, detail: `${foreignBlock(host, block, target.path)} Replace does not apply here: take that block out by hand, then install again.` };
     if (HOSTS[host].carrier === 'file') {
       if (normalise(text) === expected.block) return { status: 'current', text, bytes, block };
       if (!block) return { status: 'modified', text, bytes, block, detail: `${target.path} has no SynaBun markers, so SynaBun treats it as your own file and never replaces it. Move or delete it, then install again.` };
@@ -756,6 +782,45 @@ export function createRulesetInstaller({
     }
     tally.changed = true;
   }
+  /**
+   * The block an earlier SynaBun wrote where this host's tool also reads rules, under a name this host replaced
+   * (Gemini CLI's ~/.gemini/GEMINI.md, host=gemini, which Antigravity reads beside its own ~/.gemini/config/GEMINI.md):
+   * once the rules are where the new host keeps them, an untouched old block goes, or the tool would load them twice.
+   * An edited one is the user's: it stays, with a warning. A file that held nothing else and that SynaBun created is
+   * deleted; any other file keeps everything but the block. Never forced.
+   */
+  function moveLegacyBlock(host, file, row, tally) {
+    let bytes;
+    try { bytes = readBytes(file); } catch { return; }
+    if (bytes === null) return;
+    const text = bytes.toString('utf8');
+    const { blocks, conflict } = findBlocks(text);
+    if (conflict) {
+      tally.warnings.push(`${conflict.message} in ${file}, which ${HOSTS[host].label} also reads, so SynaBun left it as it is: remove the old SynaBun marker lines by hand.`);
+      return;
+    }
+    const block = blocks[0];
+    if (!block || !ownStamp(host, block.host)) return;
+    if (!isPristine(block)) {
+      tally.warnings.push(`The SynaBun block an earlier version wrote in ${file} was edited, so it stays there. ${HOSTS[host].label} reads that file as well: take that block out by hand, or the rules are loaded twice.`);
+      return;
+    }
+    const next = removeBlock(text);
+    const created = Array.isArray(row.created) && row.created.some((path) => samePath(path, file));
+    try {
+      tally.backup(backedUp(file, host, () => {
+        if (created && !isSymlink(file) && withoutBom(next).trim() === '') unlinkUnchanged(file, text);
+        else commit(file, next, text);
+      }));
+    } catch (error) {
+      if (error?.code !== 'CHANGED_UNDERNEATH') throw error;
+      tally.warnings.push(`${file} changed while SynaBun was moving its old rules out of it, so it was left as it is.`);
+      return;
+    }
+    tally.changed = true;
+    row.paths = row.paths.filter((path) => !samePath(path, file));
+    row.created = row.created.filter((path) => !samePath(path, file));
+  }
   /**
    * One carrier. Returns the status it ended in; writes only when the copy is
    * missing, untouched and old, or (forced) one well-formed copy that was
@@ -951,7 +1016,7 @@ export function createRulesetInstaller({
     };
     for (const target of targets('claude')) add(target.legacyFile, 'claude', 'global');
     for (const target of targets('codex')) add(target.path, 'codex', 'global');
-    for (const target of targets('gemini')) add(target.path, 'gemini', 'global');
+    for (const target of targets('antigravity')) { add(target.path, 'antigravity', 'global'); add(target.legacyBlock, 'antigravity', 'global'); }
     for (const target of targets('opencode')) add(target.legacyFile, 'opencode', 'global');
     for (const dir of projectPaths()) {
       for (const [name, host] of PROJECT_FILES) add(join(dir, name), host, 'project');
@@ -1047,6 +1112,7 @@ export function createRulesetInstaller({
         }
       }
       if (host === 'opencode' && !moveOpencode1Entry(row, tally)) addOpencodeEntry(row, tally);
+      for (const target of list) if (target.legacyBlock) moveLegacyBlock(host, target.legacyBlock, row, tally);
 
       Object.assign(row, {
         managed: true,
@@ -1181,7 +1247,7 @@ export function createRulesetInstaller({
     const created = new Set(row.created);
     // Every place a copy can be: the host's carriers, the row's paths, and what an unfinished removal recorded.
     const recorded = Array.isArray(row.removal?.paths) ? row.removal.paths.filter((path) => typeof path === 'string') : [];
-    const paths = unique([...list.map((target) => target.path), ...row.paths, ...recorded]);
+    const paths = unique([...list.map((target) => target.path), ...list.map((target) => target.legacyBlock).filter(Boolean), ...row.paths, ...recorded]);
     /** Intent first: the paths about to go are saved before the first of them is touched. */
     const recordIntent = (planned) => {
       row.removal = { at: stamp(), error: INTERRUPTED, paths: unique(planned) };
@@ -1256,7 +1322,7 @@ export function createRulesetInstaller({
           if (conflict) { refuse(path, 'conflict', `${conflict.message} in ${path}. SynaBun will not guess: remove the SynaBun marker lines by hand, then remove again.`); continue; }
           const block = blocks[0];
           if (!block) continue;
-          if (block.host !== host) { refuse(path, 'conflict', `${foreignBlock(host, block, path)} Take that block out by hand if you no longer want it.`); continue; }
+          if (!ownStamp(host, block.host)) { refuse(path, 'conflict', `${foreignBlock(host, block, path)} Take that block out by hand if you no longer want it.`); continue; }
           const pristine = isPristine(block);
           if (!force && !pristine) {
             left.push({ path, reason: 'edited', message: `The SynaBun block in ${path} was edited, so SynaBun left it in place and no longer manages it.` });
@@ -1413,6 +1479,19 @@ export function createRulesetInstaller({
         // config.json does not list any more is not moved: the user took it out, which is the opt-out below.
         const older = config && first.status !== 'missing' && !config.hasEntry ? opencode1Record(row) : null;
         const moving = older !== null && opencode1Listed(older);
+        if (first.status === 'missing' && row.movedFrom && isDir(primary.dir)) {
+          // A host this SynaBun replaced (Gemini CLI → Antigravity) was managed: its rules go where the new host reads
+          // them, and the old block goes (installHost moves it). Not an opt-out: nothing was deleted by the user.
+          const moved = installHost(state, host, { force: false }, call);
+          if (moved.ok) { delete row.movedFrom; updated.push(host); to = expected.version; from = from || row.installedVersion || null; }
+          states[host] = hostStatus(host, state).state;
+          continue;
+        }
+        if (first.status === 'missing' && row.movedFrom) {
+          // The new host's folder is not there yet (Antigravity not installed): nothing to move to; asked again later.
+          states[host] = 'not-installed';
+          continue;
+        }
         if (first.status === 'missing' || (config && !config.hasEntry && !moving)) {
           // The user deleted it: an opt-out, never a reason to put it back. (A copy SynaBun's own removal took is
           // not this case: that removal is on record and was dealt with above.)

package/neural-interface/lib/rulesets/render.js

@@ -18,7 +18,7 @@ import { normalise, sha12 } from './normalise.js';
 
 export { normalise, sha12 };
 
-export const RULESET_HOSTS = Object.freeze(['claude', 'codex', 'opencode', 'gemini', 'cursor']);
+export const RULESET_HOSTS = Object.freeze(['claude', 'codex', 'opencode', 'antigravity', 'cursor']);
 export const RULESETS_DIR = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', 'templates', 'rulesets');
 
 const HOST_SLOT = '<!-- host -->';

package/neural-interface/lib/session-cache-builder.js

@@ -3,7 +3,7 @@ import { normalizeMemoryEvents, ingestMemoryEvents } from '../../mcp-server/dist
 import { detectProject } from '../../mcp-server/dist/config.js';
 /**
  * Session Cache Builder — populates session_cache + session_fts for
- * Claude Code, Codex CLI, and OpenCode so the Resume surfaces can do
+ * Claude Code, Codex CLI, OpenCode and Antigravity so the Resume surfaces can do
  * full-body keyword search via FTS5.
  *
  * Per-provider rebuilders walk the provider's session storage, extract
@@ -25,6 +25,7 @@ import {
 import { parseLine } from './session-chunker.js';
 import { listCodexSessionsFromAccounts } from './codex-session-catalog.js';
 import { OPENCODE_SESSION_TABLES, hasOpencodeSessionTables, v2MessageText } from './opencode-db-schema.js';
+import { listAntigravityConversations, parseAntigravityTranscript, readTranscriptText } from './antigravity/transcripts.js';
 
 const MAX_BODY = 256 * 1024;
 const MAX_MSG_CHARS = 8 * 1024;
@@ -493,6 +494,68 @@ export function rebuildOpencodeCache({ getOpencodeDb, onProgress } = {}) {
   return { sessions: total, updated };
 }
 
+// --- Antigravity ---
+
+// agy keeps one transcript.jsonl per conversation (lib/antigravity/transcripts.js). Every conversation it holds,
+// SynaBun's brain and run homes included, is queued for memory capture; the user's own (the panel's and a terminal
+// agy's, the only ones the panel can load again) also go into the Resume index, titled as Antigravity titles them.
+// A conversation unchanged since the last pass (size, time, folder, title) is not read again. `only`: one
+// conversation (a panel turn just ended), the others left as they are. Request/timer paths read at most
+// MAX_BODY bytes per transcript: the index is bounded; full transcripts remain available to memory capture.
+export function rebuildAntigravityCache({ stores = [], only = null, onProgress, list = listAntigravityConversations, read = readTranscriptText } = {}) {
+  const emit = onProgress || (() => {});
+  let conversations;
+  try { conversations = list(stores); } catch { return { sessions: 0, updated: 0 }; }
+  if (only) conversations = conversations.filter((c) => c.sessionId === only);
+  const listed = new Set(conversations.filter((c) => c.store === 'user').map((c) => c.sessionId));
+  const total = listed.size;
+  let updated = 0;
+  for (const c of conversations) {
+    try {
+      queueMemoryCapture({ host: 'antigravity', sessionId: c.sessionId, filePath: c.transcript, cwd: c.cwd || undefined, project: c.cwd ? detectProject(c.cwd) : 'global', size: c.size });
+    } catch { /* memory capture is best effort */ }
+    if (c.store !== 'user') continue;
+    const mtimeIso = new Date(c.mtimeMs).toISOString();
+    const existing = getSessionCacheEntry(c.sessionId, 'antigravity');
+    if (existing && !existing.deleted && Number(existing.file_size) === c.size && existing.file_mtime === mtimeIso
+        && (existing.project_path || null) === (c.cwd || null) && (!c.title || existing.first_prompt === c.title)) continue;
+    const parsed = parseAntigravityTranscript(read(c.transcript, { maxBytes: MAX_BODY }));
+    let body = '';
+    for (const message of parsed.messages) {
+      if (message.role !== 'user' && message.role !== 'assistant') continue;
+      if (message.text) body = appendBody(body, message.text.slice(0, MAX_MSG_CHARS));
+    }
+    const firstPrompt = c.title || parsed.firstPrompt;
+    const project = c.cwd ? basename(c.cwd) : null;
+    upsertSessionCache({
+      session_id: c.sessionId,
+      provider: 'antigravity',
+      project,
+      project_path: c.cwd,
+      git_branch: null,
+      first_prompt: firstPrompt,
+      message_count: parsed.messageCount,
+      created: parsed.created,
+      modified: c.updatedAt || parsed.modified || mtimeIso,
+      file_path: c.transcript,
+      file_size: c.size,
+      file_mtime: mtimeIso,
+      body_size: body.length,
+      deleted: 0,
+    });
+    upsertSessionFts({ session_id: c.sessionId, provider: 'antigravity', project, first_prompt: firstPrompt, body });
+    updated++;
+    emit({ type: 'cache:session', provider: 'antigravity', sessionId: c.sessionId, done: updated, total });
+  }
+  // A conversation Antigravity no longer has (deleted there, or its folder cleared) leaves Resume.
+  if (!only) {
+    for (const cached of listSessionCache('antigravity', { limit: 100000 })) {
+      if (!listed.has(cached.session_id) && !cached.deleted) markSessionDeleted(cached.session_id, 'antigravity', true);
+    }
+  }
+  return { sessions: total, updated };
+}
+
 // --- Single-session refresh (for piggyback from session-indexer) ---
 
 export function updateSessionCacheEntry(provider, sessionId, opts = {}) {

package/neural-interface/lib/skills/catalog.js

@@ -178,8 +178,12 @@ export function createSkillsCatalog({ roots, readHead, describe, ownership = ()
           });
         }
       } else {
+        // Antigravity's rule for two skills of one name (its folder and a project's .agents/skills) is not known here.
+        const why = runtime === 'antigravity'
+          ? 'Antigravity sees more than one skill of this name; which one it uses is not certain. Give them different names.'
+          : `${runtime === 'codex' ? 'Codex' : 'OpenCode'} lists every skill of this name; which one the model picks is not fixed. Give them different names.`;
         for (const e of list) {
-          (e.collisions ||= []).push({ runtime, with: list.filter((x) => x !== e).map((x) => x.id), outcome: 'both-listed', why: `${runtime === 'codex' ? 'Codex' : 'OpenCode'} lists every skill of this name; which one the model picks is not fixed. Give them different names.` });
+          (e.collisions ||= []).push({ runtime, with: list.filter((x) => x !== e).map((x) => x.id), outcome: 'both-listed', why });
         }
       }
     }

package/neural-interface/lib/skills/creation-brief.js

@@ -82,7 +82,7 @@ const literal = (value, max) => { const s = String(value ?? ''); return JSON.str
  */
 export function buildDraftingBrief({ jobId, request, sources = [] }) {
   const name = request?.name || '';
-  const runtimes = [...new Set((request?.targets || []).map((t) => ({ claude: 'Claude Code', codex: 'Codex', opencode: 'OpenCode', agents: 'Codex and OpenCode (shared folder)' }[t.runtime])).filter(Boolean))];
+  const runtimes = [...new Set((request?.targets || []).map((t) => ({ claude: 'Claude Code', codex: 'Codex', opencode: 'OpenCode', antigravity: 'Antigravity', agents: 'Codex and OpenCode (shared folder)' }[t.runtime])).filter(Boolean))];
   const prompt = request?.prompt ? quoteBounded(request.prompt, PROMPT_IN_BRIEF) : null;
   const example = request?.example ? quoteBounded(request.example, EXAMPLE_IN_BRIEF) : null;
   const lines = [

package/neural-interface/lib/skills/creation-sources.js

@@ -1,6 +1,6 @@
 // ── AI skill creation: the sources a draft is made from (P3) ──
 // What lib/skills/creation.js puts in a drafting job's workspace (`sources/`) before the worker starts: one session
-// transcript of Claude Code, Codex or OpenCode, SynaBun memories, a read-only snapshot of a registered project, the
+// transcript of Claude Code, Codex, OpenCode or Antigravity, SynaBun memories, a read-only snapshot of a registered project, the
 // files of an existing skill. Every file opens with a line saying it is untrusted data, secrets are taken out
 // (lib/log-redact.js: before anything is cut short, so half a secret never survives), and every source has a
 // budget: what does not fit is cut, and the manifest says so. A web page is read by the server with the SynaBun
@@ -91,6 +91,24 @@ export function opencodeRowsToMessages(rows) {
   return out;
 }
 
+/**
+ * Antigravity's transcript as lib/antigravity/transcripts.js parses it (parseAntigravityTranscript().messages:
+ * { role: user | assistant | tool_result, text, tools }) → messages: the person's words, the model's answers and
+ * the tools it called (never its reasoning), and what the tools gave back.
+ */
+export function antigravityMessagesToMessages(messages) {
+  const out = [];
+  for (const m of Array.isArray(messages) ? messages : []) {
+    if (!m || typeof m !== 'object') continue;
+    if (m.role === 'user' && typeof m.text === 'string' && m.text.trim()) out.push({ role: 'user', text: m.text });
+    else if (m.role === 'assistant') {
+      if (typeof m.text === 'string' && m.text.trim()) out.push({ role: 'assistant', text: m.text });
+      for (const t of Array.isArray(m.tools) ? m.tools : []) out.push({ role: 'tool', tool: String(t?.name || 'tool'), text: safeJson(t?.input) });
+    } else if (m.role === 'tool_result' && typeof m.text === 'string' && m.text.trim()) out.push({ role: 'tool_result', text: m.text, error: m.error === true });
+  }
+  return out;
+}
+
 function safeJson(value) {
   try { return typeof value === 'string' ? value : JSON.stringify(value ?? {}); } catch { return ''; }
 }

package/neural-interface/lib/skills/deploy.js

@@ -1,8 +1,9 @@
 // ── Installing library revisions into runtime folders ──
 // An install puts one revision of a library skill (lib/skills/library.js) into one or more runtime folders as a
 // native skill folder: Claude Code (<config dir>/skills or a project's .claude/skills), Codex ($CODEX_HOME/skills
-// or a project's .agents/skills), OpenCode (<config>/opencode/skills or a project's .opencode/skills), and the
-// shared ~/.agents/skills only when the owner turned it on. It is two steps:
+// or a project's .agents/skills, which Antigravity reads too), OpenCode (<config>/opencode/skills or a project's
+// .opencode/skills), Antigravity (~/.gemini/config/skills), and the shared ~/.agents/skills only when the owner
+// turned it on. It is two steps:
 //
 //   plan(…)    what each target would receive (the export of the revision for that runtime, with its digest),
 //              where, which runtimes see that folder (and what else of that name they already see), what is there
@@ -39,7 +40,7 @@ import { PORTABLE_NAME_RE, TARGET_PROFILE, getProfile, lintForProfile } from '..
 import { analyzeResources, argumentDiagnostics } from '../../public/shared/skills/ss-resources.js';
 import { isEditableText } from '../../public/shared/skills/ss-doc.js';
 
-export const INSTALL_TARGETS = Object.freeze(['claude', 'codex', 'opencode', 'agents']);
+export const INSTALL_TARGETS = Object.freeze(['claude', 'codex', 'opencode', 'antigravity', 'agents']);
 export const INSTALLATIONS_SCHEMA = 2;
 const MAX_INSTALLATIONS = 2000;
 
@@ -66,9 +67,11 @@ const REFRESH = {
   opencode: (rootExisted, root) => (root?.family === 'claude'
     ? { kind: 'terminal-only', message: 'An OpenCode open in a terminal reads Claude Code\'s folder (new session); SynaBun\'s own OpenCode panel and an OpenCode Assistant do not: install for OpenCode for those.' }
     : { kind: 'panel-reload', message: 'SynaBun\'s OpenCode panel lists it now; an OpenCode open in a terminal needs a new session.' }),
+  // Antigravity reads its skill folders again by itself: there is no command to run.
+  antigravity: () => ({ kind: 'automatic', message: 'Antigravity picks up the change by itself.' }),
 };
 
-const RUNTIME_LABEL = { claude: 'Claude Code', codex: 'Codex', opencode: 'OpenCode', agents: 'the shared agents folder' };
+const RUNTIME_LABEL = { claude: 'Claude Code', codex: 'Codex', opencode: 'OpenCode', antigravity: 'Antigravity', agents: 'the shared agents folder' };
 
 /** A target as a request may name it, checked. */
 export function normalizeTarget(t) {
@@ -78,6 +81,8 @@ export function normalizeTarget(t) {
   const scope = t.scope === undefined ? 'user' : t.scope;
   if (scope !== 'user' && scope !== 'project') throw new DeployError(400, 'A target\'s scope is user or project.', 'invalid_target');
   if (runtime === 'agents' && scope !== 'user') throw new DeployError(400, 'The shared agents folder is a user folder; a project\'s .agents/skills is the codex target with scope project.', 'invalid_target');
+  // Antigravity has no project folder of its own: it reads the project's .agents/skills, the Codex project folder.
+  if (runtime === 'antigravity' && scope !== 'user') throw new DeployError(400, 'Antigravity reads a project\'s .agents/skills: that is the codex target with scope project.', 'invalid_target');
   const accountId = t.accountId === undefined || t.accountId === null || t.accountId === '' ? 'default' : t.accountId;
   if (typeof accountId !== 'string' || !/^[A-Za-z0-9_-]{1,64}$/.test(accountId)) throw new DeployError(400, 'Not an account id.', 'invalid_target');
   if (scope === 'project' && (typeof t.projectPath !== 'string' || !t.projectPath)) throw new DeployError(400, 'A project target names its project (projectPath).', 'invalid_target');

package/neural-interface/lib/skills/draft-confinement.js

@@ -139,7 +139,9 @@ export function draftConfinementSupport(provider, { platform = process.platform
     };
   }
   if (name === 'opencode') return { ok: true, level: 'rules', note: 'OpenCode with its shell, web, subagent and skill tools switched off, no MCP server, and every edit answered inside its folder only.' };
-  return { ok: false, reason: `${name || 'That provider'} cannot be held to a drafting folder.` };
+  // Antigravity (a worker of the Assistant) has no drafting confinement in SynaBun: a drafting run never starts unconfined.
+  if (name === 'antigravity') return { ok: false, reason: 'Antigravity cannot be held to a drafting folder: skill drafting runs on Claude Code, Codex and OpenCode.' };
+  return { ok: false, reason: `${name || 'That provider'} cannot be held to a drafting folder: skill drafting runs on Claude Code, Codex and OpenCode.` };
 }
 
 /** The MCP server names a Codex config.toml declares ([mcp_servers.NAME] tables), for disabling them one by one. */

package/neural-interface/lib/skills/eval-confinement.js

@@ -96,7 +96,9 @@ export function evalConfinementSupport(provider, { platform = process.platform }
   if (name === 'claude-code') return { ok: true, level: 'strict', shell: platform === 'darwin' ? 'sandbox' : 'never', optIn: false, note: 'Read, Write, Edit, Glob, Grep and Skill inside its folder; no settings file, hook or plugin but the skill under test; a shell only under the evaluation\'s macOS sandbox (no network, no home folder); no web, no MCP tools, no subagents.' };
   if (name === 'codex') return { ok: true, level: 'sandbox', shell: 'own-sandbox', optIn: true, note: `Codex keeps its shell under its ${platform === 'win32' ? 'Windows' : platform === 'darwin' ? 'Seatbelt' : 'Linux'} sandbox: writes inside its folder only, no network, no web search, no MCP server; its shell can read files anywhere on this computer, and what it reads can reach its model provider.` };
   if (name === 'opencode') return { ok: true, level: 'rules', shell: platform === 'darwin' ? 'sandbox' : 'never', optIn: false, note: 'OpenCode with no project configuration or plugin of the folder, its web, subagent and todo tools off, no MCP server, reads and edits inside its folder only; a shell only under the evaluation\'s macOS sandbox (no network, no home folder).' };
-  return { ok: false, reason: `${name || 'That provider'} cannot be held to an evaluation folder.` };
+  // Antigravity (a worker of the Assistant) has no evaluation confinement in SynaBun: an evaluation never runs unconfined.
+  if (name === 'antigravity') return { ok: false, reason: 'Antigravity cannot be held to an evaluation folder: skill evaluations run on Claude Code, Codex and OpenCode.' };
+  return { ok: false, reason: `${name || 'That provider'} cannot be held to an evaluation folder: skill evaluations run on Claude Code, Codex and OpenCode.` };
 }
 
 /**

package/neural-interface/lib/skills/eval-trace.js

@@ -60,6 +60,22 @@ export function toolCallsOf(payload = {}) {
     }
     return out;
   }
+  if (payload.provider === 'antigravity') {
+    // An ACP tool call (session/update tool_call, then tool_call_update with its status). Antigravity names its
+    // tool (read_file, run_command, call_mcp_tool …) and its arguments in its own words: the path a read names
+    // and a command's line are kept under `path` / `command`; an MCP call is <server>.<tool>.
+    if ((eventType === 'tool_call' || eventType === 'tool_call_update') && event.toolCallId) {
+      const raw = isObject(event.rawInput) ? event.rawInput : {};
+      const mcp = String(event.name || '') === 'call_mcp_tool' && raw.ServerName && raw.ToolName ? `${raw.ServerName}.${raw.ToolName}` : '';
+      const location = Array.isArray(event.locations) ? event.locations.find((l) => typeof l?.path === 'string' && l.path)?.path : '';
+      const path = [raw.AbsolutePath, raw.Path, raw.TargetFile, raw.path, raw.file_path, location].find((v) => typeof v === 'string' && v) || '';
+      const command = typeof raw.CommandLine === 'string' ? raw.CommandLine : typeof raw.command === 'string' ? raw.command : '';
+      const input = { ...(path ? { path } : {}), ...(command ? { command } : {}) };
+      const status = String(event.status || '');
+      out.push({ id: String(event.toolCallId), tool: mcp || String(event.name || event.kind || ''), input, phase: status, ok: status === 'completed' ? true : status === 'failed' ? false : null });
+    }
+    return out;
+  }
   return out;
 }
 

package/neural-interface/lib/skills/export.js

@@ -7,7 +7,10 @@
 //   - Claude Code: `disable-model-invocation: true` / `user-invocable: false` in SKILL.md (that key only);
 //   - Codex: `policy.allow_implicit_invocation: false` in agents/openai.yaml (made when there is none; otherwise
 //     that one value is set and every other value, comment and order is kept);
-//   - OpenCode: metadata `opencode/autoinvoke: "false"` in SKILL.md (the metadata key only).
+//   - OpenCode: metadata `opencode/autoinvoke: "false"` in SKILL.md (the metadata key only);
+//   - Antigravity: `disable-slash-command: true` in SKILL.md (that key only) for a skill the person may not start by
+//     name. Antigravity has no setting that keeps its model from starting a skill: an export of an explicit-only
+//     skill for it is refused (L-08-invocation-unrepresentable), never written wider.
 // A Codex export also carries the harness metadata Codex shows in its skill picker (agents/openai.yaml
 // `interface`: display_name, short_description, default_prompt, from the skill's own name and description; the
 // 02-standards-runtimes report, §6.3). A sidecar that is already there keeps every value it has: only the interface
@@ -140,7 +143,7 @@ export function buildExport({ files, dirs = [] }, profileId) {
       }
       const next = patchHead(headText, changes);
       if (next === null) {
-        diagnostics.push({ ruleId: 'L-08-adapt-failed', severity: 'error', message: `The SKILL.md frontmatter could not be changed to keep ${profile?.title || profileId} from ${t.key === 'user-invocable' ? 'showing it to the person' : 'starting it on its own'}: fix the YAML first.`, file: 'SKILL.md', line: null });
+        diagnostics.push({ ruleId: 'L-08-adapt-failed', severity: 'error', message: `The SKILL.md frontmatter could not be changed to keep ${profile?.title || profileId} from ${t.key === 'user-invocable' || t.key === 'disable-slash-command' ? 'showing it to the person' : 'starting it on its own'}: fix the YAML first.`, file: 'SKILL.md', line: null });
         continue;
       }
       headText = next;