synabun 2.0.10 → 2.2.0

package/neural-interface/lib/sqlite-integrity-worker.js

@@ -0,0 +1,22 @@
+// SQLite's PRAGMA integrity_check on each database copy of an upgrade snapshot, off the snapshot's main thread
+// (backup-service.js checkSqliteIntegrity): the archive is written and read back meanwhile. workerData: { paths };
+// posts [{ path, ok, lines, ms }] once, in the same order. A file that cannot be opened is not ok.
+import { parentPort, workerData } from 'node:worker_threads';
+import { DatabaseSync } from 'node:sqlite';
+
+const results = [];
+for (const path of workerData?.paths || []) {
+  const started = Date.now();
+  let db = null;
+  try {
+    db = new DatabaseSync(path, { readOnly: true });
+    // The check `synabun restore-backup` runs (scripts/restore-data-home-from-backup.mjs); 20 findings are plenty to say why.
+    const lines = db.prepare('PRAGMA integrity_check(20)').all().map(row => String(Object.values(row)[0]));
+    results.push({ path, ok: lines.length === 1 && lines[0] === 'ok', lines: lines.slice(0, 20), ms: Date.now() - started });
+  } catch (error) {
+    results.push({ path, ok: false, lines: [String(error?.message || error)], ms: Date.now() - started });
+  } finally {
+    try { db?.close(); } catch { /* already closed */ }
+  }
+}
+parentPort.postMessage(results);

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/tool-lists.js

@@ -0,0 +1,124 @@
+// Neural Interface's storage boundary. Catalog and resolution belong to mcp-server.
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { parseToolList, resolveToolList, serializeToolList } from '../../mcp-server/dist/services/tool-list.js';
+
+export function requireToolList(result) {
+  if (!result.ok) throw Object.assign(new Error(result.message), result, { status: 400 });
+  return result;
+}
+
+// Run 1 treats a blank environment variable/header as absent. The accepted always-on id
+// carries an explicit empty selection across those transports without falling back to all.
+export function runtimeToolsValue(items) {
+  return serializeToolList(items) || 'memory';
+}
+
+/** null is inherited; [] is an explicit selection of always-on tools only. */
+export function storedToolList(record, { customPresets = null } = {}) {
+  if (!record || typeof record !== 'object') return null;
+  if (record.tools !== undefined && record.tools !== null) {
+    if (!Array.isArray(record.tools)) throw Object.assign(new Error('tools must be an array'), { code: 'TOOLS_INVALID', status: 400 });
+    return requireToolList(resolveToolList(requireToolList(parseToolList(record.tools)).items, { source: 'runtime' })).items;
+  }
+  const legacy = record.mcpProfile;
+  if (legacy === undefined || legacy === null || legacy === '') return null;
+  if (typeof legacy !== 'string') throw Object.assign(new Error('mcpProfile must be a string'), { code: 'TOOLS_INVALID', status: 400 });
+  if (!legacy.trim()) return null;
+  const parsed = requireToolList(parseToolList(legacy, { legacy: true, customPresets }));
+  return requireToolList(resolveToolList([...parsed.items, 'mcp:*'], { source: 'runtime' })).items;
+}
+
+/** Disk records written before external scoping inherited their provider's servers, even with an empty group list. */
+export function readStoredToolListRecord(record, options) {
+  const tools = storedToolList(record, options);
+  const migrated = tools !== null && record.externalMcpVersion !== 2 && !tools.some(item => item.startsWith('mcp:'))
+    ? [...tools, 'mcp:*'] : tools;
+  return toolListRecord({ ...record, ...(migrated === null ? {} : { tools: migrated }) }, options);
+}
+
+export function automationPlatform(schedule, group, template) {
+  for (const record of [template, schedule, group]) if (record?.platform) return record.platform;
+  for (const record of [schedule, group, template]) {
+    if (typeof record?.mcpProfile !== 'string') continue;
+    const parsed = parseToolList(record.mcpProfile, { legacy: true });
+    if (parsed.ok && parsed.platform) return parsed.platform;
+  }
+  const id = String(schedule?.templateId || template?.id || schedule?.id || '');
+  if (/^(cpfb_|fbdeals_)/.test(id)) return 'facebook';
+  if (/^cp_/.test(id)) return 'twitter';
+  return null;
+}
+
+/** A copy for persistence: never rewrite a source record just because it was read. */
+export function toolListRecord(record, options) {
+  const next = { ...record, externalMcpVersion: 2 };
+  const tools = storedToolList(record, options);
+  const platform = automationPlatform(record);
+  if (tools === null) delete next.tools;
+  else next.tools = tools;
+  if (platform) next.platform = platform;
+  delete next.mcpProfile;
+  return next;
+}
+
+/** An unrelated edit must not persist a read-time external-scope migration. */
+export function toolListRecordForUpdate(record, previous, options) {
+  const next = toolListRecord(record, options);
+  if (!previous || previous.mcpProfile != null) return next;
+  const before = storedToolList(readStoredToolListRecord(previous, options), options);
+  if (serializeToolList(next.tools ?? []) !== serializeToolList(before ?? [])
+      || (next.tools == null) !== (before == null)) return next;
+  // Keep the exact stored representation, including absent/null, legacy [] and version metadata.
+  for (const key of ['tools', 'externalMcpVersion']) {
+    delete next[key];
+    if (Object.hasOwn(previous, key)) next[key] = Array.isArray(previous[key]) ? [...previous[key]] : previous[key];
+  }
+  return next;
+}
+
+/** Apply an array patch while preserving stored legacy platform hints. */
+export function applyStoredToolList(record, patch, options) {
+  if (patch.tools === undefined) return record;
+  const source = { ...record, ...patch, platform: patch.platform || automationPlatform(record) };
+  delete source.mcpProfile;
+  const next = toolListRecord(source, options);
+  delete record.mcpProfile;
+  delete record.tools;
+  if (next.tools !== undefined) record.tools = next.tools;
+  if (next.platform) record.platform = next.platform;
+  return record;
+}
+
+export function resolveStoredTools(record, context = {}, options) {
+  const stored = storedToolList(record, options);
+  return requireToolList(resolveToolList(stored ?? undefined, { source: 'launch', usesBrowser: record?.usesBrowser, taskClass: record?.taskClass, ...context }));
+}
+
+export function readDefaultTools(dataHome, options) {
+  const path = resolve(dataHome, 'data', 'default-tools.json');
+  if (existsSync(path)) {
+    const record = JSON.parse(readFileSync(path, 'utf8'));
+    if (!Array.isArray(record.tools)) throw Object.assign(new Error('Default tools must be an array'), { code: 'TOOLS_INVALID', status: 400 });
+    return storedToolList(readStoredToolListRecord(record, options), options);
+  }
+  for (const dir of ['mcp-data', 'data']) {
+    const legacyPath = resolve(dataHome, dir, 'active-profile.json');
+    if (!existsSync(legacyPath)) continue;
+    const record = JSON.parse(readFileSync(legacyPath, 'utf8'));
+    const tools = storedToolList({ mcpProfile: record.profile }, options);
+    if (tools !== null) return tools;
+  }
+  return ['all', 'mcp:*'];
+}
+
+export function writeDefaultTools(dataHome, tools) {
+  const items = storedToolList({ tools });
+  if (items === null) throw Object.assign(new Error('tools must be an array'), { code: 'TOOLS_INVALID', status: 400 });
+  const path = resolve(dataHome, 'data', 'default-tools.json');
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify({ tools: items, externalMcpVersion: 2, updatedAt: new Date().toISOString() }, null, 2) + '\n', { mode: 0o600 });
+  renameSync(tmp, path);
+  return items;
+}

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/bridge.js

