synabun 2.0.10 → 2.2.0

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

@@ -6,9 +6,11 @@
 // keeps an untouched copy current:
 //
 //   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 config.json
+//   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
@@ -29,7 +31,7 @@
 // (the user opted out) or null (never asked). `created` lists the files and
 // directories install made, `links` the symlinks it made and where each
 // pointed. OpenCode's row also holds `instructionsEntry`, the exact string
-// SynaBun added to config.json. `removal` on a row is a removal that is not
+// SynaBun added to opencode.json. `removal` on a row is a removal that is not
 // over: it is saved, with the paths it is about to take, before the first
 // copy goes, and it stays when a copy was refused (damaged markers, an
 // unreadable file). The next boot finishes it (reconcile), and the record is
@@ -74,6 +76,7 @@ import { loadLegacyHashes, normalise, renderRuleset, RULESET_HOSTS } from './ren
 import { findBlocks, findLegacy, isPristine, removeBlock, removeRange, replaceRange, upsertBlock, wrap } from './managed-text.js';
 import { backupFile, findBrokenLink, readBytes, readJsonStrict, unlinkIfUnchanged, writeTextAtomic } from './fs-safe.js';
 import { addToJsonList, countJsonKey, removeFromJsonList } from './json-edit.js';
+import { mcpServersOf, mergedOpencodeConfig, opencodeConfigDir, opencodeConfigFilePath, readOpencodeConfigDocuments } from '../opencode-config.js';
 import { createWriterLock, DEFAULT_LOCK_TIMEOUT_MS, LOCK_FILE_NAME } from './lock.js';
 
 export const RULESET_STATES = Object.freeze(['not-installed', 'installed', 'newer', 'outdated', 'modified', 'conflict', 'shadowed', 'error', 'manual']);
@@ -82,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;
 
