synabun 2.1.0 → 2.2.0

package/neural-interface/lib/assistant-runtime.js

@@ -16,6 +16,10 @@ import { dirname, resolve } from 'node:path';
 import { createClaudeBrain } from './assistant-brains/claude.js';
 import { createCodexBrain } from './assistant-brains/codex.js';
 import { createOpenCodeBrain } from './assistant-brains/opencode.js';
+import { createAntigravityBrain } from './assistant-brains/antigravity.js';
+import { acpPolicyInput, acpReadOnlyKind, acpToolName } from './antigravity/tool-call.js';
+import { antigravityUsageTokens } from './assistant-usage.js';
+import { UNPRICED_PROVIDER_REASON } from './assistant-budget-split.js';
 import { buildAssistantPersona, formatMailbox, reconcileRouteItems } from './assistant-persona.js';
 import { normalizeTestDensity, testDensityStamp } from './assistant-test-density.js';
 import { codexUsageCostUsd, floorCents } from './assistant-budget.js';
@@ -35,8 +39,9 @@ import { clampBrainModes, clampRouteMode, defaultRemotePolicyRegistry, effective
 import { browserToolDenial } from './browser-tool-policy.js';
 import { browserPolicyRoots } from './browser-policy-roots.js';
 import { stripFollowups } from '../public/shared/assistant/asst-followups.js';
+import { readJsonStrict } from './rulesets/fs-safe.js';
 
-export const BRAIN_PROVIDERS = new Set(['claude-code', 'codex', 'opencode']);
+export const BRAIN_PROVIDERS = new Set(['claude-code', 'codex', 'opencode', 'antigravity']);
 // Every tab is called SynaBun; the session title (the history list) comes from
 // the first prompt. Legacy "Assistant N" titles still count as unnamed.
 export const DEFAULT_SESSION_TITLE = 'SynaBun';
@@ -135,21 +140,33 @@ function readJson(path, fallback) { try { return JSON.parse(readFileSync(path, '
 function writeJsonAtomic(path, value) {
   mkdirSync(dirname(path), { recursive: true });
   const tmp = `${path}.${process.pid}.tmp`;
-  writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n', 'utf8');
-  renameSync(tmp, path);
+  try {
+    writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n', 'utf8');
+    renameSync(tmp, path);
+  } catch (error) {
+    try { rmSync(tmp, { force: true }); } catch { /* held too: the next write replaces it */ }
+    throw error;
+  }
 }
+// What Windows answers, now and then, to a rename over a file another process holds open for a
+// moment (an antivirus or indexer scanning it, a backup, the desktop app's pre-update snapshot).
+const HELD_FILE_CODES = new Set(['EPERM', 'EACCES', 'EBUSY']);
+// A write of the sessions index refused that way is tried again after these waits.
+const INDEX_RETRY_MS = [200, 500, 1000, 2000, 5000, 10_000];
 function clip(value, max = 200) { const text = String(value ?? '').replace(/\s+/g, ' ').trim(); return text.length > max ? `${text.slice(0, max - 1)}…` : text; }
 
 /**
  * A brain effort checked against its model (effort-levels.js). "off" (or a
  * model with no levels) stays "off" for Claude and Codex, which reset to the
- * model's default on it; OpenCode has no such variant, so it gets null.
+ * model's default on it; OpenCode has no such variant and Antigravity's thinking
+ * level no "off" (its session keeps the model's own level), so they get null.
  */
 export function checkBrainEffort(provider, model, effort, catalog) {
   if (!effort) return null;
+  if (provider === 'antigravity' && /^(?:off|default|auto|none)$/i.test(String(effort))) return null;
   if (!catalog) return String(effort);
   const next = normalizeEffort({ provider, model, effort, catalog }).effort;
-  return next || (provider === 'opencode' ? null : 'off');
+  return next || (provider === 'opencode' || provider === 'antigravity' ? null : 'off');
 }
 
 /** `catalog` (a catalog value) checks the effort against the brain's model (effort-levels.js). */
@@ -164,7 +181,8 @@ export function normalizeBrain(input = {}, defaults = {}, { catalog = null, cust
     model,
     effort: checkBrainEffort(provider, model, effort, catalog),
     agent: input?.agent ? String(input.agent) : null,
-    accountId: input?.accountId ? String(input.accountId) : (provider === 'opencode' ? null : 'default'),
+    // OpenCode and Antigravity sign in inside their own CLI: SynaBun keeps no account of theirs.
+    accountId: provider === 'antigravity' ? null : input?.accountId ? String(input.accountId) : (provider === 'opencode' ? null : 'default'),
     cwd: input?.cwd ? String(input.cwd) : (input?.project ? String(input.project) : (defaults.cwd || null)),
     tools: provider === 'opencode' ? (storedToolList(input, { customPresets }) ?? storedToolList(defaults, { customPresets }) ?? [...OPENCODE_BRAIN_TOOLS]) : ['all'],
     permissionMode: input?.permissionMode && !legacyPlan ? String(input.permissionMode) : 'default',
@@ -206,6 +224,10 @@ export function createAssistantRuntime({
   ensureIsolatedServe = null,
   stopIsolatedServe = null,
   setupOpencodeSidepanelConfig = null,
+  // Antigravity brains (assistant-brains/antigravity.js): the CLI's launch spec, the environment its process gets,
+  // the brain's home (lib/antigravity/home.js), SynaBun's own MCP entry there, and the policy registry and loopback
+  // address its hook asks (lib/antigravity/policy.js).
+  antigravity = null,
   broadcastSync = () => {},
   dataDir,
   memory = null,
@@ -322,12 +344,43 @@ export function createAssistantRuntime({
       || !!row.remote || !!row.channel || Number(row.costUsd) > 0;
     return holds ? 'unstarted' : 'empty';
   }
+  // Whether the index file may be written: it was read, or there was none. A file that could not be
+  // read (Windows: held by an antivirus or a backup) is never replaced by what this process holds;
+  // reading it is tried again (INDEX_RETRY_MS), and sessions made meanwhile join what it held.
+  let indexReady = false;
+  let indexReadTries = 0;
+  let indexBlockedLogged = false;
+  function readIndexRows() {
+    try {
+      const rows = readJsonStrict(indexPath);
+      if (Array.isArray(rows)) return rows;
+      const error = new Error(`${indexPath} does not hold a list`);
+      error.code = 'INVALID_JSON';
+      throw error;
+    } catch (error) {
+      if (error?.code === 'ENOENT') return [];
+      if (error?.code !== 'INVALID_JSON') throw error;
+      // A corrupt file is moved aside, never deleted, and the index starts again from what is live.
+      const aside = `${indexPath}.corrupt-${Date.now()}`;
+      renameSync(indexPath, aside);
+      log('assistant:index-corrupt', `${error.message}; moved to ${aside}`);
+      return [];
+    }
+  }
   function loadIndex() {
-    const rows = readJson(indexPath, []);
-    if (!Array.isArray(rows)) return;
+    let rows;
+    try { rows = readIndexRows(); } catch (error) {
+      log('assistant:index-unreadable', `${error?.code || ''} ${error?.message || String(error)}`.trim());
+      if (indexReadTries < INDEX_RETRY_MS.length) {
+        setTimeout(loadIndex, INDEX_RETRY_MS[indexReadTries++]).unref?.();
+      } else log('assistant:index-unreadable', `${indexPath} is left as it is; sessions of this run stay in memory only, until a restart reads it`);
+      return;
+    }
+    indexReady = true;
+    const late = sessions.size > 0; // sessions made while the file could not be read
     let dropped = 0;
     for (const row of rows) {
-      if (!row?.id) continue;
+      if (!row?.id || sessions.has(row.id)) continue;
       try { row.brain = normalizeSessionBrain(row.brain); }
       catch (error) { row.brain = { ...row.brain, tools: [], toolListError: { code: error.code, message: error.message, original: row.brain?.tools ?? row.brain?.mcpProfile } }; delete row.brain.mcpProfile; }
       if (settleLegacyRow(row) === 'empty') { dropped += 1; continue; }
@@ -339,16 +392,34 @@ export function createAssistantRuntime({
       }
     }
     // The index is written again without them (and with the started marks).
-    if (dropped) { log('assistant:index', `${dropped} session record(s) without a conversation dropped`); persist(); }
+    if (dropped) log('assistant:index', `${dropped} session record(s) without a conversation dropped`);
+    if (dropped || late) persist();
   }
   let persistTimer = null;
+  let persistRetries = 0; // index writes Windows refused in a row (INDEX_RETRY_MS)
   function persist({ force = false } = {}) {
     const write = () => {
+      if (!indexReady) {
+        if (!indexBlockedLogged) { indexBlockedLogged = true; log('assistant:index', 'not written: the sessions index has not been read'); }
+        return;
+      }
       // A draft is never written: it exists on disk only once its first prompt was sent (startChat).
       const rows = [...sessions.values()].filter((live) => !live.draft).map((live) => publicRecord(live.record, { withLive: false, persisted: true }))
         .sort((a, b) => String(b.updatedAt || '').localeCompare(String(a.updatedAt || '')))
         .slice(0, settings.retention);
-      try { writeJsonAtomic(indexPath, rows); } catch (error) { log('assistant:index-error', error?.message || String(error)); }
+      try {
+        writeJsonAtomic(indexPath, rows);
+        persistRetries = 0;
+      } catch (error) {
+        log('assistant:index-error', error?.message || String(error));
+        // The records changed (a rename already answered as saved, among them) and the file did not: on
+        // Windows it is written again shortly, with whatever the records hold by then, instead of waiting
+        // for the next change (a restart before it would bring the old records back).
+        if (process.platform === 'win32' && HELD_FILE_CODES.has(error?.code) && persistRetries < INDEX_RETRY_MS.length && !persistTimer) {
+          persistTimer = setTimeout(() => { persistTimer = null; write(); }, INDEX_RETRY_MS[persistRetries++]);
+          persistTimer.unref?.();
+        } else persistRetries = 0;
+      }
     };
     if (force) { if (persistTimer) { clearTimeout(persistTimer); persistTimer = null; } write(); return; }
     if (persistTimer) return;
@@ -1827,6 +1898,8 @@ export function createAssistantRuntime({
   function brainCostBasis(live) {
     const brain = live.record.brain || {};
     if (brain.provider === 'claude-code') return 'reported';
+    // Antigravity reports tokens, not prices: its spend has no dollar figure.
+    if (brain.provider === 'antigravity') return null;
     const info = brainCapabilities(live.record) || {};
     if (brain.provider === 'codex') {
       if (!pricing?.codexPrice) return null;
@@ -1868,6 +1941,10 @@ export function createAssistantRuntime({
     const money = sessionMoney(live.record.id);
     if (!money || money.unlimited) return null;
     // Fail closed: a brain whose spend has no price could spend past the budget.
+    // Antigravity has no price at all (whatever the pricing tables): a dollar budget cannot hold its turns.
+    if (live.record.brain?.provider === 'antigravity') {
+      return { code: 'BRAIN_UNPRICED', message: `${UNPRICED_PROVIDER_REASON}, so the session budget cannot hold an Antigravity brain's spend. Switch the budget to No limit in ⋯ → Budget…, or pick another provider for the brain.` };
+    }
     if (pricing && brainCostBasis(live) === null) {
       const model = live.record.brain?.model || brainCapabilities(live.record)?.id || 'its default model';
       return { code: 'BRAIN_UNPRICED', message: `No price is known for the ${live.record.brain?.provider || ''} brain model ${model}, so the session budget cannot hold its spend. Pick a priced or free model for the brain, or switch the budget to No limit.` };
@@ -2055,6 +2132,8 @@ export function createAssistantRuntime({
       remoteReadOnly: !!remote && remoteBrainLimited(brain.provider),
       // The engine keeps this conversation's thread record: pre-compact.mjs asks for no conversation memory.
       userContextThreads: brain.provider === 'claude-code' && userSuffix.nudges === true,
+      // Antigravity (assistant-brains/antigravity.js): where it runs, and what its policy hook asks of this session.
+      ...(brain.provider === 'antigravity' ? antigravityBrainDeps(live) : {}),
     };
     const gate = ensureGate(live);
     // A remote session's hook / plugin refuses a call it could not check (fail closed).
@@ -2064,7 +2143,7 @@ export function createAssistantRuntime({
         ? () => codexGateBootstrap({ url: gateUrl, session: live.record.id, token: live.gateToken, codexBin: typeof codexBin === 'function' ? codexBin() : codexBin, ...(remote ? { remote: true } : {}) })
         : async () => null;
     }
-    const factories = brainFactories || { 'claude-code': createClaudeBrain, codex: createCodexBrain, opencode: createOpenCodeBrain };
+    const factories = brainFactories || { 'claude-code': createClaudeBrain, codex: createCodexBrain, opencode: createOpenCodeBrain, antigravity: createAntigravityBrain };
     const factory = factories[brain.provider];
     if (!factory) throw new Error(`Unsupported brain provider ${brain.provider}`);
     const memoryHooks = brain.provider === 'claude-code' && memory?.claudeHooks ? memory.claudeHooks({
@@ -2715,6 +2794,7 @@ export function createAssistantRuntime({
     if (message.type === 'assistant:permission-request') {
       sendToSockets(live, { type: 'event', event: { type: 'synabun.dispatch_control_request', runId: message.runId, request_id: message.request?.requestId, provider: dispatcher?.get?.(message.runId)?.provider || null, request: message.request } });
     } else if (message.type === 'assistant:permission-resolved') {
+      live.mailbox = live.mailbox.filter((item) => !(item.run?.runId === message.runId && item.request?.requestId === message.requestId));
       sendToSockets(live, { type: 'event', event: { type: 'synabun.dispatch_control_resolved', runId: message.runId, request_id: message.requestId, resolvedBy: message.resolvedBy, behavior: message.behavior } });
     }
   }
@@ -3693,6 +3773,69 @@ export function createAssistantRuntime({
     const decision = decide(live, tool);
     return decision.allow ? { allow: true } : { allow: false, reason: decision.reason, refusals: decision.refusals, stopped: !!decision.abort };
   }
+  /**
+   * An Antigravity brain's tool call (its policy hook, lib/antigravity/policy.js), checked in this process the way
+   * gateCheck checks the OpenCode plugin's and the Codex hook's: plan mode, a remote session's read-only rules,
+   * the browser policy (every session, plan mode and subagents included), then the route gate. → { decision:
+   * 'deny', reason } or null (no objection: the brain's approval mode decides). `call`: lib/antigravity/tool-call.js
+   * acpCall. Antigravity's own bookkeeping steps (task boundaries, notes to the user) are never routed.
+   */
+  function antigravityGateCheck(live, call) {
+    const name = acpToolName(call);
+    const input = acpPolicyInput(call);
+    const planned = planGate(live, 'antigravity', name, input);
+    if (planned) return { decision: 'deny', reason: planned.reason };
+    // A remote (WhatsApp) session's Antigravity brain is read-only for good, at every level.
+    if (live.brainRemoteReadOnly && readOnlyToolDecision(name, input, { host: 'antigravity' }) === 'deny') {
+      log('assistant:remote-policy', `${live.record.id}: refused ${name} (read-only)`);
+      return { decision: 'deny', reason: `${readOnlyDenyMessage(name)} Tell the user to do this in SynaBun on their computer if they need it.` };
+    }
+    if (call.mcp) {
+      const remoteDenied = remoteGate(live, name, input, { argsComplete: true, host: 'antigravity' });
+      if (remoteDenied) return { decision: 'deny', reason: remoteDenied.reason };
+    }
+    const browserDenied = browserGate(live, name, input, { host: 'antigravity' });
+    if (browserDenied) return { decision: 'deny', reason: browserDenied.reason };
+    if (!live.gate || call.kind === 'think') return null;
+    const decision = decide(live, name);
+    return decision.allow ? null : { decision: 'deny', reason: decision.reason };
+  }
+  /** What an Antigravity brain needs from this session (assistant-brains/antigravity.js deps). */
+  function antigravityBrainDeps(live) {
+    const ag = antigravity || {};
+    const saved = live.record.usageState?.antigravity;
+    return {
+      antigravityLaunch: typeof ag.launch === 'function' ? ag.launch : () => null,
+      childEnv: typeof ag.childEnv === 'function' ? ag.childEnv : undefined,
+      antigravityHome: typeof ag.home === 'function' ? (sessionId) => ag.home(sessionId) : null,
+      synabunMcpEntry: typeof ag.synabunMcpEntry === 'function' ? ag.synabunMcpEntry : null,
+      policy: ag.policy || null,
+      policyUrl: typeof ag.policyUrl === 'function' ? ag.policyUrl() : (ag.policyUrl || null),
+      connect: ag.connect || undefined,
+      userGemini: ag.userGemini || undefined,
+      policyCheck: (call) => antigravityGateCheck(live, call),
+      // ACP counts tokens per session: what the session the record names had counted (a resume books only what follows).
+      sessionUsageBase: saved && saved.sessionId && saved.sessionId === live.record.providerSessionId ? saved.usage || null : null,
+      onAntigravitySession: (sessionId) => { if (sessionId && live.record.providerSessionId !== sessionId) { live.record.providerSessionId = sessionId; touch(live); } },
+      onAntigravitySessionUsage: (sessionId, total) => { live.record.usageState ||= {}; live.record.usageState.antigravity = { sessionId, usage: total }; },
+      onAntigravityUsage: (info) => settleAntigravityBrain(live, info),
+    };
+  }
+  /** One Antigravity brain turn's tokens into the ledger: unpriced (tokens, not prices), exact when its total agrees. */
+  function settleAntigravityBrain(live, { usage: turnUsage = null, model = null } = {}) {
+    if (!usage || !turnUsage) return;
+    metered('antigravity-settle', () => {
+      const { tokens, mismatch } = antigravityUsageTokens(turnUsage);
+      if (totalTokens(tokens) === 0) return;
+      const taskId = currentTask(live.record.id) || ensureTaskId(live.record.id);
+      usage.settle({
+        sessionId: live.record.id, taskId, scope: 'brain', runId: null, turn: live.record.turns, provider: 'antigravity',
+        model: model || live.record.brain?.model || null, part: 'main', tokens, costUsd: null, costBasis: 'unpriced',
+        fidelity: mismatch ? 'partial' : 'exact', reason: mismatch ? 'antigravity-total-mismatch' : null, source: 'antigravity-acp-usage',
+      });
+    });
+    persist({ force: true });
+  }
   /**
    * A remote session's hard refusal for one tool call (every level), else null.
    * `argsComplete: false`: the host did not pass the call's arguments. An
@@ -3913,6 +4056,9 @@ export function createAssistantRuntime({
   return {
     handleWebSocket, listSessions, getSession, createSession, updateSession, closeSession, destroySession, removeSession,
     resolveTerminal, accountInUse, ownsIsolatedServe, noteDispatch, subscribe, shutdown,
+    // The sessions index written now, synchronously: the server's exit handler runs it on every way out,
+    // since an exit through process.exit() never reaches shutdown()'s own write.
+    flushIndex: () => persist({ force: true }),
     observeBroadcast: onPermissionBroadcast,
     testDensityFor, routerSession, routerSend, routerEvent, routerMailbox, routerContinue, routerSinks, routerRouted, routerRouteFailed, routerComputerApproved, gateCheck, isPlanning, isPlanReadOnly,
     clarifySession, clarifyEvent, clarifyGate, clarifySinks,

package/neural-interface/lib/assistant-task-prompt.js

@@ -25,6 +25,7 @@ const PROVIDER_LABELS = {
   'claude-code': 'Claude Code',
   codex: 'Codex',
   opencode: 'OpenCode',
+  antigravity: 'Antigravity',
 };
 
 function providerLabel(provider) {
@@ -57,7 +58,7 @@ function topKeywords(task, title) {
 /** The provider's host name for browserPolicyText (its own web tools). */
 function policyHost(provider) {
   const value = String(provider || '').toLowerCase();
-  return value === 'claude-code' ? 'claude' : value === 'codex' || value === 'opencode' ? value : null;
+  return value === 'claude-code' ? 'claude' : value === 'codex' || value === 'opencode' || value === 'antigravity' ? value : null;
 }
 
 /**
@@ -197,12 +198,12 @@ export function styleGuideBlock(state = {}) {
 }
 
 function policyLine(policy) {
-  if (String(policy) === 'ask') {
-    return 'Permission requests are answered by the orchestrator or the user; keep them minimal and batch related actions. '
-      + 'If you need a decision, ask once and precisely with the question tool available to you.';
-  }
-  return 'This run is unattended: do not ask questions, do not enter plan mode, and do not wait for approval. '
-    + 'Make reasonable assumptions and state them in your result. If you truly cannot proceed, finish with status needs_input and one precise question.';
+  const permissions = String(policy) === 'ask'
+    ? 'Permission requests are answered by the orchestrator or the user; keep them minimal and batch related actions. '
+    : 'Continue autonomously within your permissions. Make reasonable assumptions and state them in your result. ';
+  return permissions + 'Ask only when genuinely blocked on a decision only the user can make. Use your question tool, never prose or a final needs_input result to ask: the user answers in this run’s live sidepanel and this SAME turn continues. '
+    + 'Claude Code: load the deferred AskUserQuestion schema with ToolSearch (select:AskUserQuestion) before calling it. Codex: use SynaBun choice in Default mode (request_user_input only in Plan mode). OpenCode: use the native question tool. Antigravity: use SynaBun choice through ACP form elicitation. '
+    + 'Do not enter plan mode just to ask. While a question is pending, wait for its tool result; do not end the turn or re-dispatch. If no question tool works, report blocked with the missing capability.';
 }
 
 /**
@@ -223,7 +224,7 @@ function capabilityLine(capability, state = {}) {
     case 'read-only':
       return 'CAPABILITY: read-only. You may read, search and analyze anywhere; you must not modify files, run state-changing shell commands, or publish anything. The shell runs read-only commands only (rg, grep, ls, cat, head, tail, find, stat, diff, jq, git log / diff / status / show / blame, node --check, npm ls, curl without an output file); programs, test runners and writes to files are not available.' + enforced;
     case 'workspace':
-      return `CAPABILITY: workspace. You may edit files inside the working directory${scratch ? `, the OS temp folder and your scratch folder (${scratch})` : ' and the OS temp folder'} and run the commands the task needs; nothing is written anywhere else (not under the home folder, another project or a tool's configuration such as ~/.claude, ~/.codex, ~/.agents, ~/.config/opencode or ~/.synabun). Shell commands that write elsewhere (redirections, cp, mv, rm, ln, tee, sed -i, git -C another folder, a global install) are refused.` + enforced;
+      return `CAPABILITY: workspace. You may edit files inside the working directory${scratch ? `, the OS temp folder and your scratch folder (${scratch})` : ' and the OS temp folder'} and run the commands the task needs; nothing is written anywhere else (not under the home folder, another project or a tool's configuration such as ~/.claude, ~/.codex, ~/.agents, ~/.config/opencode, ~/.gemini or ~/.synabun). Shell commands that write elsewhere (redirections, cp, mv, rm, ln, tee, sed -i, git -C another folder, a global install) are refused.` + enforced;
     default:
       return 'CAPABILITY: full access as configured by the user.';
   }
@@ -418,6 +419,7 @@ export function buildResumePrompt(state = {}, { at = '', selfRestarts = false }
   const lines = [
     `SERVER RESTART (same run ${runId}, project "${project}"): SynaBun's server restarted${clean(at) ? ` at ${clean(at)}` : ''} while you were working on this task, and this conversation was resumed in a new process.`,
     '- A tool call that was running then was cut off: its result is lost, and a command it started may or may not have finished.',
+    '- A question pending before the restart was cancelled with its live tool call, not answered. If it is still needed, ask again with the question tool; never infer an answer from the cancellation.',
     '- Check the actual state before you go on instead of assuming it: git status and git log, the files you were changing, test or build output, processes you started.',
     '- Do not repeat a side effect that already happened (a commit, a push, a message or post sent, a memory stored, a deploy): check first.',
   ];

package/neural-interface/lib/assistant-tools.js

@@ -35,7 +35,7 @@ export function launchTools(selection) {
 export function toolsView(entry) {
   const selected = dispatchTools({ tools: entry.toolsRequested ?? undefined, provider: entry.provider, usesBrowser: entry.usesBrowser, taskClass: entry.taskClass });
   const current = requireToolList(resolveToolList(entry.tools ?? launchTools(selected), { source: 'runtime', provider: entry.provider }));
-  const label = entry.provider === 'claude-code' ? 'Claude Code' : entry.provider === 'codex' ? 'Codex' : entry.provider || 'This worker';
+  const label = entry.provider === 'claude-code' ? 'Claude Code' : entry.provider === 'codex' ? 'Codex' : entry.provider === 'opencode' ? 'OpenCode' : entry.provider === 'antigravity' ? 'Antigravity' : entry.provider || 'This worker';
   return { requested: entry.toolsRequested ?? null, groups: current.groups, added: selected.added, effect: current.effect, count: current.count, servers: entry.externalServers?.names || [], disabledServers: entry.externalServers?.disabled || [],
     note: current.effect === 'focus' ? `${label} reaches every SynaBun tool on demand; this list is its focus.` : 'Loads exactly these SynaBun groups, plus always-on tools and role/grant tools.' };
 }
@@ -47,5 +47,5 @@ export function dispatchInput(body) {
 }
 
 export function workerToolsLine(catalog = toolCatalogView()) {
-  return `SynaBun tools for workers: pass tools: [group ids] on agent_dispatch. Always there: ${catalog.alwaysOnTools.join(', ')}. With no tools a worker gets ${catalog.default.join(', ')}. Groups: ${catalog.groups.map(group => `${group.id} (${group.count})`).join(' · ')}. Host effect: ${Object.entries(catalog.effect).map(([host, effect]) => `${host}: ${effect}`).join(', ')}. Strict hosts load exactly those groups; Claude Code and Codex always reach every SynaBun tool on demand and the list only sets their focus. Never assume a Claude Code or Codex worker lacks a group you left out. Your MCP servers: name them as mcp:<name> in tools (or mcp:* for all allowed servers). Every unnamed external server is off for that worker on every supported provider. Available server refs: ${(catalog.servers || []).filter(row => row.selectable !== false).map(row => row.ref).join(', ') || 'none listed'}.`;
+  return `SynaBun tools for workers: pass tools: [group ids] on agent_dispatch. Always there: ${catalog.alwaysOnTools.join(', ')}. With no tools a worker gets ${catalog.default.join(', ')}. Groups: ${catalog.groups.map(group => `${group.id} (${group.count})`).join(' · ')}. Host effect: ${Object.entries(catalog.effect).map(([host, effect]) => `${host}: ${effect}`).join(', ')}. Strict hosts load exactly those groups; Claude Code and Codex always reach every SynaBun tool on demand and the list only sets their focus. Never assume a Claude Code or Codex worker lacks a group you left out. Your MCP servers: name them as mcp:<name> in tools (or mcp:* for all allowed servers). Every unnamed external server is off for that worker on Claude Code, Codex, OpenCode and Antigravity. Available server refs: ${(catalog.servers || []).filter(row => row.selectable !== false).map(row => row.ref).join(', ') || 'none listed'}.`;
 }

package/neural-interface/lib/assistant-usage.js

@@ -20,6 +20,7 @@
 //      claudeModelUsageTokens(entry)   one SDK ModelUsage entry
 //      codexUsageTokens(usage)         → { tokens, mismatch } (Codex input includes cached, output includes reasoning)
 //      openCodeTokens(tokens)          already five classes
+//      antigravityUsageTokens(usage)   → { tokens, mismatch } (an ACP usage block; which classes nest is read off its total)
 //
 // 2. METERS  one per provider session. Each keeps a small JSON-safe state()
 //    the caller persists and hands back as { state }.
@@ -203,6 +204,34 @@ export function codexUsageTokens(usage) {
   return { tokens, mismatch: raw.total_tokens !== null && raw.total_tokens !== totalTokens(tokens) };
 }
 
+/**
+ * Antigravity usage: the ACP `usage` block of a prompt answer ({ inputTokens, outputTokens, thoughtTokens,
+ * cachedReadTokens, cachedWriteTokens, totalTokens }, camelCase or snake_case). ACP defines totalTokens as the sum
+ * of every type, so the classes are taken as disjoint; when the agent's own total says the cached tokens sit inside
+ * the input, or the thought tokens inside the output (the Gemini API's own convention), they are taken out. Which
+ * reading applied is the one whose sum is the total; `mismatch` when none is.
+ * @returns {{ tokens: object, mismatch: boolean }}
+ */
+export function antigravityUsageTokens(usage) {
+  const u = usage && typeof usage === 'object' ? usage : {};
+  const input = count(u.inputTokens ?? u.input_tokens);
+  const output = count(u.outputTokens ?? u.output_tokens);
+  const thought = count(u.thoughtTokens ?? u.thought_tokens ?? u.thinking_tokens ?? u.reasoningTokens);
+  const cacheRead = count(u.cachedReadTokens ?? u.cached_read_tokens ?? u.cache_read_tokens);
+  const cacheWrite = count(u.cachedWriteTokens ?? u.cached_write_tokens ?? u.cache_write_tokens);
+  const rawTotal = u.totalTokens ?? u.total_tokens;
+  const total = rawTotal === undefined || rawTotal === null || rawTotal === '' || !Number.isFinite(Number(rawTotal)) ? null : count(rawTotal);
+  const disjoint = { input, cacheWrite, cacheRead, output, reasoning: thought };
+  if (total === null) return { tokens: disjoint, mismatch: false };
+  const cachedInside = { ...disjoint, input: Math.max(0, input - cacheRead - cacheWrite) };
+  const thoughtInside = { ...disjoint, output: Math.max(0, output - thought) };
+  const bothInside = { ...cachedInside, output: thoughtInside.output };
+  for (const reading of [disjoint, cachedInside, thoughtInside, bothInside]) {
+    if (totalTokens(reading) === total) return { tokens: reading, mismatch: false };
+  }
+  return { tokens: disjoint, mismatch: true };
+}
+
 /** OpenCode message tokens ({ input, output, reasoning, cache:{ read, write } }): already five additive classes. */
 export function openCodeTokens(tokens) {
   const t = tokens && typeof tokens === 'object' ? tokens : {};

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

@@ -38,6 +38,11 @@ export const DEFAULT_BACKUP_RETENTION = Object.freeze({
   dailyDays: 30,
   weeklyWeeks: 12,
   maxBytes: 10 * 1024 * 1024 * 1024,
+  // How many pre-update/pre-migration snapshots this generic sweep keeps in a shared folder; the
+  // dedicated pruner for the updater's own folder (lib/update-snapshot.js prunePreUpdateSnapshots)
+  // reads the same retention.preUpdateKeep through the settings mechanism (GET/PUT
+  // /api/system/auto-backup), with its own PRE_UPDATE_KEEP_ENV override.
+  preUpdateKeep: 1,
 });
 
 /** The DATA_HOME folders every backup copies (createVerifiedBackup); DATA_HOME/.env goes too, as a file. */
@@ -1322,7 +1327,7 @@ export function applyBackupRetention({
     keep.add(latestPreUpdate.path);
     protectedPaths.add(latestPreUpdate.path);
   }
-  for (const item of snapshots.filter(item => ['pre-update', 'pre-migration'].includes(item.kind)).slice(0, 5)) keep.add(item.path);
+  for (const item of snapshots.filter(item => ['pre-update', 'pre-migration'].includes(item.kind)).slice(0, Math.max(0, Number(policy.preUpdateKeep) || 0))) keep.add(item.path);
 
   const daily = new Set();
   const weekly = new Set();

package/neural-interface/lib/browser-guard-cdp.js

@@ -5,9 +5,10 @@ import { EventEmitter } from 'node:events';
 import WebSocket from 'ws';
 
 export class GuardCdpConnection extends EventEmitter {
-  constructor(socket) {
+  constructor(socket, { timeoutMs = 5000 } = {}) {
     super();
     this.socket = socket;
+    this.timeoutMs = timeoutMs;
     this.pending = new Map();
     this.sequence = 0;
     this.closed = false;
@@ -33,7 +34,7 @@ export class GuardCdpConnection extends EventEmitter {
     if (this.closed || this.closing) return Promise.reject(new Error('Network guard CDP transport closed'));
     const id = ++this.sequence;
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`Network guard: ${method} timed out`)); }, 5000);
+      const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`Network guard: ${method} timed out`)); }, this.timeoutMs);
       this.pending.set(id, { resolve, reject, timer, sessionId, method });
       const failed = error => {
         if (!error) return;
@@ -67,7 +68,7 @@ export class GuardCdpConnection extends EventEmitter {
   }
 }
 
-export async function connectGuardCdp(endpoint) {
+export async function connectGuardCdp(endpoint, { timeoutMs } = {}) {
   let address = endpoint;
   if (!/^wss?:\/\//.test(address)) {
     // The owned DevTools JSON API, not page retrieval. No cookies or profile
@@ -79,5 +80,5 @@ export async function connectGuardCdp(endpoint) {
   if (typeof address !== 'string' || !/^wss?:\/\//.test(address)) throw new Error('Network guard: no DevTools WebSocket endpoint');
   const socket = new WebSocket(address, { handshakeTimeout: 5000, maxPayload: 16 * 1024 * 1024 });
   await new Promise((resolve, reject) => { socket.once('open', resolve); socket.once('error', reject); });
-  return new GuardCdpConnection(socket);
+  return new GuardCdpConnection(socket, { timeoutMs });
 }