@@ -57,6 +57,7 @@
 // composition are injected (Packages A and C); nothing here knows a phone number.
 
 import { assistantEventKey } from '../../public/shared/assistant/asst-state.js';
+import { stripFollowups } from '../../public/shared/assistant/asst-followups.js';
 import { brainCapsLevel, defaultRemotePolicyRegistry, effectiveLevel, remoteBrainNotice } from '../remote-policy.js';
 import { brainSignature, resolveBrainChoice } from './brain.js';
 import { answerCard, cardFromPacket, failClosedResponse, isBareAnswer, randomTag, renderCard } from './cards.js';
@@ -646,12 +647,14 @@ export function createWhatsAppBridge({
   function finalText(turn) {
     const segments = turn.segments.filter(Boolean);
     const result = typeof turn.resultText === 'string' ? turn.resultText.trim() : '';
-    const final = result || segments[segments.length - 1] || '';
+    const raw = result || segments[segments.length - 1] || '';
+    // A follow-ups block is the panel's buttons: a phone gets the words around it.
+    const final = stripFollowups(raw).trim();
     if (!final) return '';
     if (final.length < 200) {
-      const earlier = segments.filter((segment) => segment !== final && segment.length >= 280);
+      const earlier = segments.filter((segment) => segment !== raw && segment !== final && segment.length >= 280);
       const lead = earlier[earlier.length - 1];
-      if (lead && !turn.narrated?.has(lead)) return `${lead}\n\n${final}`;
+      if (lead && !turn.narrated?.has(lead)) return `${stripFollowups(lead).trim()}\n\n${final}`;
     }
     return final;
   }

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',