synabun 2.1.0 → 2.2.1

package/neural-interface/lib/skills/known-bridge-digests.json

@@ -83,7 +83,8 @@
           ],
           "skillMd": [
             "78ebb9f149ff",
-            "a28ce5188f4b"
+            "870138a74151",
+            "bb2df5d23b7d"
           ],
           "firstCommit": "ae9acec31b71",
           "firstDate": "2026-10-23"
@@ -96,7 +97,8 @@
           ],
           "skillMd": [
             "78ebb9f149ff",
-            "a28ce5188f4b"
+            "870138a74151",
+            "bb2df5d23b7d"
           ],
           "firstCommit": "ae9acec31b71",
           "firstDate": "2026-10-23"
@@ -147,6 +149,7 @@
             "g3"
           ],
           "skillMd": [
+            "68a8323dfd0d",
             "8d262753dd16",
             "a9ac8e43510e",
             "ea38ed171e73",
@@ -163,6 +166,7 @@
             "g3"
           ],
           "skillMd": [
+            "68a8323dfd0d",
             "8d262753dd16",
             "a9ac8e43510e",
             "ea38ed171e73",
@@ -182,7 +186,8 @@
             "1019fc5ef755",
             "2a5ae45388b6",
             "740fdb3985fd",
-            "b5380300a1f5"
+            "b5380300a1f5",
+            "f6a41a558efe"
           ],
           "firstCommit": "636f18afbe6b",
           "firstDate": "2026-07-21"
@@ -198,7 +203,8 @@
             "1019fc5ef755",
             "2a5ae45388b6",
             "740fdb3985fd",
-            "b5380300a1f5"
+            "b5380300a1f5",
+            "f6a41a558efe"
           ],
           "firstCommit": "636f18afbe6b",
           "firstDate": "2026-07-21"
@@ -246,6 +252,30 @@
           "firstCommit": "ae9acec31b71",
           "firstDate": "2026-10-23"
         },
+        {
+          "digest": "b052a36caf1bbbebe994c5b8c029696306c64824837ae632968a94f0d97a8888",
+          "sep": "any",
+          "generators": [
+            "g3"
+          ],
+          "skillMd": [
+            "870138a74151"
+          ],
+          "firstCommit": "0a8f77317114",
+          "firstDate": "2026-10-25"
+        },
+        {
+          "digest": "7da57892ab385c2668a1afdb2da670ddcc732927103812c46a635eb476d34781",
+          "sep": "any",
+          "generators": [
+            "g3"
+          ],
+          "skillMd": [
+            "bb2df5d23b7d"
+          ],
+          "firstCommit": "52d9d1712c34",
+          "firstDate": "2026-10-31"
+        },
         {
           "digest": "4b619a432fc38e95310399f2d59a0f1501a3984b67007febd8ff92634afffa8f",
           "sep": "any",
@@ -380,6 +410,30 @@
           ],
           "firstCommit": "6776e42b885c",
           "firstDate": "2026-10-23"
+        },
+        {
+          "digest": "6765902e8854b8d4a859e96aa9233ba61cc0fe6c33d197b9815c01668a92612c",
+          "sep": "any",
+          "generators": [
+            "g3"
+          ],
+          "skillMd": [
+            "68a8323dfd0d"
+          ],
+          "firstCommit": "2be15e00f29b",
+          "firstDate": "2026-11-02"
+        },
+        {
+          "digest": "9f95ee55bf80bd711b191e1e94c74bd2808bcf82291b02bb20f52cab91f14c3b",
+          "sep": "any",
+          "generators": [
+            "g3"
+          ],
+          "skillMd": [
+            "f6a41a558efe"
+          ],
+          "firstCommit": "20ad54882a26",
+          "firstDate": "2026-11-03"
         }
       ]
     }

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

