synabun 2.0.10 → 2.2.0

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

@@ -1,5 +1,5 @@
 // ═══════════════════════════════════════════
-// SynaBun — Assistant envelope translators (Codex / OpenCode → Claude-shaped)
+// SynaBun — Assistant envelope translators (Codex / OpenCode / Antigravity → Claude-shaped)
 // ═══════════════════════════════════════════
 //
 // The assistant UI renders one wire format: the claude-skin envelope
@@ -10,6 +10,7 @@
 // every brain looks the same to the panel. No I/O here.
 
 import { randomUUID } from 'node:crypto';
+import { acpCall, acpToolPaths, acpUiToolName } from './antigravity/tool-call.js';
 
 export function synthesizeInit({ brain, sessionId = null, cwd = null, model = null, permissionMode = null } = {}) {
   return {
@@ -130,7 +131,9 @@ export function codexControlRequestFromServerRequest(packet = {}) {
     request: {
       subtype: 'can_use_tool', provider: 'codex', kind, method, tool_name: toolName, input,
       // rpcId: the app-server's JSON-RPC id as sent (a number); request_id above is its string key.
-      brain_native: { method, params, rpcId: packet.requestId ?? null, threadId: packet.threadId || null, turnId: packet.turnId || null, toolCallId: params.toolCallId || params.itemId || null, availableDecisions: params.availableDecisions || null },
+      // Match the skin bridge's correlation precedence. Dropping callId makes
+      // automatic plan-mode replies stale even though the policy allowed them.
+      brain_native: { method, params, rpcId: packet.requestId ?? null, threadId: packet.threadId || null, turnId: packet.turnId || null, toolCallId: params.toolCallId || params.callId || params.itemId || null, availableDecisions: params.availableDecisions || null },
     },
   };
 }
@@ -598,3 +601,154 @@ export function createOpenCodeEnvelopeTranslator({ sessionId, emit, onTurnEnd =
     },
   };
 }
