synabun 2.0.10 → 2.2.0

package/neural-interface/lib/assistant-budget-split.js

@@ -3,7 +3,10 @@
 // ═══════════════════════════════════════════
 //
 // A session with a budget (assistant-budget.js) divides what is left across
-// three buckets, one per provider: claude-code, codex, opencode. A provider's
+// the buckets of the providers it can meter: claude-code, codex, opencode. A
+// provider that reports no price (antigravity: tokens only) has a bucket that
+// never takes a share: under a budget its runs are refused, under No limit
+// they run and only their spend (none) is shown. A provider's
 // runs draw from its share; the Assistant's own turns (brain turns, direct and
 // continuation routes) draw from the share of the brain's provider, which
 // keeps a reserve for them that the workers on that provider cannot spend.
@@ -22,8 +25,16 @@
 import { listedCount, priceText, providerAllHidden, providerEmpty, rowIsHidden, findModel, defaultModelRow } from './assistant-catalog.js';
 import { BUDGET_WARN_RATIO, floorCents, roundUsd } from './assistant-budget.js';
 
-export const BUDGET_PROVIDERS = Object.freeze(['claude-code', 'codex', 'opencode']);
-export const PROVIDER_LABELS = Object.freeze({ 'claude-code': 'Claude Code', codex: 'Codex', opencode: 'OpenCode' });
+export const BUDGET_PROVIDERS = Object.freeze(['claude-code', 'codex', 'opencode', 'antigravity']);
+export const PROVIDER_LABELS = Object.freeze({ 'claude-code': 'Claude Code', codex: 'Codex', opencode: 'OpenCode', antigravity: 'Antigravity' });
+/**
+ * Providers whose spend no budget can hold: they report tokens, never prices (Antigravity is billed by its Google
+ * sign-in). Under a budget they take no share, never cover work and their runs are refused (BUDGET_UNPRICED).
+ */
+export const UNPRICED_PROVIDERS = Object.freeze(['antigravity']);
+export const isUnpricedProvider = (provider) => UNPRICED_PROVIDERS.includes(provider);
+/** Why a budget cannot hold an unpriced provider's runs, in one phrase. */
+export const UNPRICED_PROVIDER_REASON = 'Antigravity reports tokens, not prices';
 
 // The brain's reserve inside its provider's share: 10 % of what is left, at least $0.50 (never more than is left).
 export const BRAIN_FLOOR_RATIO = 0.1;
@@ -48,6 +59,8 @@ const arr = (value) => (Array.isArray(value) ? value : []);
 const num = (value, fallback = 0) => (Number.isFinite(Number(value)) ? Number(value) : fallback);
 const r8 = (value) => Number((Number(value) || 0).toFixed(8));
 const isProvider = (value) => BUDGET_PROVIDERS.includes(value);
+/** Can the provider take a share? Not when it is ineligible, nor ever when it reports no prices (whatever `eligible` says). */
+const canTake = (eligible, provider) => !isUnpricedProvider(provider) && eligible?.[provider]?.eligible !== false;
 
 // ── buckets ───────────────────────────────────────────────────────────────
 
@@ -56,14 +69,15 @@ const isProvider = (value) => BUDGET_PROVIDERS.includes(value);
  *   no_models   the user disabled every model, or the provider answered with none connected
  *   signed_out  every account of the provider is signed out
  *   limited     every signed-in account is out of subscription usage