@@ -272,7 +272,7 @@ export function createSkillInstaller({ dataDir, now = () => new Date().toISOStri
   /**
    * Install `payload` at `destination` (a plain name in `root`).
    * @param {object} o
-   * @param {'claude'|'codex'|'opencode'} o.target @param {string} o.name @param {string} o.root @param {string} o.destination
+   * @param {'claude'|'codex'|'opencode'|'antigravity'|'agents'} o.target @param {string} o.name @param {string} o.root @param {string} o.destination
    * @param {object} o.payload from payloadFromFolder / payloadFromText
    * @param {object} [o.source] where the payload came from ({ kind: 'bundled', name, digest })
    * @param {{ expectedDestinationDigest?: string }} [o.decision] the person confirmed replacing what is there now

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

@@ -23,6 +23,8 @@
 //                 <config>/opencode skill folders stay listed as read by no runtime.
 //                 OpenCode also reads ~/.claude/skills and both .agents roots (not in SynaBun's own OpenCode panel,
 //                 which turns the Claude ones off).
+//   Antigravity   ~/.gemini/config/skills (Google Antigravity's `agy`; where SynaBun installs) and a project's
+//                 .agents/skills (the Codex project folder, which Antigravity reads too). Not fixture-tested.
 //   Shared        ~/.agents/skills: Codex and OpenCode (and other agents) read it. SynaBun writes there only when
 //                 the owner turned that on (`sharedAgentsRoot`).
 //   SynaBun       PACKAGE_ROOT/skills, the bundled skills: read-only.
@@ -34,7 +36,7 @@ import { lstatSync, readdirSync, realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 
-export const RUNTIMES = Object.freeze(['claude', 'codex', 'opencode']);
+export const RUNTIMES = Object.freeze(['claude', 'codex', 'opencode', 'antigravity']);
 
 const realFs = { lstat: lstatSync, realpath: realpathSync, readdir: readdirSync };
 
@@ -186,6 +188,11 @@ export function createRootResolver({
     add({ family: 'opencode', kind: 'commands', scope: 'user', sourceKind: 'legacy-bridge', path: join(home, '.opencode', 'command'), runtimes: ['opencode'],
       policy: { write: 'migration', reason: 'An old place SynaBun wrote bridges to.' }, discovery: { contract: '~/.opencode/command/<name>.md', verified: 'unverified' } });
 
+    // Antigravity (Google's `agy`): its own skills folder under ~/.gemini/config. It needs no refresh: it reads the folder again by itself.
+    add({ family: 'antigravity', kind: 'skills', scope: 'user', sourceKind: 'native', path: join(home, '.gemini', 'config', 'skills'), runtimes: ['antigravity'],
+      policy: owner('Antigravity\'s own skills folder.'), discovery: { contract: '~/.gemini/config/skills/<name>/SKILL.md', verified: 'docs' },
+      installTarget: { runtime: 'antigravity', scope: 'user' } });
+
     // Shared.
     add({ family: 'shared', kind: 'skills', scope: 'shared', sourceKind: 'shared', path: join(home, '.agents', 'skills'), runtimes: ['codex', 'opencode'],
       policy: sharedOn ? owner('Shared by Codex, OpenCode and other agents; turned on by the owner.') : { write: 'owner-opt-in', reason: 'Shared by Codex, OpenCode and other agents: SynaBun writes here only when you turn it on.' },
@@ -206,8 +213,8 @@ export function createRootResolver({
         policy: owner('The project\'s commands.'), discovery: { contract: '.claude/commands/<ns>/<name>.md → /ns:name', verified: 'docs' } });
       add({ family: 'claude', kind: 'agents', scope: 'project', sourceKind: 'native', path: at('.claude', 'agents'), runtimes: ['claude'], ...p,
         policy: owner('The project\'s agents.'), discovery: { contract: '.claude/agents/<name>.md', verified: 'docs' } });
-      add({ family: 'codex', kind: 'skills', scope: 'project', sourceKind: 'native', path: at('.agents', 'skills'), runtimes: ['codex', 'opencode'], ...p,
-        policy: owner('The project\'s shared skills (Codex\'s repository folder; OpenCode reads it too).'), discovery: { contract: '.agents/skills/<name>/SKILL.md', verified: 'fixture codex-cli 0.163.0, opencode 2.0.32' },
+      add({ family: 'codex', kind: 'skills', scope: 'project', sourceKind: 'native', path: at('.agents', 'skills'), runtimes: ['codex', 'opencode', 'antigravity'], ...p,
+        policy: owner('The project\'s shared skills (Codex\'s repository folder; OpenCode and Antigravity read it too).'), discovery: { contract: '.agents/skills/<name>/SKILL.md', verified: 'fixture codex-cli 0.163.0, opencode 2.0.32; Antigravity: docs' },
         installTarget: { runtime: 'codex', scope: 'project' } });
       add({ family: 'codex', kind: 'skills', scope: 'project', sourceKind: 'compat', path: at('.codex', 'skills'), runtimes: ['codex'], ...p,
         policy: never('Read by Codex 0.163.0 but not in its guide: new skills go to .agents/skills.'), discovery: { contract: '.codex/skills/<name>/SKILL.md', verified: 'fixture codex-cli 0.163.0' } });

package/neural-interface/lib/skills/runtime-checks.js

@@ -6,11 +6,11 @@
 //                "off", a deny rule on Skill(name)), OpenCode's opencode.json and opencode.jsonc (the last rule of
 //                action `skill` whose resource matches the name: OpenCode 2's `permissions`, an OpenCode 1
 //                `permission.skill` read as OpenCode reads it). 'enabled', 'disabled', or 'unknown' when the
-//                settings cannot be read.
+//                settings cannot be read (Antigravity's are not read: always 'unknown', with no reason).
 //   probe        asked of the runtime itself, only when the owner asks (Verify in the Studio): Codex lists its
 //                skills through `codex app-server` (skills/list, forceReload); OpenCode through SynaBun's own
-//                running serve. Claude Code has no listing to ask: it says null with the reason. A probe reads; it
-//                changes no setting.
+//                running serve. Claude Code and Antigravity have no listing to ask: they say null with the reason.
+//                A probe reads; it changes no setting.
 //   enable       the one write here, on the owner's click only (POST /api/skills-studio/v2/eligibility/enable):
 //                the setting that turns the skill off is changed to let it through, the file is backed up first
 //                (DATA_HOME/data/skills/backups/settings/), and the answer names the file, the backup and the lines
@@ -160,6 +160,8 @@ export function createSkillsRuntimeChecks({ codexHome, claudeHome, opencodeConfi
       if (decided?.effect !== 'deny') return { state: 'enabled', reason: null };
       return { state: 'disabled', reason: { kind: 'opencode-permission', file: decided.file, pattern: decided.resource, action: 'deny' } };
     }
+    // Antigravity: SynaBun reads none of its settings, so nothing is said of them (no reason: no "could not be read").
+    if (runtime === 'antigravity') return { state: 'unknown', reason: null };
     return { state: 'unknown', reason: { kind: 'unknown-runtime' } };
   }
 
@@ -273,6 +275,7 @@ export function createSkillsRuntimeChecks({ codexHome, claudeHome, opencodeConfi
       } catch (err) { return { discovered: null, code: 'no-answer', method: 'opencode serve', reason: err?.message || String(err) }; }
     }
     if (runtime === 'claude') return { discovered: null, code: 'no-list', method: 'none', reason: 'Claude Code has no list to ask; its folder rules were checked instead.' };
+    if (runtime === 'antigravity') return { discovered: null, code: 'no-list', method: 'none', reason: 'Antigravity has no list SynaBun can ask; its folder rules were checked instead.' };
     return { discovered: null, method: 'none', reason: 'Unknown runtime.' };
   }
 

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

@@ -50,7 +50,7 @@ export const SERVICE_CAPABILITIES = Object.freeze([
   'evals', 'usage', 'health', 'discover', 'packages', 'external-scanner-status',
 ]);
 
-export const ASSISTANT_RUNTIMES = Object.freeze(['claude', 'codex', 'opencode']);
+export const ASSISTANT_RUNTIMES = Object.freeze(['claude', 'codex', 'opencode', 'antigravity']);
 
 export class ServiceError extends PathConfineError {
   constructor(status, message, code, extra = {}) {
@@ -68,7 +68,7 @@ export class ServiceError extends PathConfineError {
  * @param {string|null} [o.bundledDir] PACKAGE_ROOT/skills
  * @param {string} [o.appVersion]
  * @param {(event) => void} [o.broadcast]
- * @param {() => ({ claude?: boolean, codex?: boolean, opencode?: boolean }|null)} [o.installedRuntimes] which CLIs are
+ * @param {() => ({ claude?: boolean, codex?: boolean, opencode?: boolean, antigravity?: boolean }|null)} [o.installedRuntimes] which CLIs are
  *   installed on this computer (server.js: the CLI resolver); null when not known
  * @param {object} [o.runtimeChecks] lib/skills/runtime-checks.js (the owner's enable)
  */
@@ -116,11 +116,13 @@ export function createSkillsService({ dataDir, roots, catalog, library, deployer
     const used = usedRuntimes();
     const detected = ASSISTANT_RUNTIMES.filter((r) => (installed ? installed[r] !== false : true) && used[r]);
     const fallback = detected.length ? detected : ['claude'];
-    return { chosen: config.assistants, detected: fallback, effective: config.assistants && config.assistants.length ? config.assistants : fallback, installed: installed ? ASSISTANT_RUNTIMES.filter((r) => installed[r] === true) : null };
+    // `installed` leaves out only a runtime the host says is missing (false): one it says nothing of (a host from before
+    // Antigravity) is never called "not installed".
+    return { chosen: config.assistants, detected: fallback, effective: config.assistants && config.assistants.length ? config.assistants : fallback, installed: installed ? ASSISTANT_RUNTIMES.filter((r) => installed[r] !== false) : null };
   }
   /** Which runtimes have a home on this computer (their skills folder or its parent exists), from the roots. */
   function usedRuntimes() {
-    const out = { claude: false, codex: false, opencode: false };
+    const out = { claude: false, codex: false, opencode: false, antigravity: false };
     let list = [];
     try { list = roots.listRoots(); } catch { list = []; }
     for (const r of list) {
@@ -181,7 +183,7 @@ export function createSkillsService({ dataDir, roots, catalog, library, deployer
     const binaryHead = head ? !isEditableText(head.bytes) : false;
     const base = lintText({ type: 'skill', text, folderName, binary: binaryHead }).lint;
     const sidecar = readSidecar(files);
-    const ids = Array.isArray(profiles) && profiles.length ? profiles.filter((p) => getProfile(p)) : ['portable-six-field', 'claude-code', 'codex-native', 'opencode-native'];
+    const ids = Array.isArray(profiles) && profiles.length ? profiles.filter((p) => getProfile(p)) : ['portable-six-field', 'claude-code', 'codex-native', 'opencode-native', 'antigravity-native'];
     const byProfile = {};
     for (const id of ids) {
       const lint = lintForProfile(id, { parsed, folderName, files: files.map((f) => ({ path: f.path, size: f.bytes.length })), sidecar });
@@ -281,6 +283,11 @@ export function createSkillsService({ dataDir, roots, catalog, library, deployer
     const entry = await catalog.find(artifactId);
     if (!entry) throw new ServiceError(404, 'There is no such entry in the catalog.', 'artifact_not_found');
     if (entry.kind !== 'skill') throw new ServiceError(400, 'Only a skill folder becomes a library skill.', 'not_a_skill');
+    // A folder SynaBun installed a library skill into is that skill already: adopting it again would make a second
+    // library skill of the same bytes (two Library rows, each flagged "same description" against the other).
+    const installed = deployer.activeAt(entry.path) || (entry.realPath && entry.realPath !== entry.path ? deployer.activeAt(entry.realPath) : null);
+    const owner = installed ? library.readSkill(installed.skillId) : null;
+    if (owner) return { skill: skillSummary(library.getSkill(owner.skillId)), revision: null, created: false, unchanged: true, installed: true, excluded: [] };
     const { files, dirs, excluded } = collectFolder(entry.realPath);
     const existing = library.findSkill((s) => s.origin?.kind === 'adopted' && s.origin?.artifactId === artifactId);
     const source = { kind: 'adopted', path: entry.path, rootId: entry.rootId, artifactId, name: entry.folderName };
@@ -475,7 +482,7 @@ export function createSkillsService({ dataDir, roots, catalog, library, deployer
    * backup, and the answer says what changed (lib/skills/runtime-checks.js enable).
    */
   function enableEligibility({ runtime, name, skillMd, accountId = 'default', projectPath = null, confirmDenyAll = false }) {
-    if (!['claude', 'codex', 'opencode'].includes(runtime)) throw new ServiceError(400, 'runtime is claude, codex or opencode.', 'invalid_target');
+    if (!['claude', 'codex', 'opencode', 'antigravity'].includes(runtime)) throw new ServiceError(400, 'runtime is claude, codex, opencode or antigravity.', 'invalid_target');
     if (typeof name !== 'string' || !isPlainName(name)) throw new ServiceError(400, 'name is a skill\'s folder name.', 'invalid_name');
     if (typeof skillMd !== 'string' || !skillMd || !/[\\/]SKILL\.md$/.test(skillMd)) throw new ServiceError(400, 'skillMd is the path of the skill\'s SKILL.md.', 'invalid_path');
     // Only a skill at a place SynaBun installs to (one of its install roots, or a folder a runtime reads): never an
@@ -492,7 +499,8 @@ export function createSkillsService({ dataDir, roots, catalog, library, deployer
   /** The legacy chips' view of one bundled skill: what each runtime has of it (native folder, old bridge, neither). */
   function legacyTargetStates(name) {
     const out = {};
-    for (const runtime of ['claude', 'codex', 'opencode']) {
+    // Antigravity installs to ~/.gemini/config/skills (lib/skills/roots.js), like the others to their own folders.
+    for (const runtime of ['claude', 'codex', 'opencode', 'antigravity']) {
       const root = roots.installRoot({ runtime, scope: 'user', accountId: 'default' });
       const native = root ? deployer.activeAt(join(root.path, name)) : null;
       let nativeState = 'absent';

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

@@ -9,6 +9,7 @@ export const USAGE_COVERAGE = Object.freeze({
   claude: { native: true, method: 'Skill tool request + successful tool result', limit: 'SynaBun dispatched runs only. Discovery is not invocation; task outcome is not skill quality.' },
   codex: { native: false, method: 'Successful exact cat of an installed SKILL.md', limit: 'No native invocation event. File reads are inferred loads, never invocation counts. Complex shell commands are not classified.' },
   opencode: { native: true, method: 'Completed skill tool part', limit: 'SynaBun dispatched runs only. Other terminals and historical transcripts are not mined.' },
+  antigravity: { native: false, method: 'Successful read of an installed SKILL.md', limit: 'No native invocation event: Antigravity reads a skill\'s SKILL.md itself. File reads are inferred loads, never invocation counts. SynaBun dispatched runs only.' },
 });
 const hash = (s) => createHash('sha256').update(s).digest('hex');
 // Native item IDs can restart on a follow-up turn; the dispatcher retains this turn across restarts.
@@ -65,6 +66,11 @@ export function createSkillTelemetry({ dataDir, deployer, settings, now = Date.n
         } else if (c.ok === true) add(run, i, 'invoked', 'native_skill_tool', c.id);
         else if (c.ok === false) add(run, i, 'failed', 'native_skill_tool', c.id);
       }
+      // Antigravity reads an installed skill's SKILL.md with its own file tool: a completed read of that exact file.
+      if (run.provider === 'antigravity' && (c.tool === 'read_file' || c.tool === 'view_file') && c.ok === true && typeof c.input.path === 'string') {
+        const matches = installs.filter((i) => resolve(c.input.path) === join(i.destination.path, 'SKILL.md'));
+        if (matches.length === 1) add(run, matches[0], 'loaded', 'successful_skill_file_read', c.id, 'inferred');
+      }
       if (run.provider === 'codex' && c.tool === 'shell' && c.phase === 'done' && c.ok === true) {
         // A conservative grammar: no pipes, substitutions, multiple commands, or merely mentioning a path.
         let command = c.input.command || '';

package/neural-interface/lib/synabun-version.js

@@ -121,7 +121,7 @@ export function semverNewer(a, b) {
 // versions of the same scheme compare by compareSemver.
 //
 // Only SynaBun's own versions go through these functions. The CLI tools
-// SynaBun watches (Claude Code, Codex, Gemini, OpenCode) keep plain
+// SynaBun watches (Claude Code, Codex, Antigravity, OpenCode) keep plain
 // compareSemver / semverNewer.
 
 /** True for a date-style SynaBun version (`2026.9.5`, `v.2026.07.34`, `2026.4.26-1`). */

package/neural-interface/lib/system-activity.js

@@ -14,7 +14,7 @@
 
 /** The kinds an answer may name, in the order the interface lists them. */
 export const ACTIVITY_KINDS = Object.freeze([
-  'assistant', 'claude-panel', 'codex-panel', 'opencode-panel', 'claude-cli', 'loop', 'schedule', 'backup', 'maintenance', 'unknown',
+  'assistant', 'claude-panel', 'codex-panel', 'opencode-panel', 'antigravity-panel', 'claude-cli', 'loop', 'schedule', 'backup', 'maintenance', 'unknown',
 ]);
 
 /** A Claude Code session that took a prompt this recently may still be working on it. */

package/neural-interface/lib/whatsapp/brain.js

@@ -12,9 +12,13 @@
 
 import { findModel, hiddenModelId } from '../assistant-catalog.js';
 import { modelEfforts } from '../effort-levels.js';
-import { providerLabel, remoteBrainLimited } from '../remote-policy.js';
+import { providerLabel as remoteProviderLabel, remoteBrainLimited } from '../remote-policy.js';
 
-export const BRAIN_PROVIDERS = Object.freeze(['claude-code', 'codex', 'opencode']);
+// Every provider the Assistant can run on: Antigravity too (lib/assistant-brains/antigravity.js). Like Codex and
+// OpenCode it holds a WhatsApp conversation read-only (lib/remote-policy.js remoteBrainLimited).
+export const BRAIN_PROVIDERS = Object.freeze(['claude-code', 'codex', 'opencode', 'antigravity']);
+// The provider's name in what the owner reads (remote-policy.js names the first three).
+const providerLabel = (provider) => (provider === 'antigravity' ? 'Antigravity' : remoteProviderLabel(provider));
 const EFFORT_RE = /^[A-Za-z0-9][\w.-]{0,39}$/;
 const MODEL_MAX = 200;
 
@@ -55,7 +59,7 @@ function refusal(message, { code = 'CONFIG_INVALID', status = 400 } = {}) {
  */
 export function checkBrainChoice(choice, catalog) {
   const clean = cleanBrainChoice(choice);
-  if (clean === undefined) return refusal('brain must be null (same as the Assistant) or { provider, model, effort } with a provider of claude-code, codex or opencode');
+  if (clean === undefined) return refusal('brain must be null (same as the Assistant) or { provider, model, effort } with a provider of claude-code, codex, opencode or antigravity');
   if (clean === null) return { ok: true, brain: null };
   if (!catalog || typeof catalog !== 'object') {
     return refusal('The model list is not available right now, so this model could not be checked. Try again in a few seconds.', { code: 'CATALOG_UNAVAILABLE', status: 503 });

package/neural-interface/lib/whatsapp/cards.js

@@ -49,7 +49,7 @@
 
 import { CONTROL_KINDS, buildControlResponse, describeToolInput, normalizeAnswers, normalizeControlRequest } from '../../public/shared/assistant/asst-control.js';
 import { buildRouteResponse, normalizeRouteRequest, routeOptions } from '../../public/shared/assistant/asst-route.js';
-import { isComputerTool, isDeniedRemoteTool } from '../remote-policy.js';
+import { isComputerTool, isDeniedRemoteTool, providerLabel } from '../remote-policy.js';
 
 // Codes a person can read out loud: no 0/O, 1/I/L, 2/Z, 5/S, 8/B.
 const TAG_ALPHABET = 'ACDEFGHJKMNPQRTUVWXY34679';
@@ -266,9 +266,10 @@ function choiceName(choice) {
   const strip = (value) => clean(value).replace(/^do it here with /i, '');
   return strip(choice.label) || strip(choice.title) || 'that model';
 }
-function routePhrase(choice, { it = 'it', other = false } = {}) {
-  if (choice.here) return `do ${it} here with ${choiceName(choice)}`;
-  return other ? `use ${choiceName(choice)}` : `hand ${it} to ${choiceName(choice)}`;
+/** A choice that runs in this conversation: "here" on its model, or on another model of its provider. */
+const runsHere = (choice) => !!choice?.here || choice?.kind === 'direct';
+function routePhrase(choice, { it = 'it' } = {}) {
+  return runsHere(choice) ? `do ${it} here with ${choiceName(choice)}` : `hand ${it} to ${choiceName(choice)}`;
 }
 
 /**
@@ -294,7 +295,9 @@ export function renderCard(card, { formatPlan = (text) => text } = {}) {
       lines.push(`I can't take that choice from the phone (${card.desktopOnly}): pick it in SynaBun on your computer, or say no and I'll drop it.`);
       return lines.join('\n');
     }
-    if (others.length) lines.push(`I could also ${joinOr(others.slice(0, 4).map((choice) => routePhrase(choice, { other: true })))}: just name it.${mac ? ' Then I ask about the Mac separately.' : ''}`);
+    // The other choices, the ones done here first, then the workers: "do it here with …, hand it to … or hand it to …".
+    const rest = [...others.filter(runsHere), ...others.filter((choice) => !runsHere(choice))].slice(0, 4);
+    if (rest.length) lines.push(`I could also ${joinOr(rest.map((choice) => routePhrase(choice)))}: just name it.${mac ? ' Then I ask about the Mac separately.' : ''}`);
     return `${lines.join('\n')}${tagHint(card)}`;
   }
   if (card.kind === CONTROL_KINDS.CLARIFY) {
@@ -328,7 +331,8 @@ export function renderCard(card, { formatPlan = (text) => text } = {}) {
     if (card.desktopOnly) return `I'd need to control your Mac for this, and I can't take a yes for that from the phone (${card.desktopOnly}): answer in SynaBun on your computer, or say no and I'll skip it.`;
     return `${COMPUTER_ASK_TEXT}${tagHint(card)}`;
   }
-  const worker = card.source === 'dispatch' ? `One of the agents${card.provider && card.provider !== 'claude-code' ? ` (${card.provider})` : ''}` : null;
+  // The worker's provider by its name ("Codex", "Antigravity"), not its id; Claude Code's is the default and goes unsaid.
+  const worker = card.source === 'dispatch' ? `One of the agents${card.provider && card.provider !== 'claude-code' ? ` (${providerLabel(card.provider)})` : ''}` : null;
   const lines = [worker ? `${worker} needs your OK to run this:` : 'I need your OK to run this:', ...toolLines(card)];
   if (n.message && n.message !== n.detail) lines.push(clip(n.message, 200));
   if (card.desktopOnly) lines.push(`I can't take a yes for this one from the phone (${card.desktopOnly}): approve it in SynaBun on your computer, or say no and I'll skip it.`);
@@ -426,12 +430,21 @@ function matchRouteChoice(card, text) {
   said = said.replace(PICK_LEAD, '').replace(/^the /, '');
   for (let i = 0; i < 3; i += 1) said = said.replace(/ (?:please|instead|then|thanks|model)$/, '');
   if (said.length < 2) return null;
+  // "Here" names the option on the Assistant's own model (else the first done here); "dispatch" / "a worker"
+  // names the first worker option, the one the card suggests for the worker side.
+  const firstHere = card.routeChoices.find((choice) => choice.here) || card.routeChoices.find(runsHere) || null;
+  const firstWorker = card.routeChoices.find((choice) => !runsHere(choice)) || null;
   const names = (choice) => {
     const list = [choice.label, choiceName(choice), choice.model, choice.title, String(choice.model || '').split('/').pop()].map(plain).filter(Boolean);
-    if (choice.here) list.push('here', 'do it here', 'do it yourself', 'yourself', 'you do it', `here with ${plain(choice.label)}`);
+    if (choice === firstHere) list.push('here', 'do it here', 'do it yourself', 'yourself', 'you do it', `here with ${plain(choice.label)}`);
+    if (choice === firstWorker) list.push('dispatch', 'dispatch it', 'a worker', 'worker', 'hand it off', 'delegate', 'delegate it');
     return [...new Set(list)];
   };
-  const hits = card.routeChoices.filter((choice) => names(choice).some((name) => name === said || (said.length >= 3 && name.startsWith(`${said} `))));
+  // A whole name first: "do it here" is the "here" option even when another option's label starts with it
+  // ("Do it here with Haiku 4.5"); only then the start of a name ("sonnet" for "Sonnet 5").
+  const exact = card.routeChoices.filter((choice) => names(choice).includes(said));
+  if (exact.length) return exact.length === 1 ? exact[0] : null;
+  const hits = card.routeChoices.filter((choice) => names(choice).some((name) => said.length >= 3 && name.startsWith(`${said} `)));
   return hits.length === 1 ? hits[0] : null;
 }
 
@@ -472,7 +485,7 @@ export function answerCard(card, reply, { quoted = false } = {}) {
     if (!tag.ok) return needTag();
     if (card.desktopOnly || !choice) return { action: 'desktop', message: 'I can\'t take that choice from the phone: pick it in SynaBun on your computer, or say no and I\'ll drop it.' };
     const onMac = routeControlsMac(card) && choice.id === card.routeChoices[0].id;
-    return respond(card, buildRouteResponse(card.route, { optionId: choice.id, remember: false }), onMac ? `doing it on your Mac, here with ${choiceName(choice)}. Esc on the Mac stops me` : choice.here ? `doing it here with ${choiceName(choice)}` : `handing it to ${choiceName(choice)}`);
+    return respond(card, buildRouteResponse(card.route, { optionId: choice.id, remember: false }), onMac ? `doing it on your Mac, here with ${choiceName(choice)}. Esc on the Mac stops me` : runsHere(choice) ? `doing it here with ${choiceName(choice)}` : `handing it to ${choiceName(choice)}`);
   }
   if (stop || parsed.type === 'no' || (numbers.length === 1 && numbers[0] === 2)) return deny(card, parsed.rest);
   const yes = parsed.type === 'yes' || (numbers.length === 1 && numbers[0] === 1 && !parsed.rest);

package/neural-interface/lib/whatsapp/config.js

@@ -164,7 +164,7 @@ const MESSAGES = {
   activityText: 'activityText must be true or false',
   strictWorkerApprovals: 'strictWorkerApprovals must be true or false',
   computerUse: 'computerUse must be true or false',
-  brain: 'brain must be null (same as the Assistant) or { provider, model, effort } with a provider of claude-code, codex or opencode',
+  brain: 'brain must be null (same as the Assistant) or { provider, model, effort } with a provider of claude-code, codex, opencode or antigravity',
   transcriptionEnabled: 'transcriptionEnabled must be true or false',
   transcriptionLanguage: "transcriptionLanguage must be 'auto' or a 2-3 letter lowercase language code, such as en or pt",
   transcriptionEnginePath: 'transcriptionEnginePath must be empty (find whisper-cli by itself) or the absolute path of the whisper-cli program',

package/neural-interface/lib/worker-confinement.js

@@ -39,6 +39,7 @@
 import { existsSync, lstatSync, realpathSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { dirname, isAbsolute, join, resolve, sep } from 'node:path';
+import { acpCall, acpToolPaths } from './antigravity/tool-call.js';
 
 export const WORKER_GUARD_MODES = Object.freeze(['enforce', 'warn', 'off']);
 export const WORKER_GUARD_DEFAULT = 'enforce';
@@ -46,7 +47,7 @@ export const WORKER_CONFINEMENT = 'worker';
 /** The capabilities the guard applies to (never 'full'). */
 export const GUARDED_CAPABILITIES = Object.freeze(['read-only', 'workspace']);
 /** Folders under the home a worker must never write into (documented; the rule itself is "outside the writable roots"). */
-export const PROTECTED_HOME_DIRS = Object.freeze(['.claude', '.codex', '.agents', '.config/opencode', '.synabun', '.local/share/opencode', '.ssh', '.gnupg', '.aws', '.config']);
+export const PROTECTED_HOME_DIRS = Object.freeze(['.claude', '.codex', '.agents', '.config/opencode', '.synabun', '.local/share/opencode', '.gemini', '.ssh', '.gnupg', '.aws', '.config']);
 
 export function normalizeWorkerGuardMode(value) {
   const text = String(value ?? '').trim().toLowerCase();
@@ -1163,6 +1164,81 @@ export function openCodePermissionDecision(request, confinement, { toolName = nu
   }
 }
 
+// The ACP tool kinds that change files (session/request_permission's toolCall.kind).
+const ACP_WRITE_KINDS = new Set(['edit', 'delete', 'move']);
+// Preserve the public import while using Antigravity's canonical path reader.
+export { acpToolPaths };
+
+/**
+ * An ACP permission request (session/request_permission: its toolCall { kind, title, locations, rawInput }) under
+ * a confinement, the way Antigravity's `agy acp` asks before an edit, a command or work outside the workspace:
+ * null when it may go ahead, else a refusal. `execute` is read through the shell heuristic, `edit` / `delete` /
+ * `move` by every path the call names (all of them must be writable; read-only refuses them all), `read` /
+ * `search` pass unless they reach one of SynaBun's protected home folders, `fetch` passes unless it calls one of
+ * SynaBun's own local ports, and anything else (an MCP tool) goes through workerToolDecision by its title.
+ */
+export function acpPermissionDecision(rawCall, confinement) {
+  if (!confinement) return null;
+  try {
+    // Either shape Antigravity sends (a permission request's toolCall, a hook payload's { name, args }), read as one
+    // (lib/antigravity/tool-call.js): its kind from its name when it has none, an MCP call as its server and tool.
+    const call = rawCall?.args && 'mcp' in rawCall ? rawCall : acpCall(rawCall);
+    const toolCall = { ...call, rawInput: call.args };
+    // An MCP call is the tool it calls (agy reports it as kind `execute` with no command line).
+    if (call.mcp) return workerToolDecision(`mcp__${call.mcp.server}__${call.mcp.tool}`, call.mcp.args, confinement);
+    const kind = String(call.kind || 'other').toLowerCase();
+    const input = call.args;
+    const label = String(call.title || call.name || kind).slice(0, 120);
+    if (kind === 'execute') {
+      const command = typeof input.command === 'string' ? input.command
+        : Array.isArray(input.command) ? input.command.join(' ')
+          : typeof input.CommandLine === 'string' ? input.CommandLine
+            : typeof input.cmd === 'string' ? input.cmd : '';
+      if (!command) return refusal('unknown-command', `${label} names no command SynaBun could read, so it is refused; this run writes inside ${rootsText(confinement)} only.`);
+      return workerShellDecision(command, confinement);
+    }
+    if (ACP_WRITE_KINDS.has(kind)) {
+      if (confinement.capability === 'read-only') return refusal('read-only', `This run has capability read-only: ${label} (${kind}) is not available. Report what you found instead of changing files.`);
+      const paths = acpToolPaths(toolCall);
+      if (!paths.length) return refusal('unknown-path', `${label} (${kind}) names no path SynaBun could read; this run writes inside ${rootsText(confinement)} only.`);
+      for (const raw of paths) {
+        const place = placeOf(raw, { cwd: confinement.cwd, home: confinement.home });
+        if (!place) return refusal('unknown-path', `${label} names a path SynaBun could not read ("${String(raw).slice(0, 200)}"); this run writes inside ${rootsText(confinement)} only.`);
+        if (!mayWrite(place, confinement)) return refusal('write-outside', `${label} (${kind}) to ${place} is outside this run's workspace: this run writes inside ${rootsText(confinement)} only.`, place);
+      }
+      return null;
+    }
+    if (kind === 'read' || kind === 'search') {
+      for (const raw of acpToolPaths(toolCall)) {
+        const place = placeOf(raw, { cwd: confinement.cwd, home: confinement.home });
+        if (place && isProtectedPlace(place, confinement)) {
+          return refusal('protected-path', `${label} reaches ${place}, one of SynaBun's protected home folders (its data home or a runtime's credential store): a worker does not read there, whatever its capability.`, place);
+        }
+      }
+      return null;
+    }
+    if (kind === 'fetch') {
+      const url = typeof input.url === 'string' ? input.url : typeof input.Url === 'string' ? input.Url : '';
+      if (url) {
+        let parsed = null;
+        try { parsed = new URL(url); } catch { /* not a URL: nothing to compare */ }
+        if (parsed && isLoopbackHost(parsed.hostname)) {
+          const port = Number(parsed.port || (parsed.protocol === 'https:' ? 443 : 80));
+          const kindOfPort = controlPortOf(port, confinement);
+          if (kindOfPort) return refusal('control-port', `${label}: ${controlPortText(kindOfPort, parsed.hostname, port, confinement)}; a worker does not call it.`);
+        }
+      }
+      return null;
+    }
+    if (kind === 'think' || kind === 'switch_mode') return null;
+    // MCP and other tools: by the name the call carries ("mcp__server__tool" when the agent says so).
+    const name = typeof input.toolName === 'string' ? input.toolName : typeof toolCall?.title === 'string' ? toolCall.title : '';
+    return name ? workerToolDecision(name, input, confinement) : null;
+  } catch (err) {
+    return refusal('check-failed', `The request could not be checked (${err?.message || err}), so it is refused.`);
+  }
+}
+
 /** What the run's transcript records for a decision: { type: 'synabun.confinement', action, tool, rule, reason, target? }. */
 export function confinementEvent(decision, { tool, confinement, provider = null } = {}) {
   return {

package/neural-interface/lib/worker-question.js

@@ -0,0 +1,74 @@
+// Provider wire answers for the dispatcher's single, first-wins pending request.
+import { codexControlRequestFromServerRequest, codexControlResponse } from './assistant-envelope.js';
+import { validateCodexServerResponse } from './codex-compat-rpc.js';
+
+export const CODEX_QUESTIONS = new Set(['item/tool/requestUserInput', 'tool/requestUserInput', 'mcpServer/elicitation/request']);
+
+export function workerQuestions(params = {}) {
+  if (Array.isArray(params.questions)) return params.questions;
+  if (String(params.message || '').startsWith('[SYNABUN_CHOICE_V1]')) {
+    try { return JSON.parse(params.message.slice('[SYNABUN_CHOICE_V1]'.length)).questions || []; } catch { /* generic form */ }
+  }
+  return [];
+}
+
+export function elicitationReply(params, reply = {}) {
+  const action = reply.action || reply.result?.action || (reply.behavior === 'allow' ? 'accept' : 'cancel');
+  if (reply.behavior !== 'allow' || action !== 'accept') return { action: action === 'decline' ? 'decline' : 'cancel' };
+  const supplied = reply.content ?? reply.result?.content ?? reply.answers ?? {};
+  if (!supplied || typeof supplied !== 'object' || Array.isArray(supplied)) throw new Error('Question answers must be an object');
+  const content = {};
+  for (const [key, value] of Object.entries(supplied)) {
+    const answers = value?.answers;
+    const property = params.requestedSchema?.properties?.[key];
+    content[key] = Array.isArray(answers) ? (property?.type === 'array' ? answers : answers.join(', ')) : value;
+    // An Assistant answer may give free text instead of choice's wire sentinel.
+    if (property?.type === 'array' && !Array.isArray(content[key])) content[key] = [String(content[key])];
+    if (property?.oneOf && !property.oneOf.some((o) => o.const === content[key]) && params.requestedSchema.properties[`${key}__other`]) {
+      content[`${key}__other`] = String(content[key]); content[key] = '__synabun_other__';
+    }
+  }
+  for (const key of params.requestedSchema?.required || []) {
+    if (content[key] == null || content[key] === '' || (Array.isArray(content[key]) && !content[key].length)) throw new Error(`Missing answer for ${key}`);
+  }
+  for (const [key, value] of Object.entries(content)) {
+    const schema = params.requestedSchema?.properties?.[key];
+    if (!schema) continue;
+    if (schema.type === 'array') {
+      if (!Array.isArray(value) || value.some((v) => typeof v !== 'string')) throw new Error(`Invalid choices for ${key}`);
+    } else if (schema.type && typeof value !== schema.type.replace('integer', 'number')) throw new Error(`Invalid answer for ${key}`);
+    if ((value === '__synabun_other__' || Array.isArray(value) && value.includes('__synabun_other__')) && !content[`${key}__other`]?.trim()) throw new Error(`Missing custom answer for ${key}`);
+  }
+  return { action: 'accept', content };
+}
+
+export function codexWorkerReply(packet, reply) {
+  if (packet.method === 'mcpServer/elicitation/request') return { result: elicitationReply(packet.params || {}, reply) };
+  if (reply.result?.answers && !reply.answers) reply = { ...reply, answers: reply.result.answers };
+  const result = codexControlResponse(codexControlRequestFromServerRequest({ ...packet, requestId: packet.id }), reply);
+  if (result.result) validateCodexServerResponse(packet.method, packet.params, result.result);
+  return result.error ? { error: result.error } : { result: result.result };
+}
+
+export function openCodeAnswers(questions, answers) {
+  const list = Array.isArray(answers) ? answers : questions.map((q, i) => answers?.[q.id || q.question] ?? answers?.[q.header] ?? answers?.[i]);
+  return questions.map((q, i) => {
+    const value = list[i]?.answers ?? list[i];
+    const result = (Array.isArray(value) ? value : value == null ? [] : [value]).map(String);
+    if (!result.length || !result.some((v) => v.trim())) throw new Error(`Missing answer for ${q.header || q.question || i}`);
+    return result;
+  });
+}
+
+/** Validate before consuming the resolver, so a malformed answer leaves a retryable card. */
+export function validateWorkerReply(pending, reply) {
+  if (reply.behavior !== 'allow' || pending.kind !== 'question') return;
+  const protocol = pending.protocol;
+  if (protocol?.method === 'elicitation/create') elicitationReply(pending.input || {}, reply);
+  else if (protocol?.provider === 'codex') codexWorkerReply({ id: protocol.id, method: protocol.method, params: pending.input || {} }, reply);
+  else if (protocol?.provider === 'opencode') openCodeAnswers(pending.questions || [], reply.answers);
+  else if (pending.toolName === 'AskUserQuestion') {
+    const answers = reply.answers ?? reply.updatedInput?.answers;
+    for (const q of pending.questions || []) if (!answers?.[q.question]) throw new Error(`Missing answer for ${q.question}`);
+  }
+}