synabun 2.0.10 → 2.2.0

package/mcp-server/src/tools/leonardo-browser-tools.ts

@@ -1,291 +0,0 @@
-/**
- * Leonardo.ai Browser MCP tools.
- * 100% browser-based — all interaction happens via SynaBun's browser automation.
- * No API key required.
- *
- * Tools: leonardo_browser_navigate, leonardo_browser_generate, leonardo_browser_library, leonardo_browser_download, leonardo_browser_reference
- */
-
-import { z } from 'zod/v3';
-import * as ni from '../services/neural-interface.js';
-import { text } from './response.js';
-
-const tabIdField = z.string().optional().describe('Target a specific tab within the session. Auto-resolved from environment if omitted.');
-
-const LEO_BASE = 'https://app.leonardo.ai';
-
-// ── Helper ────────────────────────────────────────────────────
-
-async function wait(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-// ── Browser Navigate ──────────────────────────────────────────
-
-export const browserNavigateSchema = {
-  page: z.enum([
-    'home', 'library', 'image', 'video', 'upscaler',
-    'blueprints', 'flow-state', 'models',
-  ] as const).describe('Leonardo.ai page to navigate to.'),
-  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
-  tabId: tabIdField,
-};
-
-export const browserNavigateDescription =
-  'Navigate the browser to a specific Leonardo.ai page. Always use this as the first step before any browser-based generation.';
-
-export async function handleBrowserNavigate(args: { page: string; sessionId?: string; tabId?: string }) {
-  const resolved = await ni.resolveSession(args.sessionId, { url: LEO_BASE }, args.tabId, { platform: true });
-  if ('error' in resolved) return text('No browser session available. Open Leonardo.ai in the browser first using browser_navigate or the Apps menu.');
-
-  const paths: Record<string, string> = {
-    'home': '/',
-    'library': '/library',
-    'image': '/image-generation',
-    'video': '/image-generation/video',
-    'upscaler': '/universal-upscaler',
-    'blueprints': '/blueprints',
-    'flow-state': '/flow-state',
-    'models': '/models-training',
-  };
-
-  const path = paths[args.page] || '/';
-  const res = await ni.navigate(resolved.sessionId, `${LEO_BASE}${path}`, resolved.tabId);
-  if (res.error) return text(`Navigation failed: ${res.error}`);
-
-  // Wait for page to settle
-  await wait(3000);
-
-  return text(`Navigated to Leonardo.ai ${args.page} page (${LEO_BASE}${path}). Use browser_snapshot to see the current UI state.`);
-}
-
-// ── Browser Generate (full UI automation) ─────────────────────
-
-export const browserGenerateSchema = {
-  prompt: z.string().describe('The generation prompt to type into Leonardo.ai.'),
-  type: z.enum(['image', 'video'] as const).optional().describe('Generation type. Default: image.'),
-  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
-  tabId: tabIdField,
-};
-
-export const browserGenerateDescription =
-  'Fill the prompt field and click Generate on the current Leonardo.ai page. Set all other settings (model, style, dimensions, motion controls) BEFORE calling this — use browser_click, browser_fill, and browser_snapshot to configure the UI first. This tool only handles: navigate to correct page if needed → clear & fill prompt → click Generate.';
-
-export async function handleBrowserGenerate(args: {
-  prompt: string;
-  type?: string;
-  sessionId?: string;
-  tabId?: string;
-}) {
-  const resolved = await ni.resolveSession(args.sessionId, { url: LEO_BASE }, args.tabId, { platform: true });
-  if ('error' in resolved) return text('No browser session available. Open Leonardo.ai first.');
-
-  const genType = args.type || 'image';
-
-  // Check current URL — navigate only if not already on the right page
-  const snapshot = await ni.snapshot(resolved.sessionId, resolved.tabId);
-  const currentUrl = (snapshot as any)?.url || '';
-  const targetPath = genType === 'video' ? '/image-generation/video' : '/image-generation';
-
-  if (!currentUrl.includes(targetPath)) {
-    const navRes = await ni.navigate(resolved.sessionId, `${LEO_BASE}${targetPath}`, resolved.tabId);
-    if (navRes.error) return text(`Navigation failed: ${navRes.error}`);
-    await wait(3000);
-  }
-
-  // Clear and fill the prompt textbox
-  const fillRes = await ni.fill(resolved.sessionId, '[aria-label="Prompt"], textbox[name="Prompt"], textarea', args.prompt, undefined, resolved.tabId);
-  if (fillRes.error) return text(`Failed to fill prompt: ${fillRes.error}`);
-
-  await wait(500);
-
-  // Click the Generate button
-  const clickRes = await ni.click(resolved.sessionId, 'button[aria-label="Generate"], button:has-text("Generate")', undefined, resolved.tabId);
-  if (clickRes.error) return text(`Failed to click Generate: ${clickRes.error}`);
-
-  return text(`Generation started (${genType}).\n\nPrompt: "${args.prompt.substring(0, 120)}${args.prompt.length > 120 ? '...' : ''}"\n\nThe generation is processing in Leonardo.ai. Use browser_snapshot or browser_screenshot to check progress and see results. Results also appear in the library.`);
-}
-
-// ── Browser Library ───────────────────────────────────────────
-
-export const browserLibrarySchema = {
-  action: z.enum(['view', 'search'] as const).describe('Action: view (open library) or search (search for a term).'),
-  query: z.string().optional().describe('Search query (for search action).'),
-  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
-  tabId: tabIdField,
-};
-
-export const browserLibraryDescription =
-  'Open or search Leonardo.ai\'s library to view past generations. Use browser_snapshot after to see results.';
-
-export async function handleBrowserLibrary(args: { action: string; query?: string; sessionId?: string; tabId?: string }) {
-  const resolved = await ni.resolveSession(args.sessionId, { url: LEO_BASE }, args.tabId, { platform: true });
-  if ('error' in resolved) return text('No browser session available.');
-
-  const navRes = await ni.navigate(resolved.sessionId, `${LEO_BASE}/library`, resolved.tabId);
-  if (navRes.error) return text(`Navigation failed: ${navRes.error}`);
-
-  await wait(2000);
-
-  if (args.action === 'search' && args.query) {
-    const fillRes = await ni.fill(resolved.sessionId, 'input[placeholder*="Search" i]', args.query, undefined, resolved.tabId);
-    if (fillRes.error) return text(`Failed to search: ${fillRes.error}`);
-    await ni.pressKey(resolved.sessionId, 'Enter', resolved.tabId);
-    return text(`Searched Leonardo.ai library for: "${args.query}". Use browser_snapshot to see results.`);
-  }
-
-  return text('Leonardo.ai library opened. Use browser_snapshot to see recent generations.');
-}
-
-// ── Browser Download / Screenshot ─────────────────────────────
-
-export const browserDownloadSchema = {
-  action: z.enum(['screenshot'] as const).describe('Action: screenshot (capture current Leonardo.ai page state).'),
-  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
-  tabId: tabIdField,
-};
-
-export const browserDownloadDescription =
-  'Capture a screenshot of the current Leonardo.ai page. Use to verify generation results or UI state.';
-
-export async function handleBrowserDownload(args: { action: string; sessionId?: string; tabId?: string }) {
-  const resolved = await ni.resolveSession(args.sessionId, { url: LEO_BASE }, args.tabId, { platform: true });
-  if ('error' in resolved) return text('No browser session available.');
-
-  if (args.action === 'screenshot') {
-    const res = await ni.screenshot(resolved.sessionId, resolved.tabId);
-    if (res.error) return text(`Screenshot failed: ${res.error}`);
-    return text('Screenshot captured of the current Leonardo.ai page.');
-  }
-
-  return text(`Unknown action: ${args.action}`);
-}
-
-// ── Browser Reference (upload reference images) ──────────────
-
-export const browserReferenceSchema = {
-  type: z.enum([
-    'image_ref', 'style_ref', 'content_ref', 'character_ref',
-    'image_to_image', 'start_frame', 'end_frame',
-  ] as const).describe(
-    'Reference type. Image generation: image_ref, style_ref, content_ref, character_ref, image_to_image. ' +
-    'Video generation: start_frame, end_frame. Availability depends on the selected model — check the model advisor.',
-  ),
-  filePaths: z.array(z.string()).describe(
-    'Absolute file paths of images to upload as reference. Get paths from image_staged tool or from user-attached images.',
-  ),
-  autoClear: z.boolean().optional().describe(
-    'Auto-delete the source images from data/images/ after successful upload. Default: true.',
-  ),
-  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
-  tabId: tabIdField,
-};
-
-export const browserReferenceDescription =
-  'Upload reference image(s) to Leonardo.ai for guided generation. Supports image references, style/content/character references, ' +
-  'image-to-image, and video start/end frames. Must be called AFTER selecting a model (reference type availability is model-dependent) ' +
-  'and BEFORE calling leonardo_browser_generate. Uses browser automation to click the reference panel, upload the file(s), and confirm. ' +
-  'By default, auto-clears uploaded images from the SynaBun image store after success.';
-
-export async function handleBrowserReference(args: {
-  type: string;
-  filePaths: string[];
-  autoClear?: boolean;
-  sessionId?: string;
-  tabId?: string;
-}) {
-  const resolved = await ni.resolveSession(args.sessionId, { url: LEO_BASE }, args.tabId, { platform: true });
-  if ('error' in resolved) return text('No browser session available. Open Leonardo.ai first.');
-
-  const { type, filePaths, autoClear = true } = args;
-  const isVideo = type === 'start_frame' || type === 'end_frame';
-
-  // Step 1: Open the reference panel
-  let openResult: { error?: string };
-
-  if (isVideo) {
-    // Video: click "Add Image Guidance to generation" button
-    openResult = await ni.evaluate(resolved.sessionId, `(() => {
-      const btns = document.querySelectorAll('button');
-      for (const b of btns) {
-        if (b.textContent.includes('Image Guidance') || b.textContent.includes('Add Image')) {
-          b.click(); return 'opened';
-        }
-      }
-      return 'not found';
-    })()`, resolved.tabId);
-  } else {
-    // Image: click "Add elements" button
-    openResult = await ni.evaluate(resolved.sessionId, `(() => {
-      const btns = document.querySelectorAll('button');
-      for (const b of btns) {
-        if (b.textContent.includes('Add elements') || b.textContent.includes('Add Elements')) {
-          b.click(); return 'opened';
-        }
-      }
-      return 'not found';
-    })()`, resolved.tabId);
-  }
-
-  if (openResult.error) return text(`Failed to open reference panel: ${openResult.error}`);
-  await wait(1500);
-
-  // Step 2: For image references, click the specific reference type tab/button
-  if (!isVideo) {
-    const typeLabels: Record<string, string[]> = {
-      'image_ref': ['Image Reference', 'Image Ref', 'Image Input'],
-      'style_ref': ['Style Reference', 'Style Ref'],
-      'content_ref': ['Content Reference', 'Content Ref'],
-      'character_ref': ['Character Reference', 'Character Ref'],
-      'image_to_image': ['Image to Image', 'Img2Img'],
-    };
-
-    const labels = typeLabels[type] || [type];
-    const labelSearch = labels.map(l => `b.textContent.includes('${l}')`).join(' || ');
-
-    const selectResult = await ni.evaluate(resolved.sessionId, `(() => {
-      const btns = document.querySelectorAll('button, [role="tab"], [role="menuitem"]');
-      for (const b of btns) {
-        if (${labelSearch}) { b.click(); return 'selected'; }
-      }
-      return 'not found — use browser_snapshot to see available options';
-    })()`, resolved.tabId);
-
-    if (selectResult.error) return text(`Failed to select reference type: ${selectResult.error}. Use browser_snapshot to see the panel.`);
-    await wait(1000);
-  }
-
-  // Step 3: Find file input and upload
-  const uploadResult = await ni.upload(resolved.sessionId, 'input[type="file"]', filePaths, undefined, resolved.tabId);
-  if (uploadResult.error) {
-    // Fallback: try broader selector
-    const fallback = await ni.upload(resolved.sessionId, 'input[accept*="image"]', filePaths, undefined, resolved.tabId);
-    if (fallback.error) {
-      return text(
-        `Failed to upload reference image(s): ${uploadResult.error}. ` +
-        `The file input may not be visible yet — try browser_snapshot to inspect the panel, ` +
-        `then use browser_upload manually with the correct selector.`,
-      );
-    }
-  }
-
-  await wait(1000);
-
-  // Step 4: Auto-clear source images if requested
-  if (autoClear) {
-    const { basename } = await import('path');
-    for (const fp of filePaths) {
-      const filename = basename(fp);
-      try {
-        await ni.deleteImage(filename);
-      } catch { /* ignore cleanup errors */ }
-    }
-  }
-
-  const typeLabel = type.replace(/_/g, ' ');
-  return text(
-    `Reference uploaded (${typeLabel}): ${filePaths.length} image(s).\n` +
-    `${autoClear ? 'Source images auto-cleared from store.\n' : ''}` +
-    `Use browser_snapshot to verify the reference is applied, then proceed with leonardo_browser_generate.`,
-  );
-}

package/mcp-server/src/tools/leonardo.ts

@@ -1,30 +0,0 @@
-/**
- * Leonardo.ai MCP tool registration barrel.
- * 100% browser-based — no API key required.
- * Registers 4 Leonardo browser tools on the given server instance.
- */
-
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-
-import {
-  browserNavigateSchema, browserNavigateDescription, handleBrowserNavigate,
-  browserGenerateSchema, browserGenerateDescription, handleBrowserGenerate,
-  browserLibrarySchema, browserLibraryDescription, handleBrowserLibrary,
-  browserDownloadSchema, browserDownloadDescription, handleBrowserDownload,
-  browserReferenceSchema, browserReferenceDescription, handleBrowserReference,
-} from './leonardo-browser-tools.js';
-
-/**
- * Register all Leonardo.ai MCP tools on the given server instance.
- * These are browser-based tools that automate the Leonardo.ai web UI.
- * Use the /leonardo skill for the full guided creation experience.
- */
-export function registerLeonardoTools(server: McpServer) {
-  return [
-    server.tool('leonardo_browser_navigate', browserNavigateDescription, browserNavigateSchema, handleBrowserNavigate),
-    server.tool('leonardo_browser_generate', browserGenerateDescription, browserGenerateSchema, handleBrowserGenerate),
-    server.tool('leonardo_browser_library', browserLibraryDescription, browserLibrarySchema, handleBrowserLibrary),
-    server.tool('leonardo_browser_download', browserDownloadDescription, browserDownloadSchema, handleBrowserDownload),
-    server.tool('leonardo_browser_reference', browserReferenceDescription, browserReferenceSchema, handleBrowserReference),
-  ];
-}

package/mcp-server/src/tools/profile.ts

@@ -1,122 +0,0 @@
-import { z } from 'zod/v3';
-import { text } from './response.js';
-import { VALID_GROUPS, getProfilePresets, persistRuntimeProfile, type ProfileRuntime } from '../services/profiles.js';
-import { reportRuntimeMcpProfile, type RuntimeMcpProfileReport } from '../services/neural-interface.js';
-
-export const profileSchema = {
-  action: z.enum(['get', 'set']).describe(
-    'get = inspect this runtime and its available presets. set = switch only this runtime to another profile and refresh the host tool list.'
-  ),
-  profile: z.string().optional().describe(
-    'Profile to switch to (required for "set"). Call get for current presets, choose the narrowest one that supplies the needed tools, or pass valid comma-separated groups.'
-  ),
-};
-
-export const profileDescription =
-  'Always-available MCP capability router. If a task needs a tool that is not currently listed, call action="get", then action="set" with the narrowest suitable profile and continue after the host refreshes its tools. Codex advertises the complete SynaBun catalog as deferred tools from turn start, so its profile is a focus selection and needs no reload. Do not claim a SynaBun capability is unavailable before trying this. A switch affects only the current sidepanel/loop/schedule runtime and never changes other sessions or the future-session default.';
-
-const ALWAYS_ON_TOOL_COUNT = 11;
-const GROUP_TOOL_ESTIMATES: Record<string, number> = {
-  git: 1,
-  image: 1,
-  whiteboard: 3,
-  card: 4,
-  tictactoe: 2,
-  browser: 20,
-  browser_twitter: 1,
-  browser_facebook: 1,
-  browser_tiktok: 4,
-  browser_whatsapp: 2,
-  browser_instagram: 5,
-  browser_linkedin: 8,
-  browser_bluesky: 15,
-  leonardo: 5,
-  discord: 8,
-  gsc: 30,
-  youtube: 11,
-  styleguide: 1,
-  morelogin: 1,
-  agents: 11,
-  computer: 4,
-};
-
-export async function handleProfile(runtime: ProfileRuntime, args: { action: string; profile?: string }) {
-  if (args.action === 'get') {
-    const { profile, activeGroups } = runtime.getActiveProfile();
-    const presets = Object.entries(getProfilePresets()).map(([name, groups]) => ({
-      name,
-      groups,
-      toolEstimate: `~${ALWAYS_ON_TOOL_COUNT + groups.reduce((sum, group) => sum + (GROUP_TOOL_ESTIMATES[group] || 0), 0)}`,
-    }));
-    return text(JSON.stringify({
-      currentProfile: profile,
-      activeGroups,
-      catalogMode: runtime.getCatalogMode(),
-      // Role-gated groups (agents) follow the role, not the profile.
-      role: runtime.getRole(),
-      presets,
-      validGroups: Array.from(VALID_GROUPS),
-    }, null, 2));
-  }
-
-  if (args.action === 'set') {
-    if (!args.profile) {
-      return text('Error: "profile" parameter is required for action "set". Call action="get" for the available presets or use valid comma-separated groups.');
-    }
-    let result;
-    try {
-      result = runtime.applyProfile(args.profile);
-    } catch (err) {
-      return text(`Error: ${err instanceof Error ? err.message : String(err)}. Call action="get" for valid presets and groups.`);
-    }
-    const runtimeStatePersisted = persistRuntimeProfile(result.profile);
-    const runtimeReport: RuntimeMcpProfileReport = await reportRuntimeMcpProfile(result.profile, {
-      catalogMode: result.catalogMode,
-    });
-    let hostRefresh: 'scheduled' | 'notification' | 'unavailable' | 'not-needed' = 'not-needed';
-    let toolListNotification: 'scheduled' | 'unavailable' | 'not-needed' = 'not-needed';
-    if (result.catalogMode === 'profiled') {
-      // Always queue one post-response MCP notification. Managed sidepanels
-      // may also perform a host-level reconnect. Queue this even when the
-      // requested profile already matches so an explicit retry can repair a
-      // stale/lost host catalog instead of becoming a silent no-op.
-      const notificationScheduled = runtime.scheduleProfileChangedNotification();
-      toolListNotification = notificationScheduled ? 'scheduled' : 'unavailable';
-      hostRefresh = runtimeReport.hostRefresh === 'scheduled'
-        ? 'scheduled'
-        : notificationScheduled ? 'notification' : 'unavailable';
-    } else {
-      // Codex snapshots deferred MCP schemas at turn start, so its SynaBun
-      // process advertises the complete deferred catalog from the beginning.
-      // Changing the focus profile updates runtime/UI state only; no tool-list
-      // mutation or global MCP reload is needed.
-      hostRefresh = 'not-needed';
-    }
-    return text(JSON.stringify({
-      switched: true,
-      changed: result.changed,
-      profile: result.profile,
-      enabled: result.enabled,
-      disabled: result.disabled,
-      totalTools: result.totalTools,
-      scope: 'current-runtime',
-      catalogMode: result.catalogMode,
-      runtimeStatePersisted,
-      runtimeStateReported: runtimeReport.reported,
-      hostRefresh,
-      toolListNotification,
-      ...(runtimeReport.runtimeKind ? { runtimeKind: runtimeReport.runtimeKind } : {}),
-      ...(runtimeReport.correlationId ? { refreshCorrelationId: runtimeReport.correlationId } : {}),
-      ...(runtimeReport.error ? { refreshReportError: runtimeReport.error } : {}),
-      note: result.catalogMode === 'deferred'
-        ? 'The Codex focus profile changed. Its complete SynaBun catalog was already available through deferred tools, so no MCP reload was needed.'
-        : hostRefresh === 'not-needed'
-          ? 'This runtime already uses the requested profile.'
-          : hostRefresh === 'unavailable'
-            ? 'The runtime profile changed, but the host refresh could not be scheduled. Retry the switch or use the sidepanel selector.'
-            : 'The runtime profile changed. The host tool refresh is queued; continue with the newly loaded tools.',
-    }, null, 2));
-  }
-
-  return text(`Unknown action "${args.action}". Use "get" or "set".`);
-}

package/neural-interface/lib/assistant-brains/opencode-browser-policy.js

@@ -1,47 +0,0 @@
-// SynaBun — OpenCode plugin: the browser policy of an Assistant task run.
-// Loaded only by the isolated `opencode serve` of a worker the Assistant
-// dispatched (its config's `plugin` entry, added by withOpenCodeBrowserPolicy
-// from server.js setupOpencodeLoopConfig); loops, schedules and the OpenCode
-// sidepanel never load it. Before every tool call it asks
-// lib/browser-tool-policy.js here, with no server round trip. A refusal is
-// thrown as a plain Error: OpenCode records it as that tool's error and the
-// loop continues. Script paths resolve against the run's cwd (the plugin
-// options), else the serve's directory. A policy module that cannot load fails
-// closed: the failure is logged once, and bash, webfetch, websearch and every
-// tool that is not OpenCode's own or SynaBun's (another MCP server's, another
-// plugin's) are refused with that reason until the run ends. The default
-// export is the only export: OpenCode runs every function a plugin exports.
-
-// An absolute file URL: the policy loads from SynaBun's lib/ wherever OpenCode imports this file from.
-const POLICY_URL = new URL('../browser-tool-policy.js', import.meta.url).href;
-
-// OpenCode's own tools that run no command and fetch no page. bash, webfetch and
-// websearch are not here; any other name belongs to an MCP server or a plugin.
-const OWN_TOOLS = new Set([
-  'read', 'list', 'glob', 'grep', 'edit', 'write', 'patch', 'multiedit', 'apply_patch', 'todowrite', 'todoread',
-  'task', 'skill', 'lsp', 'codesearch', 'question', 'batch', 'invalid', 'plan_exit', 'plan_enter',
-]);
-
-export default async function SynabunBrowserPolicy(input = {}, options = {}) {
-  let policy = null;
-  let loadError = null;
-  try { policy = await import(POLICY_URL); } catch (error) { loadError = error; }
-  if (typeof policy?.browserToolDenial !== 'function') {
-    const why = loadError?.message || 'browserToolDenial is missing';
-    console.error(`[SynaBun] browser policy could not load from ${POLICY_URL} (${why}); refusing bash, webfetch, websearch and other servers' tools for this run`);
-    return {
-      'tool.execute.before': async (call) => {
-        const tool = String(call?.tool || '');
-        if (/^synabun_/i.test(tool) || OWN_TOOLS.has(tool.toLowerCase())) return;
-        throw new Error(`SynaBun browser policy: ${tool} was refused — SynaBun's browser policy could not load (${why}), so no command, web tool or other server's tool can be checked for a browser launch. SynaBun's own tools (SynaBun_*) and file tools still work. Stop and report this.`);
-      },
-    };
-  }
-  const cwd = (typeof options?.cwd === 'string' && options.cwd) || (typeof input?.directory === 'string' && input.directory) || process.cwd();
-  return {
-    'tool.execute.before': async (call, output) => {
-      const reason = policy.browserToolDenial(String(call?.tool || ''), output?.args || {}, { host: 'opencode', cwd });
-      if (reason) throw new Error(reason);
-    },
-  };
-}

package/neural-interface/lib/assistant-brains/opencode-route-gate.js

@@ -1,62 +0,0 @@
-// SynaBun — OpenCode plugin for the Assistant's route gate.
-// Loaded only by the assistant brain's isolated `opencode serve` (its config's
-// `plugin` entry, written by patchOpenCodeAssistantConfig); the OpenCode
-// sidepanel never loads it. Before every tool call it asks the Neural
-// Interface whether the call may run (the route gate, and plan mode's
-// read-only policy on every session of this serve). A refusal is thrown as a plain Error:
-// OpenCode records it as that tool's error and the loop continues (only
-// permission/question rejections stop a turn). When the gate allows, the
-// user's own OpenCode permission rules apply exactly as before. The call's
-// whole arguments travel (the remote denylist reads paths from them), marked
-// inputComplete; arguments too big to send go as their command/action only.
-// Any failure (server unreachable, bad reply) allows the call — except with
-// `remote` (a WhatsApp session's serve), where a call SynaBun could not check
-// is refused.
-//
-// On load it says hello: until the Neural Interface hears it, it enforces the
-// gate reactively (interrupting a turn after an unrouted tool started), so a
-// plugin that never loads still leaves the brain gated. A WhatsApp session
-// runs no turn at all until the hello arrives.
-
-const MAX_INPUT_BYTES = 256 * 1024;
-const UNCHECKED = 'SynaBun could not check this call, so a WhatsApp session does not run it.';
-
-/** { input, inputComplete }: the whole arguments when small enough to send, else their command/action. */
-function callArguments(args) {
-  if (!args || typeof args !== 'object' || Array.isArray(args)) return { input: {}, inputComplete: false };
-  let size = Infinity;
-  try { size = JSON.stringify(args).length; } catch {}
-  if (size <= MAX_INPUT_BYTES) return { input: args, inputComplete: true };
-  const subset = {};
-  for (const key of ['command', 'action']) {
-    if (typeof args[key] === 'string' && args[key].length <= 64 * 1024) subset[key] = args[key];
-  }
-  return { input: subset, inputComplete: false };
-}
-
-export default async function SynabunRouteGate(_input, options = {}) {
-  const { url, session, token, remote = false } = options || {};
-  if (!url || !session || !token) return {};
-  const post = (body) => fetch(url, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ session, token, host: 'opencode', ...body }),
-    signal: AbortSignal.timeout(5000),
-  });
-  // Never blocks loading; a lost hello only keeps the reactive fallback on.
-  post({ hello: true }).catch(() => {});
-  return {
-    'tool.execute.before': async (input, output) => {
-      let decision = null;
-      try {
-        const response = await post({ tool: String(input?.tool || ''), providerSessionId: input?.sessionID || null, ...callArguments(output?.args) });
-        decision = await response.json();
-      } catch {
-        if (remote === true) throw new Error(UNCHECKED);
-        return;
-      }
-      if (decision && decision.allow === false) throw new Error(String(decision.reason || 'SynaBun route gate: call agent_route first.'));
-      if (remote === true && !(decision && decision.allow === true)) throw new Error(UNCHECKED);
-    },
-  };
-}