+
+// ── Antigravity (ACP) ────────────────────────────────────────────────────────
+
+/**
+ * An Antigravity tool call as the panel shows it: its name (SynaBun_agent_route for an MCP call, as OpenCode's;
+ * Antigravity's own word otherwise) and its input (an MCP call's arguments; a command as `command`; a path as
+ * `file_path`, so the panel's generic cards read them).
+ */
+export function acpToolUse(update = {}) {
+  const call = acpCall(update);
+  const input = call.mcp ? { ...call.mcp.args } : { ...call.args };
+  if (!call.mcp) {
+    if (call.command && typeof input.command !== 'string') input.command = call.command;
+    const path = acpToolPaths(call)[0];
+    if (path && typeof input.file_path !== 'string') input.file_path = path;
+  }
+  return { id: call.id || `acp-${randomUUID()}`, name: acpUiToolName(call), input };
+}
+
+/** The text an ACP tool call produced: its content blocks' text (diffs as their path), else a raw output. */
+export function acpToolOutput(update = {}) {
+  const parts = [];
+  for (const block of Array.isArray(update.content) ? update.content : []) {
+    if (block?.type === 'content' && block.content?.type === 'text' && block.content.text) parts.push(block.content.text);
+    else if (block?.type === 'diff' && block.path) parts.push(`edited ${block.path}`);
+    else if (block?.type === 'terminal' && block.terminalId) parts.push(`[terminal ${block.terminalId}]`);
+  }
+  if (parts.length) return parts.join('\n');
+  const raw = update.rawOutput;
+  if (typeof raw === 'string') return raw;
+  if (raw && typeof raw === 'object') {
+    const joined = [raw.output, raw.stdout, raw.stderr, raw.error].filter((v) => typeof v === 'string' && v).join('\n');
+    if (joined) return joined;
+    return safeJson(raw);
+  }
+  return '';
+}
+
+/**
+ * Stateful translator for one Antigravity brain turn after another: ACP session/update notifications → the
+ * envelope (`handle(update)`), and the turn's end from the session/prompt answer (`endTurn({ stopReason,
+ * usage, error })`). `planTurn()`: the turn runs in plan mode with the proposal instructions (assistant-persona.js
+ * planModeInstructions): its <proposed_plan> block is the plan (`result.plan`), and the tags never show.
+ */
+export function createAcpEnvelopeTranslator({ emit, brain = {}, planTurn = () => false } = {}) {
+  const state = { started: false, announcedInit: false, text: '', tools: new Map(), turn: 0 };
+  const event = (payload) => emit({ type: 'event', event: payload });
+  const startIfNeeded = () => {
+    if (!state.announcedInit) { state.announcedInit = true; event(synthesizeInit({ brain: 'antigravity', sessionId: brain.sessionId?.() || null, cwd: brain.cwd || null, model: brain.model?.() || null })); }
+    if (state.started) return;
+    state.started = true;
+    event(messageStart(`antigravity-turn-${randomUUID()}`));
+  };
+  // A plan turn's tags never stream: a trailing "<…" that could still become one waits for the next chunk.
+  let held = '';
+  function streamText(delta) {
+    if (planTurn() !== true) return delta;
+    const text = `${held}${delta}`.replace(/<\/?proposed_plan>/g, '');
+    const at = text.lastIndexOf('<');
+    const cut = at !== -1 && ['<proposed_plan>', '</proposed_plan>'].some((tag) => tag.startsWith(text.slice(at))) ? at : text.length;
+    held = text.slice(cut);
+    return text.slice(0, cut);
+  }
+  function toolStarted(update) {
+    const use = acpToolUse(update);
+    if (state.tools.has(use.id)) return state.tools.get(use.id);
+    const known = { use, done: false };
+    state.tools.set(use.id, known);
+    startIfNeeded();
+    event(assistantMessage([{ type: 'tool_use', id: use.id, name: use.name, input: use.input }], `antigravity-tool-${use.id}`));
+    return known;
+  }
+  return {
+    state,
+    /** Forget anything left of an earlier turn (nothing is emitted): the next turn starts clean. */
+    reset() { state.text = ''; state.tools.clear(); state.started = false; held = ''; },
+    /** One session/update's `update`. → true when it meant something for the panel. */
+    handle(update = {}) {
+      const kind = update?.sessionUpdate;
+      if (kind === 'agent_message_chunk' && update.content?.type === 'text') {
+        const delta = String(update.content.text || '');
+        if (!delta) return false;
+        state.text += delta;
+        const shown = streamText(delta);
+        if (shown) { startIfNeeded(); event(textDelta(shown)); }
+        return true;
+      }
+      if (kind === 'agent_thought_chunk' && update.content?.type === 'text') {
+        const delta = String(update.content.text || '');
+        if (!delta) return false;
+        startIfNeeded();
+        event(thinkingDelta(delta));
+        return true;
+      }
+      if (kind === 'tool_call') { toolStarted(update); return true; }
+      if (kind === 'tool_call_update') {
+        const id = String(update.toolCallId || '');
+        if (!id) return false;
+        // An update for a call never announced (a resumed turn): it is announced with what the update carries.
+        const known = state.tools.get(id) || toolStarted({ ...update });
+        if ((update.status === 'completed' || update.status === 'failed') && !known.done) {
+          known.done = true;
+          const output = acpToolOutput(update) || (update.status === 'failed' ? 'tool failed' : '');
+          event(toolResult(id, clip(output), update.status === 'failed'));
+        }
+        return true;
+      }
+      if (kind === 'session_info_update' && typeof update.title === 'string' && update.title.trim()) {
+        event({ type: 'system', subtype: 'thread_title', title: update.title.trim() });
+        return true;
+      }
+      return false;
+    },
+    /**
+     * The turn's end: what the session/prompt answered (stopReason, usage) or the error it rejected with.
+     * `planned`: whether the turn that ended was a plan turn (the caller may have let go of it already).
+     */
+    endTurn({ stopReason = 'end_turn', usage = null, error = null, planned = undefined } = {}) {
+      state.turn += 1;
+      const said = state.text;
+      const planning = typeof planned === 'boolean' ? planned : planTurn() === true;
+      const text = planning ? said.replace(/<\/?proposed_plan>/g, '').trim() : said;
+      const plan = planning ? proposedPlanText(said) : '';
+      if (held) { const rest = held; held = ''; if (rest) { startIfNeeded(); event(textDelta(rest)); } }
+      if (state.started) event(messageStop());
+      // Calls still open when the turn ended (a stop, an error) end with it.
+      for (const [id, known] of state.tools) if (!known.done) { known.done = true; event(toolResult(id, stopReason === 'cancelled' ? 'interrupted' : 'tool did not finish', true)); }
+      state.tools.clear();
+      state.text = '';
+      state.started = false;
+      if (error) {
+        const message = typeof error === 'string' ? error : (error?.message || 'Antigravity turn failed');
+        if (text) event(assistantMessage([{ type: 'text', text }], `antigravity-final-${randomUUID()}`));
+        event({ type: 'result', subtype: 'error_during_execution', is_error: true, result: text || message, usage, total_cost_usd: null, brain: 'antigravity', num_turns: 1 });
+        emit({ type: 'error', message });
+        emit({ type: 'done', code: 1 });
+        return { status: 'failed', text, error: message };
+      }
+      if (stopReason === 'cancelled') {
+        if (text) event(assistantMessage([{ type: 'text', text }], `antigravity-final-${randomUUID()}`));
+        emit({ type: 'aborted' });
+        return { status: 'aborted', text };
+      }
+      if (text) event(assistantMessage([{ type: 'text', text }], `antigravity-final-${randomUUID()}`));
+      const refused = stopReason === 'refusal';
+      event({ type: 'result', subtype: refused ? 'error_during_execution' : 'success', ...(refused ? { is_error: true } : {}), result: text, plan: plan || undefined, usage, total_cost_usd: null, brain: 'antigravity', num_turns: 1, stop_reason: stopReason });
+      emit({ type: 'done', code: refused ? 1 : 0 });
+      return { status: refused ? 'refused' : 'completed', text };
+    },
+  };
+}

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