+ *   unpriced    the provider reports no prices (UNPRICED_PROVIDERS): a budget cannot hold its spend
  * A provider whose model list is merely unavailable stays eligible (routing is lenient there too). The
  * brain's provider is always eligible (its turns are paid from it); `reason` then says what else is wrong.
  */
 export function bucketEligibility({ catalog = null, accounts = null, brainProvider = null } = {}) {
   const out = {};
   for (const provider of BUDGET_PROVIDERS) {
-    let reason = null;
-    if (catalog) {
+    let reason = isUnpricedProvider(provider) ? 'unpriced' : null;
+    if (!reason && catalog) {
       if (providerEmpty(catalog, provider) || providerAllHidden(catalog, provider)) reason = 'no_models';
       else if (listedCount(catalog, provider) > 0 || arr(catalog.models?.[provider]).length) {
         const usable = arr(catalog.models?.[provider]).filter((row) => !rowIsHidden(catalog, { ...row, provider: row.provider || provider }) && row.status !== 'unavailable');
@@ -115,11 +129,13 @@ export function priceLabel(row, price) {
 }
 /**
  * How the work is paid for: 'free' (a free model), 'api' (an API key, or OpenCode's own providers), 'plan'
- * (a Claude / ChatGPT subscription). `account`: the account row the work would run under, when known.
+ * (a Claude / ChatGPT subscription, or Antigravity's Google sign-in, which reports no price at all).
+ * `account`: the account row the work would run under, when known.
  */
 export function billingOf(provider, price, account = null) {
   if (isFreePrice(price)) return 'free';
   if (provider === 'opencode') return 'api';
+  if (provider === 'antigravity') return 'plan';
   if (account?.mode === 'apiKey') return 'api';
   return 'plan';
 }
@@ -149,7 +165,7 @@ export function fallbackWeights({
   const weights = Object.fromEntries(BUDGET_PROVIDERS.map((p) => [p, 0]));
   const brainProvider = isProvider(brain?.provider) ? brain.provider : null;
   const price = (provider, model) => priceIndex(listPriceOf(rowOf(catalog, provider, model), { pricing, provider, model }));
-  const add = (provider, model, weight) => { if (isProvider(provider) && eligible[provider]?.eligible !== false) weights[provider] += weight * price(provider, model); };
+  const add = (provider, model, weight) => { if (isProvider(provider) && canTake(eligible, provider)) weights[provider] += weight * price(provider, model); };
   const prefs = routing?.preferences && typeof routing.preferences === 'object' ? routing.preferences : {};
   for (const taskClass of classes) {
     // Chat always runs here, on the brain, whatever its saved route says (assistant-router.js evaluateRoute).
@@ -161,8 +177,8 @@ export function fallbackWeights({
   if (task?.provider) add(task.provider, task.model || null, 3 * classWeight(task.taskClass));
   if (brainProvider) add(brainProvider, brain?.model || null, 2);
   for (const run of arr(liveRuns)) add(run?.provider, run?.model || null, classWeight(run?.taskClass));
-  for (const provider of arr(needs)) if (isProvider(provider) && eligible[provider]?.eligible !== false && weights[provider] <= 0) weights[provider] = Math.max(weights[provider], price(provider, null) > 0 ? 1 : 0);
-  const pool = BUDGET_PROVIDERS.filter((p) => eligible[p]?.eligible !== false);
+  for (const provider of arr(needs)) if (isProvider(provider) && canTake(eligible, provider) && weights[provider] <= 0) weights[provider] = Math.max(weights[provider], price(provider, null) > 0 ? 1 : 0);
+  const pool = BUDGET_PROVIDERS.filter((p) => canTake(eligible, p));
   if (pool.length && pool.every((p) => !(weights[p] > 0))) for (const p of pool) weights[p] = 1;
   return weights;
 }
@@ -201,7 +217,7 @@ export function jevWeights(judgment, eligible = {}) {
   if (!scores || typeof scores !== 'object') return null;
   const out = Object.fromEntries(BUDGET_PROVIDERS.map((p) => [p, 0]));
   for (const provider of BUDGET_PROVIDERS) {
-    if (eligible[provider]?.eligible === false) continue;
+    if (!canTake(eligible, provider)) continue;
     const share = shareFromScore(scores[provider]);
     if (share === null) return null;
     out[provider] = Math.max(0, share);
@@ -239,7 +255,7 @@ export function apportion(total, parts) {
  */
 export function divideLeft({ leftUsd = 0, weights = {}, eligible = {}, brainProvider = null } = {}) {
   const leftCents = floorCents(leftUsd);
-  const pool = BUDGET_PROVIDERS.filter((p) => eligible[p]?.eligible !== false);
+  const pool = BUDGET_PROVIDERS.filter((p) => canTake(eligible, p));
   const zero = Object.fromEntries(BUDGET_PROVIDERS.map((p) => [p, 0]));
   if (!leftCents || !pool.length) return { allocCents: zero, leftCents, brainFloorCents: 0, floorsCents: { ...zero } };
   const parts = Object.fromEntries(pool.map((p) => [p, Math.max(0, num(weights[p]))]));
@@ -298,6 +314,11 @@ export function coverageOf({ amountUsd = 0, split = null, spend = null, brainPro
   const providers = {};
   for (const provider of BUDGET_PROVIDERS) {
     const used = providerSpendOf(spend, provider);
+    // An unpriced provider can spend nothing a budget could hold, split or not.
+    if (isUnpricedProvider(provider)) {
+      providers[provider] = { ...used, shareUsd: split ? 0 : null, leftUsd: 0, workerLeftUsd: 0, eligible: false };
+      continue;
+    }
     const eligible = split ? split.eligible?.[provider]?.eligible !== false : true;
     if (!split) {
       providers[provider] = { ...used, shareUsd: null, leftUsd, workerLeftUsd: leftUsd, eligible };
@@ -327,16 +348,22 @@ export function coverageOf({ amountUsd = 0, split = null, spend = null, brainPro
 export function coversWork(coverage, { provider, forBrain = false, free = false, minUsd = MIN_SPEND_USD } = {}) {
   if (!coverage) return true;
   if (coverage.leftUsd < minUsd) return false;
+  // A budget cannot hold what is never priced.
+  if (isUnpricedProvider(provider)) return false;
   if (free) return true;
   const row = coverage.providers?.[provider];
   if (!row) return false;
   return (forBrain ? row.leftUsd : row.workerLeftUsd) >= minUsd;
 }
 
-/** The providers whose share is used up for workers (or ineligible), in BUDGET_PROVIDERS order. */
+/**
+ * The providers whose share is used up for workers (or ineligible), in BUDGET_PROVIDERS order. An unpriced
+ * provider is never among them: it has no share to run out of (its runs are refused under a budget for that).
+ */
 export function dryProviders(coverage, { minUsd = MIN_SPEND_USD } = {}) {
-  if (!coverage?.hasSplit) return coverage && coverage.leftUsd < minUsd ? [...BUDGET_PROVIDERS] : [];
-  return BUDGET_PROVIDERS.filter((p) => !coverage.providers[p] || coverage.providers[p].workerLeftUsd < minUsd);
+  const metered = BUDGET_PROVIDERS.filter((p) => !isUnpricedProvider(p));
+  if (!coverage?.hasSplit) return coverage && coverage.leftUsd < minUsd ? metered : [];
+  return metered.filter((p) => !coverage.providers[p] || coverage.providers[p].workerLeftUsd < minUsd);
 }
 
 // ── the view (API, live packet, agent_usage) ──────────────────────────────
@@ -380,7 +407,7 @@ export function budgetView({ sessionId = null, setting = null, coverage = null,
     const judged = split?.jev?.scores?.[provider] || null;
     return {
       provider, label: PROVIDER_LABELS[provider],
-      eligible: row.eligible, reason: split?.eligible?.[provider]?.reason || null,
+      eligible: row.eligible, reason: split?.eligible?.[provider]?.reason || (isUnpricedProvider(provider) ? 'unpriced' : null),
       isBrain: provider === (cov.brainProvider || split?.brainProvider || null),
       shareUsd: row.shareUsd === null ? null : roundUsd(row.shareUsd),
       spentUsd: roundUsd(row.spentUsd), brainSpentUsd: roundUsd(row.brainUsd), runsSpentUsd: roundUsd(row.runsUsd),

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

@@ -1,10 +1,13 @@
+import { EXTERNAL_SERVER_LIMITATIONS } from './mcp-external-servers.js';
+import { toolCatalogView } from '../../mcp-server/dist/services/tool-catalog.js';
 // ═══════════════════════════════════════════
 // SynaBun — Assistant model catalog (providers · models · tier · price · vision)
 // ═══════════════════════════════════════════
 //
 // One normalized view of every model the assistant can route to: Claude Code
-// (CLI model list), Codex (app-server model/list) and OpenCode (the shared
-// serve's /provider, connected providers only). Claude and Codex rows are
+// (CLI model list), Codex (app-server model/list), OpenCode (the shared
+// serve's /provider, connected providers only) and Antigravity (what an ACP
+// session of its own CLI offers; a brain and a worker, unpriced). Claude and Codex rows are
 // priced from the one list-price table (assistant-pricing.js), the same one
 // the usage ledger prices tokens with; OpenCode rows carry the price the serve
 // reports. A Codex row keeps `price: null` (plan billing: routing treats it as
@@ -18,7 +21,7 @@
 //
 // Which models exist is never decided here. Each provider's rows are the list
 // its own model selector reads (/api/claude/models, /api/codex/models,
-// /api/opencode/providers/full); the static tables (prices, tier hints, the 1M
+// /api/opencode/providers/full, /api/antigravity/models); the static tables (prices, tier hints, the 1M
 // rule) only describe a row. A model the provider lists and no table knows is
 // offered with what is unknown left unknown; a model only a table knows is
 // never offered. `sources` says how each provider's list was obtained.
@@ -26,8 +29,12 @@
 import { sortEfforts, variantNames } from './effort-levels.js';
 import { listPrice } from './assistant-pricing.js';
 
-export const CATALOG_PROVIDERS = ['claude-code', 'codex', 'opencode'];
+export const CATALOG_PROVIDERS = ['claude-code', 'codex', 'opencode', 'antigravity'];
+/** The providers an Assistant brain can run on (every provider of the catalog: each is a worker too). */
+export const BRAIN_PROVIDERS = Object.freeze(['claude-code', 'codex', 'opencode', 'antigravity']);
 export const TIERS = ['small', 'medium', 'large'];
+/** The thinking levels Antigravity accepts, for a model whose row names none of its own. */
+export const ANTIGRAVITY_EFFORTS = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
 
 const SMALL_HINTS = /(haiku|mini|nano|flash|lite|luna|small|tiny|\bair\b|[:\-_ ](1|2|3|4|7|8|9|12|14|20|24|27|30|32)b\b)/i;
 const LARGE_HINTS = /(opus|fable|astra|ultra|\bpro\b|-pro\b|large|[:\-_ ](1\d\d|[2-9]\d\d)b\b|-sol\b)/i;
@@ -149,7 +156,8 @@ export function withClaudeContextVariants(rows) {
 
 /** Tier guess: name hints first, then output-price bands. */
 export function guessTier(row = {}) {
-  const name = `${row.id || ''} ${row.label || ''} ${row.upstream || ''}`;
+  // "Gemini" holds the small hint "mini": the family's name says nothing of its size (gemini-2.5-pro is not small).
+  const name = `${row.id || ''} ${row.label || ''} ${row.upstream || ''}`.replace(/gemini/gi, ' ');
   if (SMALL_HINTS.test(name)) return 'small';
   if (LARGE_HINTS.test(name)) return 'large';
   if (MEDIUM_HINTS.test(name)) return 'medium';
@@ -322,6 +330,43 @@ export function normalizeCodexRows(rows, { priceOf = null } = {}) {
   });
 }
 
+/**
+ * Antigravity's own model list (GET /api/antigravity/models: { id, label, description?, default?, efforts? }) →
+ * rows. Antigravity is billed by its Google sign-in and reports tokens, not prices: `price` stays null and its
+ * runs are unpriced. A row without levels of its own takes the five Antigravity accepts. The tier is guessed from
+ * the name like every provider's (guessTier). `via: 'acp'` (the list an ACP session offered, lib/antigravity/
+ * catalog.js): SynaBun hands such a model images as ACP image blocks, which agy passes on (measured on agy 1.4.12
+ * with Gemini 3.8 Flash and 4 Argon), so it can see; a list `agy models` gave says nothing about that. Outputs and the
+ * context window stay unknown.
+ */
+export function normalizeAntigravityRows(rows, { via = null } = {}) {
+  const sees = via === 'acp';
+  const seen = new Set();
+  const out = [];
+  for (const raw of arr(rows)) {
+    const m = typeof raw === 'string' ? { id: raw } : raw;
+    const id = typeof m?.id === 'string' ? m.id.trim() : '';
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    const own = sortEfforts(arr(m.efforts));
+    const row = {
+      provider: 'antigravity', id, upstream: id, label: String(m.label || m.name || id), family: null,
+      tier: null, vision: sees ? true : null, visionSource: sees ? 'acp' : 'unknown',
+      outputs: { image: null, video: null }, outputsSource: 'unknown',
+      reasoning: null, toolcall: null, contextWindow: null,
+      price: null,
+      efforts: own.length ? own : [...ANTIGRAVITY_EFFORTS], defaultEffort: null,
+      isDefault: m.default === true || m.isDefault === true,
+      status: 'active',
+      description: m.description ? String(m.description) : null,
+    };
+    row.tier = guessTier(row);
+    row.tierSource = 'guess';
+    out.push(row);
+  }
+  return out;
+}
+
 /** The ids the user hid for `provider` (catalog.hidden, else the older opencodeHidden). */
 function hiddenList(catalog, provider) {
   const map = catalog?.hidden;
@@ -490,9 +535,10 @@ function ctxText(ctx) {
 
 /** One routing-sheet line: `id · tier · $in/$out · vision · image-out · video-out · ctx · efforts`. */
 export function formatModelLine(row) {
-  // Only Codex bills a plan; any other row without a price is a model no table prices yet.
+  // Only Codex bills a plan; Antigravity reports tokens, never prices; any other row without a price is a
+  // model no table prices yet.
   const planBilled = row.provider === 'codex' || !!row.listPrice;
-  const parts = [row.id, row.tier || '?', row.price || planBilled ? priceText(row.price, row.listPrice) : 'price unknown'];
+  const parts = [row.id, row.tier || '?', row.price || planBilled ? priceText(row.price, row.listPrice) : row.provider === 'antigravity' ? 'unpriced' : 'price unknown'];
   if (row.vision) parts.push('vision');
   if (rowMakes(row, 'image')) parts.push('image-out');
   if (rowMakes(row, 'video')) parts.push('video-out');
@@ -556,7 +602,8 @@ export function selectSheetModels(catalog, { brain = {}, preferences = {}, max =
         else if (current.id === 'default' && row.upstream === current.upstream) families.set(family, row);
       }
       for (const row of families.values()) add(row);
-    } else if (provider === 'codex') {
+    } else if (provider === 'codex' || provider === 'antigravity') {
+      // Short lists, and Antigravity's rows carry no tier or price to sample by.
       for (const row of rows) add(row);
     } else {
       const upstream = brain?.provider === 'opencode' && brain?.model ? String(brain.model).split('/')[0] : null;
@@ -610,6 +657,7 @@ export function compactRow(row) {
  */
 export function createAssistantCatalog({
   fetchJson,
+  getExternalServers = () => [],
   claudePricing = null,
   codexPrice = (model) => listPrice('codex', model),
   listAccounts = () => ({}),
@@ -656,17 +704,30 @@ export function createAssistantCatalog({
     return JSON.stringify(arr(rows).map((row) => [row.id, row.label, row.upstream || '', row.status || '', row.contextWindow || 0, arr(row.efforts).join(',')]));
   }
 
+  /**
+   * Antigravity's answer: its endpoint says itself how the list was obtained ('live', 'stale': its own last
+   * list while the CLI does not answer, 'unavailable'). No answer, a refusal or an unavailable list: no rows.
+   */
+  function antigravityList(payload) {
+    if (!payload || typeof payload !== 'object' || payload.ok === false) return { list: [], state: 'unavailable' };
+    const said = String(payload.source || '').toLowerCase();
+    // Whether Antigravity is signed in, and on which plan, as its last listing said (null: not known).
+    const signIn = { signedIn: payload.signedIn === true ? true : payload.signedIn === false || payload.authRequired === true ? false : null, tier: typeof payload.tier === 'string' ? payload.tier : null };
+    if (said === 'unavailable') return { list: [], state: 'unavailable', via: null, ...signIn };
+    const list = pickArray(payload, ['models']);
+    return { list, state: said === 'stale' ? 'stale' : list.length || said === 'live' ? 'live' : 'unavailable', via: typeof payload.via === 'string' ? payload.via : null, ...signIn };
+  }
+
   async function build({ deep = false } = {}) {
     // `deep` also drops the providers' own discovery caches (a CLI or app-server round trip).
     const fresh = deep ? '?refresh=1' : '';
-    const [claudeModels, codexModels, opencodeProviders, projects, mcpProfile] = await Promise.all([
+    const [claudeModels, codexModels, opencodeProviders, antigravityModels, projects] = await Promise.all([
       fetchJson(`/api/claude/models${fresh}`), fetchJson(`/api/codex/models${fresh}`), fetchJson('/api/opencode/providers/full'),
-      fetchJson('/api/projects'), fetchJson('/api/mcp/profile'),
+      // A provider that does not answer is unavailable for this build, never a failed build.
+      Promise.resolve().then(() => fetchJson(`/api/antigravity/models${fresh}`)).catch(() => null),
+      fetchJson('/api/projects'),
     ]);
     const filter = (() => { try { return readFilter() || {}; } catch { return {}; } })();
-    const presets = mcpProfile?.presets && typeof mcpProfile.presets === 'object'
-      ? Object.entries(mcpProfile.presets).map(([name, preset]) => ({ name, label: preset?.label || name, groups: preset?.groups || [], tools: preset?.tools || null }))
-      : [];
     let accounts = {};
     try { accounts = listAccounts() || {}; } catch (error) { log('catalog:accounts-error', error?.message || String(error)); }
     // Models the user hid (Assistant → Models, Settings → OpenCode) never reach
@@ -680,17 +741,20 @@ export function createAssistantCatalog({
     })();
     const claude = settle('claude-code', claudeModels);
     const codex = settle('codex', codexModels);
+    const antigravity = antigravityList(antigravityModels);
     // OpenCode is read from its serve on every build; while it is down its models are unknown, not remembered.
     const sources = {
       'claude-code': claude.state,
       codex: codex.state,
       opencode: opencodeProviders && opencodeProviders.ok !== false ? 'live' : 'unavailable',
+      antigravity: antigravity.state,
     };
     for (const p of ['claude-code', 'codex']) if (sources[p] !== 'live') log('catalog:source', `${p}: ${sources[p]}`);
     const all = {
       'claude-code': withClaudeContextVariants(normalizeClaudeRows(claude.list, { pricing: claudePricing })),
       codex: normalizeCodexRows(codex.list, { priceOf: codexPrice }),
       opencode: parseOpenCodeProviders(opencodeProviders, { filter: filter.opencode || null }),
+      antigravity: normalizeAntigravityRows(antigravity.list, { via: antigravity.via }),
     };
     // A hidden alias hides the model it named when it was hidden. With the rows at hand the
     // store settles that: an alias that moved on is shown again and its old model stays hidden.
@@ -737,14 +801,16 @@ export function createAssistantCatalog({
       opencodeListed: listedCounts.opencode,
       opencodeHidden: hidden.opencode,
       projects: pickArray(projects, ['projects']),
-      profiles: presets,
-      mcpProfiles: { presets, default: mcpProfile?.defaultProfile || mcpProfile?.profile || 'full' },
+      tools: { ...toolCatalogView(), servers: getExternalServers(pickArray(projects, ['projects'])), externalServerLimitations: EXTERNAL_SERVER_LIMITATIONS },
       accounts,
       // Efforts are per model (row.efforts); a provider's list is the union of its rows'.
       providers: [
         { id: 'claude-code', brain: true, efforts: providerEfforts(models['claude-code']), permissionPolicies: ['auto', 'ask'] },
         { id: 'codex', brain: true, efforts: providerEfforts(models.codex), permissionPolicies: ['auto', 'restricted'] },
         { id: 'opencode', brain: true, efforts: providerEfforts(models.opencode), permissionPolicies: ['auto', 'ask'] },
+        // A brain and a worker. No accounts (Antigravity signs in with Google in its own CLI: `signedIn` and `tier`
+        // say what its last model listing found) and unpriced (tokens, not prices).
+        { id: 'antigravity', brain: true, efforts: providerEfforts(models.antigravity), permissionPolicies: ['auto', 'ask'], accounts: false, priced: false, signedIn: antigravity.signedIn, tier: antigravity.tier },
       ],
     };
   }

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

@@ -17,7 +17,9 @@ import { normalizeUserContext, USER_CONTEXT_DEFAULTS } from './assistant-user-co
 
 export const ROUTE_MODES = ['always-ask', 'ask-unsure', 'never'];
 export const PREFERENCE_KINDS = ['direct', 'dispatch'];
-export const ROUTE_PROVIDERS = ['claude-code', 'codex', 'opencode'];
+export const ROUTE_PROVIDERS = ['claude-code', 'codex', 'opencode', 'antigravity'];
+/** The route providers whose targets name an account (OpenCode has none of its own; Antigravity signs in with Google in its CLI). */
+export const ROUTE_ACCOUNT_PROVIDERS = ['claude-code', 'codex'];
 
 export const DEFAULT_ROUTING = Object.freeze({
   defaultMode: 'ask-unsure',
@@ -51,13 +53,14 @@ function routingError(field, message) {
 function cleanTarget(field, target) {
   if (target === null) return null;
   if (!target || typeof target !== 'object') throw routingError(field, `routing.${field} must be an object or null`);
-  const kind = PREFERENCE_KINDS.includes(target.kind) ? target.kind : 'dispatch';
   const provider = String(target.provider || '').trim();
   if (!ROUTE_PROVIDERS.includes(provider)) throw routingError(`${field}.provider`, `routing.${field}.provider must be one of ${ROUTE_PROVIDERS.join(', ')}`);
+  // Every provider can be the brain now (Antigravity included), so a route keeps the kind it was saved with.
+  const kind = PREFERENCE_KINDS.includes(target.kind) ? target.kind : 'dispatch';
   const out = { kind, provider, model: target.model ? String(target.model).slice(0, 200) : null, effort: target.effort ? String(target.effort).slice(0, 40) : null };
   if (target.accountId != null && target.accountId !== '') {
     if (typeof target.accountId !== 'string' || !/^[a-z0-9-]{1,64}$/.test(target.accountId)) throw routingError(`${field}.accountId`, 'Invalid route account id');
-    if (provider !== 'opencode') out.accountId = target.accountId;
+    if (ROUTE_ACCOUNT_PROVIDERS.includes(provider)) out.accountId = target.accountId;
   }
   if (target.label) out.label = String(target.label).slice(0, 120);
   if (target.at) out.at = String(target.at).slice(0, 40);