@@ -190,7 +200,7 @@ export function createRulesetInstaller({
   // `hooks` are seams for tests, each a point where another program could act
   // (or where a test holds an operation still, inside the lock):
   // afterInspect(host, path, status) once a carrier was read and is about to be
-  // written, beforeCommit(path) right before a file (a carrier, config.json,
+  // written, beforeCommit(path) right before a file (a carrier, opencode.json,
   // the state file) is checked against what was read and replaced or deleted,
   // afterCheck(path) between that check and a delete, afterSave(revision) once
   // the state file was saved.
@@ -258,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;
@@ -351,15 +372,20 @@ export function createRulesetInstaller({
 
   // ── Where things live ──────────────────────────────────────────────────────
   // Resolved the way the MCP toggle routes resolve them: Claude, Codex and
-  // Gemini under the home directory, OpenCode under XDG_CONFIG_HOME when set.
+  // 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() {
     // The server passes the resolver its /api/opencode/mcp toggle uses, so both always edit the same file.
     const opencodeConfig = opencodeConfigPath
       ? resolve(opencodeConfigPath())
-      : join(env?.XDG_CONFIG_HOME ? join(env.XDG_CONFIG_HOME, 'opencode') : join(home, '.config', 'opencode'), 'config.json');
+      : opencodeConfigFilePath(opencodeConfigDir({ env: env || {}, home }));
     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,
@@ -413,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() {
@@ -425,9 +451,12 @@ 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 !!JSON.parse(readFileSync(where.opencodeConfig, 'utf8'))?.mcp?.SynaBun;
+      if (host === 'opencode') return !!mcpServersOf(mergedOpencodeConfig(readOpencodeConfigDocuments(where.opencodeDir))).SynaBun;
     } catch { /* no config, no registration */ }
     return false;
   }
@@ -478,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.` };
@@ -511,7 +540,7 @@ export function createRulesetInstaller({
   /**
    * The file an `instructions` entry of `configPath` names, or null when the entry is not one plain path: a URL, or
    * a pattern with glob characters. A leading `~` is the installer's home, and a relative path starts at the
-   * directory of config.json (never at this process's working directory).
+   * directory of opencode.json (never at this process's working directory).
    */
   function entryFile(value, configPath) {
     if (typeof value !== 'string' || !value) return null;
@@ -530,8 +559,7 @@ export function createRulesetInstaller({
     if (path === resolve(owned)) return true;
     try { return realpathSync(path) === realpathSync(owned); } catch { return false; }
   }
-  function readOpencodeConfig() {
-    const path = layout().opencodeConfig;
+  function readOpencodeConfig(path = layout().opencodeConfig) {
     const entry = opencodeEntry();
     const refuse = (why) => ({ path, exists: true, hasEntry: false, cfg: null, text: null, bytes: null, error: `${path} ${why}. SynaBun will not rewrite it: fix the file, or add "${entry}" to its "instructions" list by hand.` });
     let bytes;
@@ -558,7 +586,7 @@ export function createRulesetInstaller({
     return { path, exists: true, hasEntry: (cfg.instructions || []).some((value) => entryIsOwnedFile(value, path)), cfg, text, bytes, error: null };
   }
   /**
-   * The text of config.json after `edit()`, accepted only when it parses to
+   * The text of opencode.json after `edit()`, accepted only when it parses to
    * exactly `cfg`. There is no other way to write this file: when the edit
    * cannot be made on the text, SynaBun refuses rather than write the whole
    * object out again and lose what the user's file spells its own way.
@@ -570,7 +598,7 @@ export function createRulesetInstaller({
     } catch { /* text the editor could not follow */ }
     throw new Error(`${path} could not be edited safely, so SynaBun did not write it. Change its "instructions" list by hand: the entry is "${opencodeEntry()}".`);
   }
-  /** What install writes when there is no config.json yet: remove deletes the file only while it still holds exactly this. */
+  /** What install writes when there is no opencode.json yet: remove deletes the file only while it still holds exactly this. */
   function newConfigText(value) {
     return addToJsonList('{}\n', 'instructions', value);
   }
@@ -582,7 +610,7 @@ export function createRulesetInstaller({
   }
   /**
    * The `instructions` entries that resolve to SynaBun's owned file and that SynaBun has no record of adding: the
-   * user's own lines, however they are spelled (`~/...`, relative to config.json, a symlink to the file). One listing
+   * user's own lines, however they are spelled (`~/...`, relative to opencode.json, a symlink to the file). One listing
    * of the recorded string is SynaBun's; every other is theirs. A URL or a glob pattern is never one of them.
    */
   function userEntries(row, config) {
@@ -592,13 +620,13 @@ export function createRulesetInstaller({
     return list.filter((value, index) => index !== mine && entryIsOwnedFile(value, config.path));
   }
   /**
-   * One change to config.json. `plan(config)` answers null (nothing to do) or
+   * One change to opencode.json. `plan(config)` answers null (nothing to do) or
    * {text, done?}; `text: null` deletes the file. The file is replaced only
    * while it still holds the bytes that were read: a change by another program
-   * in between is CHANGED_UNDERNEATH, and config.json is left to it.
+   * in between is CHANGED_UNDERNEATH, and opencode.json is left to it.
    */
-  function editOpencodeConfig(tally, plan) {
-    const config = readOpencodeConfig();
+  function editOpencodeConfig(tally, plan, path = layout().opencodeConfig) {
+    const config = readOpencodeConfig(path);
     if (config.error) throw new Error(config.error);
     const step = plan(config);
     if (!step) return;
@@ -611,7 +639,7 @@ export function createRulesetInstaller({
     tally.changed = true;
     if (step.done) step.done();
   }
-  /** Lists synabun.md in config.json unless it is listed already, and records the string SynaBun added. */
+  /** Lists synabun.md in opencode.json unless it is listed already, and records the string SynaBun added. */
   function addOpencodeEntry(row, tally) {
     const value = opencodeEntry();
     let listed = null;
@@ -645,7 +673,7 @@ export function createRulesetInstaller({
       const mine = ownedEntry(row, config);
       const others = theirs ? userEntries(row, config) : [];
       if (mine === null && !others.length) return null;
-      // A config.json install created goes only while its bytes are still what install wrote. Anything the user
+      // An opencode.json install created goes only while its bytes are still what install wrote. Anything the user
       // added since makes it their file: the entries are edited out and the file stays.
       if (mine !== null && row.created.includes(config.path) && config.text === newConfigText(mine)) return { text: null };
       const dropKey = row.created.includes(`${config.path}#instructions`);
@@ -661,6 +689,60 @@ export function createRulesetInstaller({
     });
   }
 
+  // ── OpenCode 1's config.json ───────────────────────────────────────────────
+  // An older SynaBun listed synabun.md in config.json, which OpenCode 2 never reads. A copy SynaBun manages whose
+  // recorded entry is there is moved, at the next boot (reconcile) or install: listed in opencode.json, then the one
+  // string SynaBun added is taken out of config.json (the file goes when SynaBun made it and it still holds only that
+  // string). A remove takes that string out too. A line the user wrote in config.json is never touched. At a boot, a
+  // copy config.json no longer lists (the user took the line out, or the file) is an opt-out, as it was with
+  // OpenCode 1: never put back in opencode.json. An install, which the user asked for, lists it whatever config.json says.
+  function opencode1ConfigPath() {
+    return join(layout().opencodeDir, 'config.json');
+  }
+  /** The entry an older SynaBun recorded adding to config.json, or null. */
+  function opencode1Record(row) {
+    const owned = row.instructionsEntry;
+    return owned && typeof owned.value === 'string' && samePath(owned.config, opencode1ConfigPath()) ? { config: owned.config, value: owned.value } : null;
+  }
+  /**
+   * Whether config.json still lists the copy (`legacy`: opencode1Record), by any spelling: the line SynaBun added or
+   * one of the user's. A config.json SynaBun cannot read as plain JSON cannot say it does not, so it counts as listing.
+   */
+  function opencode1Listed(legacy) {
+    const config = readOpencodeConfig(legacy.config);
+    return !!config.error || config.hasEntry;
+  }
+  /** Takes the string of `legacy` (opencode1Record) out of config.json, and SynaBun's record of what it made there. */
+  function removeOpencode1Entry(row, tally, legacy) {
+    editOpencodeConfig(tally, (config) => {
+      if (!config.exists || !config.cfg) return null;
+      const list = [...(config.cfg.instructions || [])];
+      const at = list.lastIndexOf(legacy.value);
+      if (at < 0) return null;
+      if (row.created.includes(config.path) && config.text === newConfigText(legacy.value)) return { text: null };
+      const dropKey = row.created.includes(`${config.path}#instructions`);
+      list.splice(at, 1);
+      const cfg = { ...config.cfg, instructions: list };
+      if (!list.length && dropKey) delete cfg.instructions;
+      return { text: configText(config.path, cfg, () => removeFromJsonList(config.text, 'instructions', legacy.value, { dropEmptyKey: dropKey })) };
+    }, legacy.config);
+    row.created = row.created.filter((path) => !samePath(path, legacy.config) && path !== `${legacy.config}#instructions`);
+  }
+  /**
+   * A managed copy listed in config.json only: listed in opencode.json, and SynaBun's string taken out of
+   * config.json (a failure there leaves it with a warning: OpenCode 2 does not read that file). False when the row
+   * has no such record.
+   */
+  function moveOpencode1Entry(row, tally) {
+    const legacy = opencode1Record(row);
+    if (!legacy) return false;
+    addOpencodeEntry(row, tally);
+    try { removeOpencode1Entry(row, tally, legacy); } catch (error) {
+      tally.warnings.push(`${legacy.config} still lists ${legacy.value} under "instructions" (OpenCode 2 does not read that file): ${error?.message || error}`);
+    }
+    return true;
+  }
+
   // ── Writing ────────────────────────────────────────────────────────────────
   /**
    * The pasted copies in `text`, sorted by what install may do with them:
@@ -700,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
@@ -847,8 +968,7 @@ export function createRulesetInstaller({
     if (first.block) out.installedVersion = first.block.version;
     if (host === 'opencode') {
       const config = readOpencodeConfig();
-      const sideFiles = ['opencode.json', 'opencode.jsonc'].filter((name) => existsSync(join(primary.dir, name)));
-      if (sideFiles.length) out.notes = [`OpenCode also reads ${sideFiles.join(' and ')} in ${primary.dir}; SynaBun writes config.json, the same file its MCP toggle uses.`];
+      if (existsSync(join(primary.dir, 'opencode.jsonc'))) out.notes = [`OpenCode also reads opencode.jsonc in ${primary.dir}; SynaBun writes opencode.json, the same file its MCP toggle uses.`];
       if (config.error) return { ...out, state: 'error', error: config.error, detail: config.error };
       if (first.status !== 'missing' && !config.hasEntry) {
         unlisted = `${config.path} does not list it under "instructions", so OpenCode does not load it.`;
@@ -858,7 +978,7 @@ export function createRulesetInstaller({
           return { ...out, state: 'not-installed', installedVersion: null, detail: `${primary.path} exists, but ${unlisted}` };
         }
       }
-      // A line in config.json that SynaBun did not add points at the file: a remove keeps both unless it is forced.
+      // A line in opencode.json that SynaBun did not add points at the file: a remove keeps both unless it is forced.
       if (first.status !== 'missing' && userEntries(row, config).length) out.entry = 'user';
     }
     if (first.status === 'missing' && RANK[worst.status] < RANK.error) return { ...out, installedVersion: null };
@@ -896,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');
@@ -991,7 +1111,8 @@ export function createRulesetInstaller({
           stripLegacy(host, target.legacyFile, tally);
         }
       }
-      if (host === 'opencode') addOpencodeEntry(row, tally);
+      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,
@@ -1055,10 +1176,10 @@ export function createRulesetInstaller({
    * first; damaged markers, a block stamped for another tool, a symlinked owned
    * file and a file that cannot be read are refused either way.
    *
-   * OpenCode: a line in config.json that points at the owned file and that
+   * OpenCode: a line in opencode.json that points at the owned file and that
    * SynaBun did not add keeps the file too (`kept`, reason `listed-in-config`):
    * nothing is ever left pointing at a file SynaBun deleted. With `force` that
-   * line goes as well, after a backup of config.json, and then the file.
+   * line goes as well, after a backup of opencode.json, and then the file.
    *
    * Symlinks at a block carrier (AGENTS.md, GEMINI.md): the block is taken out
    * of the file the link points at and the link stays, exactly as install wrote
@@ -1076,7 +1197,7 @@ export function createRulesetInstaller({
    * True while a copy that keeps a removal open is still on disk: one SynaBun
    * should have taken and could not. That is damaged markers, a file that
    * cannot be read, an untouched copy of this host's rules (behind a symlink,
-   * or held back by another refusal), and for OpenCode a config.json that
+   * or held back by another refusal), and for OpenCode an opencode.json that
    * cannot be edited while SynaBun's entry is on record. A copy the user
    * edited, a file without markers and a block stamped for another tool are
    * not: the keep rule leaves the first two to the user, and the third was
@@ -1126,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) };
@@ -1169,6 +1290,11 @@ export function createRulesetInstaller({
         if (go && doomed.length) recordIntent(doomed.map((entry) => entry.path));
         if (go && together) {
           try { removeOpencodeEntry(row, tally, { theirs: force && doomed.length > 0 }); } catch (error) { refuse(layout().opencodeConfig, 'error', error?.message || String(error)); }
+          // The string an older SynaBun added to OpenCode 1's config.json goes too (OpenCode 2 never read it).
+          const legacy = opencode1Record(row);
+          if (legacy) {
+            try { removeOpencode1Entry(row, tally, legacy); } catch (error) { tally.warnings.push(`${legacy.config} still lists ${legacy.value} under "instructions": ${error?.message || error}`); }
+          }
         }
         if (!(together && refused.length)) {
           for (const { path, text } of go ? doomed : []) {
@@ -1196,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.` });
@@ -1253,7 +1379,7 @@ export function createRulesetInstaller({
       // (`created`, OpenCode's entry) stays on record, so a forced remove or a Replace can still clean up. The same
       // row for a refusal that leaves nothing to wait for (a block stamped for another tool, a copy that turned out
       // edited): the host is opted out, and no removal is kept open over a file that was never SynaBun's to take.
-      // `paths` are places a copy of the rules is: config.json, which a refusal can name, is not one of them.
+      // `paths` are places a copy of the rules is: opencode.json, which a refusal can name, is not one of them.
       const config = host === 'opencode' ? layout().opencodeConfig : null;
       Object.assign(row, {
         managed: false, installedVersion: null, installedSha: null, path: primary.path,
@@ -1349,7 +1475,24 @@ export function createRulesetInstaller({
         const config = host === 'opencode' ? readOpencodeConfig() : null;
         if (config?.error) { states[host] = 'error'; continue; }
         const first = isDir(primary.dir) ? inspect(host, primary, expected) : { status: 'missing' };
-        if (first.status === 'missing' || (config && !config.hasEntry)) {
+        // Listed by an older SynaBun in OpenCode 1's config.json only: moved to opencode.json, never an opt-out. A copy
+        // 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.)
           Object.assign(row, { managed: false, optedOutAt: stamp() });
@@ -1358,6 +1501,7 @@ export function createRulesetInstaller({
           continue;
         }
         const tally = call.tally(host);
+        if (moving) moveOpencode1Entry(row, tally);
         const known = new Set(row.paths.map((path) => realKey(path)));
         let primaryCurrent = first.status === 'current';
         for (const target of list) {

package/neural-interface/lib/rulesets/json-edit.js

@@ -2,7 +2,7 @@
 // SynaBun — one entry of a JSON list, edited as text (pure, no fs)
 // ═══════════════════════════════════════════
 //
-// OpenCode's config.json belongs to the user. Parsing it and writing it back
+// OpenCode's opencode.json belongs to the user. Parsing it and writing it back
 // would re-indent it, re-space it and drop whatever JSON.stringify spells
 // differently, all to add one string to one list. These two functions change
 // only the characters of that entry (and of the key, when SynaBun adds or takes

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
@@ -24,7 +24,8 @@ import {
 } from './db.js';
 import { parseLine } from './session-chunker.js';
 import { listCodexSessionsFromAccounts } from './codex-session-catalog.js';
-import { opencodeDbFlavor, sessionTablesFor, v2MessageText } from './opencode-db-schema.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;
@@ -381,18 +382,15 @@ export function rebuildCodexCache({ project, projects, accounts, onProgress } =
 
 // --- OpenCode ---
 
-// `protocol`: the OpenCode major SynaBun talks to (lib/opencode-db-schema.js
-// opencodeDbFlavor): OpenCode 2 keeps its sessions in session_v2 and their text
-// in session_message rows, in the same database file as OpenCode 1's tables.
-export function rebuildOpencodeCache({ getOpencodeDb, onProgress, protocol = null } = {}) {
+// OpenCode 2 keeps its sessions in session_v2 and their text in session_message rows
+// (lib/opencode-db-schema.js); a file without those tables has nothing to index.
+export function rebuildOpencodeCache({ getOpencodeDb, onProgress } = {}) {
   const emit = onProgress || (() => {});
   if (typeof getOpencodeDb !== 'function') return { sessions: 0, updated: 0 };
 
   const ocdb = getOpencodeDb();
-  if (!ocdb) return { sessions: 0, updated: 0 };
-  const flavor = opencodeDbFlavor(ocdb, protocol);
-  if (!flavor) return { sessions: 0, updated: 0 };
-  const tables = sessionTablesFor(flavor);
+  if (!ocdb || !hasOpencodeSessionTables(ocdb)) return { sessions: 0, updated: 0 };
+  const tables = OPENCODE_SESSION_TABLES;
 
   let sessions;
   try {
@@ -409,29 +407,19 @@ export function rebuildOpencodeCache({ getOpencodeDb, onProgress, protocol = nul
   let total = sessions.length;
   let updated = 0;
 
-  // OpenCode 1 schema: message.data (JSON w/ role+metadata) + part.data (JSON w/ type+text).
-  // Pull parts per message, decode JSON, grab text where type === 'text'.
-  // OpenCode 2: one session_message row per message, its text in `data`
-  // (v2MessageText); read as the same { part_id, part_created, pdata, mdata } rows.
+  // One session_message row per message, its text in `data` (v2MessageText); read as
+  // { part_id, part_created, pdata, mdata } rows.
   let partStmt;
   try {
-    partStmt = flavor === 'v2'
-      ? (() => {
-        const rows = ocdb.prepare(`SELECT id, type, time_created, data FROM session_message
-                                   WHERE session_id = ? AND type IN ('user', 'assistant')
-                                   ORDER BY seq ASC`);
-        return {
-          all: (sessionId) => rows.all(sessionId).map((row) => {
-            const said = v2MessageText(row.type, row.data);
-            return said ? { part_id: row.id, part_created: row.time_created, pdata: JSON.stringify({ type: 'text', text: said.text }), mdata: JSON.stringify({ role: said.role }) } : null;
-          }).filter(Boolean),
-        };
-      })()
-      : ocdb.prepare(`SELECT p.id AS part_id, p.time_created AS part_created, p.data AS pdata, m.data AS mdata
-                             FROM part p
-                             LEFT JOIN message m ON m.id = p.message_id
-                             WHERE p.session_id = ?
-                             ORDER BY p.time_created ASC`);
+    const rows = ocdb.prepare(`SELECT id, type, time_created, data FROM session_message
+                               WHERE session_id = ? AND type IN ('user', 'assistant')
+                               ORDER BY seq ASC`);
+    partStmt = {
+      all: (sessionId) => rows.all(sessionId).map((row) => {
+        const said = v2MessageText(row.type, row.data);
+        return said ? { part_id: row.id, part_created: row.time_created, pdata: JSON.stringify({ type: 'text', text: said.text }), mdata: JSON.stringify({ role: said.role }) } : null;
+      }).filter(Boolean),
+    };
   } catch { partStmt = null; }
 
   for (const row of sessions) {
@@ -506,6 +494,68 @@ export function rebuildOpencodeCache({ getOpencodeDb, onProgress, protocol = nul
   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 = {}) {