@@ -12,9 +12,15 @@
  *   Codex     item.completed: command_execution, mcp_tool_call, file_change, error
  *   OpenCode  message.part.updated tool parts, keyed by callID, last write wins,
  *             counted once completed or errored
+ *   Antigravity  ACP tool_call / tool_call_update, keyed by toolCallId (an update
+ *             carries only what changed, so it is merged into the call), counted
+ *             once completed or failed: execute → a command (rawInput.command or
+ *             Antigravity's CommandLine), edit / delete / move → edited files,
+ *             any other kind that can show success or failure → a result
  */
 
 import { isTestOrBuildCommand } from '../../hooks/claude-code/shared.mjs';
+import { acpMcpTarget } from './antigravity/tool-call.js';
 
 const MAX_KEPT = 24;          // commands / results kept per turn
 const MAX_PENDING = 200;      // Claude tool uses waiting for their result; OpenCode parts
@@ -32,6 +38,11 @@ const MEMORY_TOOL = /(?:^|__)Syna[Bb]un[._]+(?:remember|reflect|recall|memories|
 const CLAUDE_EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
 const OPENCODE_EDIT_TOOLS = new Set(['edit', 'write', 'patch', 'multiedit']);
 const OPENCODE_QUIET = /^(?:read|grep|glob|list|ls|todo\w*)$/i;
+// ACP tool kinds: the ones that change files, and the ones whose result says nothing about success.
+const ACP_EDIT_KINDS = new Set(['edit', 'delete', 'move']);
+const ACP_QUIET_KINDS = new Set(['read', 'search', 'think', 'switch_mode']);
+// Path fields of an ACP call's raw input (lib/worker-confinement.js acpToolPaths reads the same, Antigravity's included).
+const ACP_PATH_KEYS = ['path', 'file_path', 'filePath', 'TargetFile', 'AbsolutePath', 'destination', 'newPath', 'new_path'];
 
 function clipLine(value, max) {
   const s = String(value ?? '').replace(/\s+/g, ' ').trim();
@@ -176,6 +187,69 @@ function recordOpenCode(acc, eventType, event) {
   if (acc.parts.size > MAX_PENDING) acc.parts.delete(acc.parts.keys().next().value);
 }
 
+// ── Antigravity (ACP) ───────────────────────────────────────────────────────
+/** The command an ACP execute call runs (Antigravity's run_command names it CommandLine), else ''. */
+export function acpCommandOf(call = {}) {
+  const input = call?.rawInput && typeof call.rawInput === 'object' ? call.rawInput : {};
+  if (typeof input.command === 'string') return input.command;
+  if (Array.isArray(input.command)) return input.command.map(String).join(' ');
+  if (typeof input.CommandLine === 'string') return input.CommandLine;
+  if (typeof input.cmd === 'string') return input.cmd;
+  return '';
+}
+/** The text an ACP call produced: its content blocks' text, else a text raw output. */
+function acpOutput(call) {
+  const blocks = Array.isArray(call?.content) ? call.content : [];
+  const text = blocks.map((block) => (block?.type === 'content' && block.content?.type === 'text' ? block.content.text || '' : '')).filter(Boolean).join('\n');
+  if (text) return text;
+  const raw = call?.rawOutput;
+  if (typeof raw === 'string') return raw;
+  if (raw && typeof raw === 'object') {
+    const joined = [raw.output, raw.stdout, raw.stderr, raw.error].filter((v) => typeof v === 'string' && v).join('\n');
+    if (joined) return joined;
+  }
+  return '';
+}
+/** A command's exit from what the call reports: a failed call is an error; a completed one only by an exit code it names. */
+function acpExit(call) {
+  if (call.status === 'failed') return 'error';
+  const raw = call.rawOutput && typeof call.rawOutput === 'object' ? call.rawOutput : {};
+  const code = [raw.exitCode, raw.exit_code, raw.ExitCode, raw.code].find((v) => typeof v === 'number');
+  return typeof code === 'number' ? (code === 0 ? 'ok' : 'error') : 'unknown';
+}
+function acpPaths(call) {
+  const out = (Array.isArray(call?.locations) ? call.locations : []).map((l) => l?.path).filter((p) => typeof p === 'string' && p);
+  const input = call?.rawInput && typeof call.rawInput === 'object' ? call.rawInput : {};
+  for (const key of ACP_PATH_KEYS) if (typeof input[key] === 'string' && input[key]) out.push(input[key]);
+  return out;
+}
+function recordAntigravity(acc, eventType, update) {
+  if ((eventType !== 'tool_call' && eventType !== 'tool_call_update') || !update || typeof update !== 'object') return;
+  const key = String(update.toolCallId || '');
+  if (!key) return;
+  if (!acc.acpCalls) acc.acpCalls = new Map();
+  // An update carries only what changed: it is merged into the call.
+  const known = acc.acpCalls.get(key);
+  const call = { ...(known || { order: ++acc.seq }) };
+  for (const [field, value] of Object.entries(update)) if (value !== undefined && value !== null && field !== 'sessionUpdate' && field !== 'order') call[field] = value;
+  acc.acpCalls.set(key, call);
+  if (acc.acpCalls.size > MAX_PENDING) acc.acpCalls.delete(acc.acpCalls.keys().next().value);
+  // An MCP call is the tool it calls, never a command (agy reports it as kind `execute` with no command line).
+  const mcp = acpMcpTarget(call.name || '', call.rawInput) || (call.rawInput && typeof call.rawInput === 'object' && call.rawInput.ServerName && call.rawInput.ToolName ? { server: String(call.rawInput.ServerName), tool: String(call.rawInput.ToolName) } : null);
+  const kind = mcp ? 'mcp' : String(call.kind || 'other');
+  if (ACP_EDIT_KINDS.has(kind)) for (const path of acpPaths(call)) addFile(acc, path);
+  if (call.status !== 'completed' && call.status !== 'failed') return;
+  const failed = call.status === 'failed';
+  const name = mcp ? `mcp__${mcp.server}__${mcp.tool}` : String(call.title || call.name || kind);
+  let record = null;
+  if (kind === 'execute') record = { kind: 'command', entry: { command: clipLine(acpCommandOf(call) || name, COMMAND_CLIP), exit: acpExit(call), output_tail: tailText(acpOutput(call)) } };
+  else if (ACP_EDIT_KINDS.has(kind)) { if (failed) record = { kind: 'result', entry: { tool: name, is_error: true, tail: tailText(acpOutput(call) || `${kind} failed: ${acpPaths(call).join(', ')}`) } }; }
+  else if (!ACP_QUIET_KINDS.has(kind) && !quietTool(name)) record = { kind: 'result', entry: { tool: name, is_error: failed, tail: tailText(acpOutput(call)) } };
+  if (!record) return;
+  acc.parts.set(`acp:${key}`, { order: call.order, ...record });
+  if (acc.parts.size > MAX_PENDING) acc.parts.delete(acc.parts.keys().next().value);
+}
+
 /** Fold one provider-event payload ({ provider, eventType?, event }) into the turn's evidence. */
 export function recordProviderEvent(acc, payload = {}) {
   if (!acc || !payload || typeof payload !== 'object') return acc;
@@ -184,6 +258,7 @@ export function recordProviderEvent(acc, payload = {}) {
     if (event.type === 'assistant' || event.type === 'user') recordClaude(acc, event);
   } else if (payload.provider === 'codex') recordCodex(acc, event);
   else if (payload.provider === 'opencode') recordOpenCode(acc, payload.eventType || event.type, event);
+  else if (payload.provider === 'antigravity') recordAntigravity(acc, payload.eventType || event.sessionUpdate, event);
   return acc;
 }
 
@@ -203,6 +278,11 @@ export function evidenceSnapshot(acc) {
     if (use.name !== 'Bash') continue;
     commands.push({ order: use.order, command: clipLine(use.input.command, COMMAND_CLIP), exit: use.input.run_in_background ? 'background' : 'interrupted', output_tail: '' });
   }
+  // The same for an ACP command that never completed nor failed.
+  for (const call of acc.acpCalls?.values?.() || []) {
+    if (call.kind !== 'execute' || call.status === 'completed' || call.status === 'failed') continue;
+    commands.push({ order: call.order, command: clipLine(acpCommandOf(call) || call.title || 'command', COMMAND_CLIP), exit: 'interrupted', output_tail: '' });
+  }
   commands.sort((a, b) => a.order - b.order);
   results.sort((a, b) => a.order - b.order);
   const errors = results.filter((r) => r.is_error).slice(-SNAPSHOT_RESULTS);

package/neural-interface/lib/assistant-hidden-models.js

@@ -6,7 +6,8 @@
 // router, the dispatcher, the catalog (routing sheet, agent_catalog) and every
 // Assistant model menu leave them out. One denylist per provider, so new
 // models start enabled:
-//   claude-code, codex → ~/.synabun/data/assistant-hidden-models.json
+//   claude-code, codex,
+//   antigravity        → ~/.synabun/data/assistant-hidden-models.json
 //   opencode           → the Settings → OpenCode store (lib/opencode-hidden-models.js),
 //                        so both screens edit the same list
 // Matching (lib/assistant-catalog.js hiddenModelId): the id, or the row's
@@ -54,7 +55,7 @@ import { HIDDEN_MODELS_SYNC_TYPE as OPENCODE_SYNC_TYPE } from './opencode-hidden
 import { createWriterLock } from './rulesets/lock.js';
 
 export const ASSISTANT_HIDDEN_SYNC_TYPE = 'assistant:hidden-models-changed';
-export const OWN_PROVIDERS = Object.freeze(['claude-code', 'codex']);
+export const OWN_PROVIDERS = Object.freeze(['claude-code', 'codex', 'antigravity']);
 export const MAX_HIDDEN_PER_PROVIDER = 2000;
 /** How long a save waits for another process that is saving. */
 export const HIDDEN_LOCK_TIMEOUT_MS = 2000;
@@ -202,8 +203,9 @@ export function planHiddenPins({ ids = [], pins = {}, rows = [], source = null,
 }
 
 /**
- * The Claude Code / Codex store:
- * { version, updatedAt, providers: { 'claude-code': [], codex: [] }, pins: { 'claude-code': { [id]: pin }, codex: {} } }.
+ * The Claude Code / Codex / Antigravity store:
+ * { version, updatedAt, providers: { 'claude-code': [], codex: [], antigravity: [] }, pins: { 'claude-code': { [id]: pin }, codex: {}, antigravity: {} } }.
+ * (Antigravity rows are their own models: no alias, so nothing of theirs is ever pinned.)
  */
 export function createAssistantHiddenModelsStore({
   path, now = Date.now, log = () => {},
@@ -508,7 +510,7 @@ export function resolveHiddenModelId({ id, provider = null, action = 'hide', row
 }
 
 /**
- * GET   /  → { ok, providers: { 'claude-code': [], codex: [], opencode: [] }, pins }
+ * GET   /  → { ok, providers: { 'claude-code': [], codex: [], opencode: [], antigravity: [] }, pins }
  * PATCH /  { provider?, hide?: [], show?: [] } → the new lists plus what changed.
  *          A missing provider is inferred from the unfiltered catalog. Hiding an
  *          alias ("haiku") records the model it names at that moment (`pins`),