synabun 1.3.0 → 2.0.0-beta

package/neural-interface/public/shared/ocp-v2/ocp-v2-ws.js

@@ -0,0 +1,545 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// OpenCode V2 — WebSocket client (multi-panel)
+// One WS connection serves every OCP v2 panel on the page. Panels register a
+// store via subscribeSession(sessionId, store) and receive only the events for
+// that session. session.created events fan out to subscribeSessionCreated()
+// listeners (used by the panel manager to spawn child panels).
+// ─────────────────────────────────────────────────────────────────────────────
+
+import { getDefaultStore } from './ocp-v2-state.js';
+import { notify as uiNotify, NOTIF_TYPE } from '../ui-notifications.js';
+import { nativeLoopWindowId } from '../ui-native-window-id.js';
+import { registerAutomationSession } from './ocp-v2-automation-ownership.js';
+import { applyEvent, resolveEventTargets } from './ocp-v2-events.js';
+import { createCapabilities, gatedRequest } from './ocp-v2-caps.js';
+import { shouldAutoAccept, autoAcceptRequest, autoAcceptInherited } from './ocp-v2-approvals.js';
+import { verifyDescendant, knownDescendant, createReconnectNotifier, requestOwner } from './ocp-v2-rehydrate.js';
+
+// Request types the connected server answers. Empty against a server that
+// predates the list; cleared on every disconnect and refilled on reconnect.
+export const capabilities = createCapabilities();
+export const supports = (...types) => capabilities.hasAll(...types);
+// The @opencode-ai/sdk version the server answered `init` with ('' from a
+// server that does not say).
+let _sdkVersion = '';
+export const sdkVersion = () => _sdkVersion;
+
+const _notifiedPermissionIds = new Set();
+// Per-store DONE/ERROR dedup: once an outcome fires for a turn, suppress
+// duplicates until the next time `running` flips back to true (new turn).
+// ERROR locks out future DONE; DONE allows a later ERROR through.
+const _outcomeKey = new WeakMap();        // store → NOTIF_TYPE.DONE | NOTIF_TYPE.ERROR
+const _outcomeSubscribed = new WeakSet(); // stores already wired for reset
+
+function _fireOutcomeNotify(store, type) {
+  const last = _outcomeKey.get(store);
+  if (last === type) return;
+  if (last === NOTIF_TYPE.ERROR && type === NOTIF_TYPE.DONE) return;
+  _outcomeKey.set(store, type);
+  const s = store.getState();
+  const baseLabel = s.sessionInfo?.title || s.sessionInfo?.info?.title || 'OpenCode';
+  const label = s.parentSessionId ? `↳ ${baseLabel}` : baseLabel;
+  try {
+    uiNotify('panel', type, label, { panel: 'opencode', provider: 'opencode' });
+  } catch (err) { console.warn('[ocp-v2-ws] outcome notify failed', err); }
+}
+
+function _ensureOutcomeReset(store) {
+  if (_outcomeSubscribed.has(store)) return;
+  _outcomeSubscribed.add(store);
+  try {
+    store.subscribe((event, state) => {
+      if (event?.type === 'running:set' && state.running) {
+        _outcomeKey.delete(store);
+      }
+    });
+  } catch (err) { console.warn('[ocp-v2-ws] outcome subscribe failed', err); }
+}
+
+let _ws = null;
+let _connecting = null;
+let _reqSeq = 0;
+const _pending = new Map();           // id → { resolve, reject, timeout }
+const _eventListeners = new Set();    // (eventType, event) => void  — raw fan-out
+
+const _storesBySession = new Map();   // sessionId → Set<store>
+const _allStores = new Set();         // every registered store (server:status broadcast)
+const _sessionCreatedListeners = new Set();
+// Buffer recent session.created events so a late-arriving subscriber (the
+// panel manager registers ONLY after boot() finishes — see ocp-v2-panel.js)
+// can still detect sub-agent spawns that fired before it was ready. Without
+// this buffer, a child OpenCode session created during boot vanishes from
+// the listener fanout and the pill/panel never spawns.
+const _sessionCreatedBuffer = [];
+const SESSION_CREATED_BUFFER_MAX = 32;
+const SESSION_CREATED_BUFFER_TTL_MS = 60_000;
+
+function url() {
+  const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+  return `${proto}//${location.host}/ws/opencode-v2`;
+}
+
+export function isConnected() {
+  return _ws && _ws.readyState === WebSocket.OPEN;
+}
+
+export async function connect() {
+  if (isConnected()) return _ws;
+  if (_connecting) return _connecting;
+
+  _connecting = new Promise((resolve, reject) => {
+    const ws = new WebSocket(url());
+    _ws = ws;
+    let opened = false;
+
+    ws.addEventListener('open', () => {
+      opened = true;
+      console.log('[ocp-v2-ws] open');
+      try { ws.send(JSON.stringify({ type: 'identify', windowId: nativeLoopWindowId })); }
+      catch (err) { console.warn('[ocp-v2-ws] identify failed', err); }
+      _connecting = null;
+      _reconnects.opened();
+      resolve(ws);
+    });
+
+    ws.addEventListener('message', (ev) => {
+      let msg;
+      try { msg = JSON.parse(ev.data); } catch { return; }
+      handleMessage(msg);
+    });
+
+    ws.addEventListener('close', () => {
+      console.log('[ocp-v2-ws] close');
+      _ws = null;
+      _connecting = null;
+      capabilities.clear();
+      _reconnects.closed();
+      for (const [, p] of _pending) p.reject(new Error('websocket closed'));
+      _pending.clear();
+      broadcastServerStatus({ status: 'reconnecting' });
+      setTimeout(() => { connect().catch(() => {}); }, 1500);
+      if (!opened) reject(new Error('websocket failed to open'));
+    });
+
+    ws.addEventListener('error', (err) => {
+      console.warn('[ocp-v2-ws] error', err);
+      if (!opened) broadcastServerStatus({ status: 'error' });
+      if (!opened) {
+        _connecting = null;
+        reject(err);
+      }
+    });
+  });
+
+  return _connecting;
+}
+
+function broadcastServerStatus(payload) {
+  if (_allStores.size === 0) getDefaultStore().setServerStatus(payload);
+  for (const store of _allStores) store.setServerStatus(payload);
+}
+
+export function disconnect() {
+  if (_ws) {
+    try { _ws.close(); } catch {}
+    _ws = null;
+  }
+}
+
+// ── Per-panel registration ────────────────────────────────────────────────
+// Bind a store to a sessionId so subsequent events for that session mutate
+// only this store. Returns an unsubscribe.
+export function subscribeSession(sessionId, store) {
+  if (!store) return () => {};
+  _allStores.add(store);
+  _ensureOutcomeReset(store);
+  if (!sessionId) {
+    // Not yet bound — caller should call again once a session exists.
+    return () => { _allStores.delete(store); };
+  }
+  let set = _storesBySession.get(sessionId);
+  if (!set) { set = new Set(); _storesBySession.set(sessionId, set); }
+  set.add(store);
+  return () => {
+    const s = _storesBySession.get(sessionId);
+    if (s) {
+      s.delete(store);
+      if (!s.size) _storesBySession.delete(sessionId);
+    }
+    _allStores.delete(store);
+  };
+}
+
+/** True when some panel is bound to this session. */
+export function hasSessionStore(sessionId) {
+  return !!_storesBySession.get(sessionId)?.size;
+}
+
+// session.created events — used by the panel manager to detect sub-agent
+// spawns (info.parentID points at the parent session). Newly attached
+// listeners replay the recent buffer so a late subscription still catches
+// child sessions that fired during boot.
+export function subscribeSessionCreated(cb) {
+  _sessionCreatedListeners.add(cb);
+  const now = Date.now();
+  for (const entry of _sessionCreatedBuffer) {
+    if (now - entry.ts > SESSION_CREATED_BUFFER_TTL_MS) continue;
+    try { cb(entry.event); } catch (e) { console.warn('[ocp-v2-ws] session.created replay listener error', e); }
+  }
+  return () => _sessionCreatedListeners.delete(cb);
+}
+
+function handleMessage(msg) {
+  if (msg.type === 'server:status') {
+    const payload = { status: msg.status, port: msg.port, version: msg.version, managed: msg.managed };
+    // Broadcast to every registered store; also poke the default singleton
+    // so legacy callers (no panel registered yet) still see status.
+    broadcastServerStatus(payload);
+    return;
+  }
+
+  if (msg.type === 'providers:changed') {
+    document.dispatchEvent(new CustomEvent('ocp-providers-changed'));
+    return;
+  }
+
+  if (msg.type === 'capabilities') {
+    capabilities.set(msg.capabilities);
+    _reconnects.capabilities();
+    return;
+  }
+
+  if (msg.type === 'event') {
+    // Native OpenCode runs travel over a different WebSocket than the run
+    // router. Register ownership before any child-session listener runs so a
+    // fast Task spawn cannot flash a child panel during the attach race.
+    if (msg.nativeRunId && msg.nativeRootSessionId) {
+      registerAutomationSession(msg.nativeRootSessionId, msg.nativeRunId);
+    }
+    handleEvent(msg.eventType, msg.event || {});
+    fanout(msg.eventType, msg.event || {});
+    return;
+  }
+
+  if (msg.id != null && _pending.has(msg.id)) {
+    const p = _pending.get(msg.id);
+    _pending.delete(msg.id);
+    clearTimeout(p.timeout);
+    if (msg.type === 'init:result') {
+      capabilities.set(msg.capabilities);
+      if (typeof msg.sdkVersion === 'string') _sdkVersion = msg.sdkVersion;
+    }
+    p.resolve(msg);
+    return;
+  }
+}
+
+function handleEvent(eventType, ev) {
+  // session.created → broadcast to manager listeners (child-panel spawning).
+  // Don't dispatch as a state mutation — the spawned panel's own subscribeSession
+  // call will catch its own subsequent message events.
+  if (eventType === 'session.created') {
+    rememberParent(ev);
+    _sessionCreatedBuffer.push({ ts: Date.now(), event: ev });
+    if (_sessionCreatedBuffer.length > SESSION_CREATED_BUFFER_MAX) {
+      _sessionCreatedBuffer.splice(0, _sessionCreatedBuffer.length - SESSION_CREATED_BUFFER_MAX);
+    }
+    for (const cb of _sessionCreatedListeners) {
+      try { cb(ev); } catch (e) { console.warn('[ocp-v2-ws] session.created listener error', e); }
+    }
+    return;
+  }
+
+  // session.updated can be the first event that carries a child's parentID.
+  if (eventType === 'session.updated') rememberParent(ev);
+  // (A request that is answered while it is being handed over: handOverRequests.)
+  if (ANSWERED.has(eventType)) noteAnswered(ev);
+
+  const targets = resolveEventTargets({
+    eventType, ev, storesBySession: _storesBySession, parentOf: _parentOf, allStores: _allStores,
+  });
+  for (const store of targets) applyEvent(store, eventType, ev, EVENT_HOOKS);
+}
+
+// child sessionID → parent sessionID, learned from session.created/updated.
+// Lets a sub-agent's permission or question reach the panel of its parent
+// when no child panel is open for it.
+const _parentOf = new Map();
+function rememberParent(ev) {
+  const info = ev?.info || ev?.session || ev || {};
+  const childId = info.id || ev?.sessionID || ev?.sessionId;
+  const parentId = info.parentID || info.parentId || info.parent_id || ev?.parentID || ev?.parentId;
+  if (childId && parentId && childId !== parentId) _parentOf.set(childId, parentId);
+}
+
+/**
+ * A parent link the server reported some other way than a session event: the
+ * children it listed for a session (the panel manager's scan after a reload).
+ * Not for a link that was only inferred (a task tool's part): such a link is
+ * read from the session itself when it is needed (isDescendantSession).
+ */
+export function rememberSessionParent(childId, parentId) {
+  const child = String(childId || '');
+  const parent = String(parentId || '');
+  if (child && parent && child !== parent) _parentOf.set(child, parent);
+}
+
+// The parent session of `sessionId` as far as the page knows it: the link the
+// server reported, else the one the panel on that session was made with.
+function parentSessionOf(sessionId) {
+  const known = _parentOf.get(sessionId);
+  if (known) return known;
+  for (const store of _storesBySession.get(sessionId) || []) {
+    const parent = store.getState().parentSessionId;
+    if (parent) return parent;
+  }
+  return '';
+}
+
+// Requests that were answered a moment ago (the newest 256 ids).
+const ANSWERED = new Set(['permission.replied', 'question.replied', 'question.rejected']);
+const _answered = new Set();
+function noteAnswered(ev) {
+  const id = String(ev?.requestID || ev?.id || ev?.permissionID || '');
+  if (!id) return;
+  _answered.delete(id);
+  _answered.add(id);
+  while (_answered.size > 256) _answered.delete(_answered.values().next().value);
+}
+
+// Roots: sessions the server said have no parent (saves asking again).
+const _rootSessions = new Set();
+
+/**
+ * Verified ancestry: is `sessionId` a sub-agent session (at any depth) of
+ * `ancestorId`? Known links come from session events; an unknown one is read
+ * from the session itself. Anything that cannot be established is false.
+ */
+export function isDescendantSession(sessionId, ancestorId) {
+  return verifyDescendant(sessionId, ancestorId, {
+    parentOf: _parentOf,
+    roots: _rootSessions,
+    fetchParent: async (id) => {
+      const res = await api.sessionGet(id);
+      if (!res || res.error || (typeof res.status === 'number' && res.status >= 400) || !res.data?.id) return null;
+      return String(res.data.parentID || res.data.parentId || '');
+    },
+  });
+}
+
+/**
+ * The same question answered from what is already known (session events and
+ * earlier verified lookups), without asking the server. For rendering: a card
+ * is drawn only for a request of the bound session or of a known sub-agent.
+ */
+export function isKnownDescendantSession(sessionId, ancestorId) {
+  return knownDescendant(sessionId, ancestorId, _parentOf);
+}
+
+// The socket came back after an outage: whatever was sent meanwhile reached no
+// panel. Listeners re-read their session (the primary panel does it through its
+// auto-heal; the panel manager does it for the sub-agent panel).
+const _reconnectListeners = new Set();
+const _reconnects = createReconnectNotifier(() => {
+  for (const fn of _reconnectListeners) {
+    try { fn(); } catch (e) { console.warn('[ocp-v2-ws] reconnect listener error', e); }
+  }
+});
+export function onReconnect(listener) {
+  _reconnectListeners.add(listener);
+  return () => _reconnectListeners.delete(listener);
+}
+
+// A sub-agent's panel follows the switch of the session that spawned it, up
+// the chain: a sub-agent of a sub-agent follows the session in the main panel.
+// The chain is the sessions' own (child → parent), not the panels that happen
+// to be open: a sub-agent whose parent's panel was closed still inherits.
+function autoAcceptEnabledFor(store) {
+  const s = store.getState();
+  if (s.autoAccept) return true;
+  return autoAcceptInherited(s.sessionId, {
+    parentOf: (sessionId) => (sessionId === s.sessionId && s.parentSessionId) || parentSessionOf(sessionId),
+    isOn: (sessionId) => [...(_storesBySession.get(sessionId) || [])].some((panel) => panel.getState().autoAccept === true),
+  });
+}
+
+function sessionLabel(store) {
+  const s = store.getState();
+  const baseLabel = s.sessionInfo?.title || s.sessionInfo?.info?.title || 'OpenCode';
+  return s.parentSessionId ? `↳ ${baseLabel}` : baseLabel;
+}
+
+const _compactedListeners = new Set();
+/** Called with the store after OpenCode compacted its session (transcript changed). */
+export function onSessionCompacted(listener) {
+  _compactedListeners.add(listener);
+  return () => _compactedListeners.delete(listener);
+}
+
+// What the reducer cannot do itself: desktop notifications and refetches.
+const EVENT_HOOKS = {
+  onOutcome(store, outcome) {
+    _fireOutcomeNotify(store, outcome === 'error' ? NOTIF_TYPE.ERROR : NOTIF_TYPE.DONE);
+  },
+  onAsk(store, id, kind, ev) {
+    if (!id || _notifiedPermissionIds.has(id)) return;
+    _notifiedPermissionIds.add(id);
+    // Auto-accept is the user's standing answer for this session: reply and
+    // stay quiet. A refused reply leaves the card up for them.
+    if (kind === 'permission' && shouldAutoAccept(autoAcceptEnabledFor(store), ev)) {
+      const s = store.getState();
+      // The label of the session that asked, read now: by the time the reply
+      // is back the store may show another session's title.
+      const label = sessionLabel(store);
+      autoAcceptRequest(store, api, ev, { cwd: s.cwd || s.sessionInfo?.directory || undefined, isDescendant: isDescendantSession })
+        .then((accepted) => { if (!accepted) notifyAsk(store, label); })
+        .catch((err) => console.warn('[ocp-v2-ws] auto-accept failed', err));
+      return;
+    }
+    notifyAsk(store);
+  },
+  onAskCleared(id) {
+    if (id) _notifiedPermissionIds.delete(id);
+  },
+  onCompacted(store) {
+    for (const fn of _compactedListeners) {
+      try { fn(store); } catch (e) { console.warn('[ocp-v2-ws] compacted listener error', e); }
+    }
+  },
+};
+
+function notifyAsk(store, label = sessionLabel(store)) {
+  try {
+    uiNotify('panel', NOTIF_TYPE.ASK, label, { panel: 'opencode', provider: 'opencode' });
+  } catch (err) { console.warn('[ocp-v2-ws] notify failed', err); }
+}
+
+/**
+ * A panel was closed while requests were waiting in it: its own, or those of
+ * sub-agents below it that have no panel. OpenCode still waits for an answer,
+ * so each goes, at once, where it would have gone had that panel never
+ * existed: to the nearest session above its own that has a panel
+ * (resolveEventTargets). Call it after the closed panel's store was
+ * unsubscribed.
+ * A request whose chain of parents is not known here (its sub-agent was
+ * announced by a task card only) has the chain read first, up to `within`
+ * (the session the main panel has as a tab), and is shown then, unless it was
+ * answered while that read was out.
+ * A request that was announced when it was raised is not announced again.
+ */
+export function handOverRequests(store, { within = '' } = {}) {
+  const s = store.getState();
+  const asks = [
+    ...(s.pendingPermissions || []).map((req) => ['permission.asked', req]),
+    ...(s.pendingQuestions || []).map((req) => ['question.asked', req]),
+  ];
+  for (const [eventType, held] of asks) {
+    // (`_auto`: a reply the closed panel sent is still out; refused, the card stays.)
+    const { _auto, ...req } = held || {};
+    const deliver = () => {
+      const targets = resolveEventTargets({ eventType, ev: req, storesBySession: _storesBySession, parentOf: _parentOf, allStores: _allStores });
+      for (const target of targets) applyEvent(target, eventType, req, EVENT_HOOKS);
+      return targets.length > 0;
+    };
+    if (deliver() || !within) continue;
+    isDescendantSession(requestOwner(req), within)
+      .then((known) => { if (known && !_answered.has(String(req.requestID || req.id || req.permissionID || ''))) deliver(); })
+      .catch((err) => console.warn('[ocp-v2-ws] handing over a closed panel\'s request failed', err));
+  }
+}
+
+// ── Public: subscribe to raw events (any session) ────────────────────────
+export function onEvent(listener) {
+  _eventListeners.add(listener);
+  return () => _eventListeners.delete(listener);
+}
+
+function fanout(eventType, ev) {
+  for (const fn of _eventListeners) {
+    try { fn(eventType, ev); } catch (e) { console.warn('[ocp-v2-ws] event listener error', e); }
+  }
+}
+
+// ── Request/response (id-correlated, 30s default timeout) ──
+
+function request(payload, timeoutMs = 30000) {
+  return new Promise(async (resolve, reject) => {
+    try { await connect(); } catch (e) { return reject(e); }
+    const id = ++_reqSeq;
+    const timeout = setTimeout(() => {
+      _pending.delete(id);
+      reject(new Error(`request timeout: ${payload.type}`));
+    }, timeoutMs);
+    _pending.set(id, { resolve, reject, timeout });
+    _ws.send(JSON.stringify({ ...payload, id }));
+  });
+}
+
+export const api = {
+  init:           ()              => request({ type: 'init', windowId: nativeLoopWindowId }),
+  // options: { search, archived, roots, limit }. A server without
+  // feature:session-list-filters ignores them and lists every live session.
+  sessionList:    (options)       => request(options ? { type: 'session:list', options } : { type: 'session:list' }),
+  sessionCreate:  (body, cwd)     => request({ type: 'session:create', body, cwd }),
+  sessionGet:     (sessionId)     => request({ type: 'session:get', sessionId }),
+  sessionUpdate:  (sessionId, body) => request({ type: 'session:update', sessionId, body }),
+  sessionDelete:  (sessionId)     => request({ type: 'session:delete', sessionId }),
+  sessionMessages:(sessionId)     => request({ type: 'session:messages', sessionId }),
+  sessionContext: ({ sessionId, cwd } = {}) => request({ type: 'session:context', sessionId, cwd }),
+  send: ({ sessionId, parts, model, agent, mode, variant, cwd, mcpProfile, noAbortPrev }) =>
+    request({ type: 'message:send', sessionId, parts, model, agent, mode, variant, cwd, mcpProfile, noAbortPrev: !!noAbortPrev }, 30 * 60 * 1000),
+  abort: (sessionId) => request({ type: 'message:abort', sessionId }),
+  compact: ({ sessionId, cwd, mcpProfile, model } = {}) => request({ type: 'session:compact', sessionId, cwd, mcpProfile, model }, 5 * 60 * 1000),
+  permissionReply: ({ sessionId, permissionId, response, cwd, message }) =>
+    request({ type: 'permission:reply', sessionId, permissionId, response, cwd, message }),
+  questionList:   ({ cwd, sessionId } = {})   => request({ type: 'question:list', cwd, sessionId }),
+  questionReply:  ({ requestId, answers, cwd, sessionId }) => request({ type: 'question:reply', requestId, answers, cwd, sessionId }),
+  questionReject: ({ requestId, sessionId })  => request({ type: 'question:reject', requestId, sessionId }),
+  mcpProfileGet:  (sessionId) => request({ type: 'mcp:profile:get', sessionId }),
+  mcpProfileSet:  (sessionId, profile) => request({ type: 'mcp:profile:set', sessionId, profile }, 45_000),
+
+  // ── Newer request types: sent only when the server lists them (see
+  //    ocp-v2-caps.js); otherwise they resolve { ok:false, unsupported:true }.
+  sessionStatus:  ({ sessionId, cwd } = {}) => gated({ type: 'session:status', sessionId, cwd }),
+  permissionList: ({ sessionId, cwd } = {}) => gated({ type: 'permission:list', sessionId, cwd }),
+  sessionTodo:    ({ sessionId, cwd } = {}) => gated({ type: 'session:todo', sessionId, cwd }),
+  sessionRevert:   ({ sessionId, messageID, partID, cwd } = {}) => gated({ type: 'session:revert', sessionId, messageID, partID, cwd }),
+  sessionUnrevert: ({ sessionId, cwd } = {}) => gated({ type: 'session:unrevert', sessionId, cwd }),
+  sessionFork:     ({ sessionId, messageID, cwd } = {}) => gated({ type: 'session:fork', sessionId, messageID, cwd }),
+  sessionChildren: ({ sessionId, cwd } = {}) => gated({ type: 'session:children', sessionId, cwd }),
+  sessionShare:    ({ sessionId, cwd } = {}) => gated({ type: 'session:share', sessionId, cwd }),
+  sessionUnshare:  ({ sessionId, cwd } = {}) => gated({ type: 'session:unshare', sessionId, cwd }),
+  sessionSharePolicy: ({ cwd } = {}) => gated({ type: 'session:share:policy', cwd }),
+  messageDelete:   ({ sessionId, messageID, cwd } = {}) => gated({ type: 'message:delete', sessionId, messageID, cwd }),
+  commandList:     ({ cwd } = {}) => gated({ type: 'command:list', cwd }),
+  // A command is a turn: it can run as long as a prompt does.
+  commandRun:      ({ sessionId, command, arguments: args, agent, model, variant, parts, cwd, mcpProfile } = {}) =>
+    gated({ type: 'command:run', sessionId, command, arguments: args, agent, model, variant, parts, cwd, mcpProfile }, 30 * 60 * 1000),
+  sessionShell:    ({ sessionId, command, agent, model, cwd, mcpProfile } = {}) =>
+    gated({ type: 'session:shell', sessionId, command, agent, model, cwd, mcpProfile }, 10 * 60 * 1000),
+  findFiles:       ({ query, cwd, dirs } = {}) => gated({ type: 'find:files', query, cwd, dirs }, 10000),
+  findSymbols:     ({ sessionId, query, cwd } = {}) => gated({ type: 'find:symbols', sessionId, query, cwd }, 10000),
+  resourceList:    ({ sessionId, cwd } = {}) => gated({ type: 'resource:list', sessionId, cwd }, 15000),
+  referenceList:   ({ sessionId, cwd } = {}) => gated({ type: 'reference:list', sessionId, cwd }, 15000),
+  agentList:       ({ cwd } = {}) => gated({ type: 'agent:list', cwd }, 15000),
+  sessionDiff:     ({ sessionId, messageID, cwd } = {}) => gated({ type: 'session:diff', sessionId, messageID, cwd }),
+  vcsGet:          ({ cwd } = {}) => gated({ type: 'vcs:get', cwd }),
+  vcsStatus:       ({ cwd } = {}) => gated({ type: 'vcs:status', cwd }),
+  vcsDiff:         ({ cwd, mode } = {}) => gated({ type: 'vcs:diff', cwd, mode }, 60_000),
+  worktreeList:    ({ cwd } = {}) => gated({ type: 'worktree:list', cwd }),
+  worktreeCreate:  ({ cwd, name } = {}) => gated({ type: 'worktree:create', cwd, name }, 60_000),
+  worktreeRemove:  ({ cwd, directory } = {}) => gated({ type: 'worktree:remove', cwd, directory }, 60_000),
+  mcpStatus:       ({ sessionId, cwd } = {}) => gated({ type: 'mcp:status', sessionId, cwd }),
+  mcpConnect:      ({ sessionId, name, cwd } = {}) => gated({ type: 'mcp:connect', sessionId, name, cwd }, 60_000),
+  mcpDisconnect:   ({ sessionId, name, cwd } = {}) => gated({ type: 'mcp:disconnect', sessionId, name, cwd }, 60_000),
+  // OAuth: OpenCode opens the browser and waits for the callback.
+  mcpAuthenticate: ({ sessionId, name, cwd } = {}) => gated({ type: 'mcp:authenticate', sessionId, name, cwd }, 5 * 60 * 1000 + 5000),
+  // Registers a server on the serve running this session and, with `persist`,
+  // saves it to the OpenCode config in the same request (see ocp-v2-status.js).
+  mcpAdd:          ({ sessionId, name, config, persist, cwd } = {}) => gated({ type: 'mcp:add', sessionId, name, config, persist: persist === true, cwd }, 60_000),
+  envStatus:       ({ sessionId, cwd } = {}) => gated({ type: 'env:status', sessionId, cwd }),
+};
+
+function gated(payload, timeoutMs) {
+  return gatedRequest(capabilities, request, payload, timeoutMs);
+}

package/neural-interface/public/shared/provider-icons.js

@@ -0,0 +1,30 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Shared Provider Icons
+// ═══════════════════════════════════════════
+
+const SVG_CLAUDE = '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M4.709 15.955l4.72-2.647.08-.23-.08-.128H9.2l-.79-.048-2.698-.073-2.339-.097-2.266-.122-.571-.121L0 11.784l.055-.352.48-.321.686.06 1.52.103 2.278.158 1.652.097 2.449.255h.389l.055-.157-.134-.098-.103-.097-2.358-1.596-2.552-1.688-1.336-.972-.724-.491-.364-.462-.158-1.008.656-.722.881.06.225.061.893.686 1.908 1.476 2.491 1.833.365.304.145-.103.019-.073-.164-.274-1.355-2.446-1.446-2.49-.644-1.032-.17-.619a2.97 2.97 0 01-.104-.729L6.283.134 6.696 0l.996.134.42.364.62 1.414 1.002 2.229 1.555 3.03.456.898.243.832.091.255h.158V9.01l.128-1.706.237-2.095.23-2.695.08-.76.376-.91.747-.492.584.28.48.685-.067.444-.286 1.851-.559 2.903-.364 1.942h.212l.243-.242.985-1.306 1.652-2.064.73-.82.85-.904.547-.431h1.033l.76 1.129-.34 1.166-1.064 1.347-.881 1.142-1.264 1.7-.79 1.36.073.11.188-.02 2.856-.606 1.543-.28 1.841-.315.833.388.091.395-.328.807-1.969.486-2.309.462-3.439.813-.042.03.049.061 1.549.146.662.036h1.622l3.02.225.79.522.474.638-.079.485-1.215.62-1.64-.389-3.829-.91-1.312-.329h-.182v.11l1.093 1.068 2.006 1.81 2.509 2.33.127.578-.322.455-.34-.049-2.205-1.657-.851-.747-1.926-1.62h-.128v.17l.444.649 2.345 3.521.122 1.08-.17.353-.608.213-.668-.122-1.374-1.925-1.415-2.167-1.143-1.943-.14.08-.674 7.254-.316.37-.729.28-.607-.461-.322-.747.322-1.476.389-1.924.315-1.53.286-1.9.17-.632-.012-.042-.14.018-1.434 1.967-2.18 2.945-1.726 1.845-.414.164-.717-.37.067-.662.401-.589 2.388-3.036 1.44-1.882.93-1.086-.006-.158h-.055L4.132 18.56l-1.13.146-.487-.456.061-.746.231-.243 1.908-1.312-.006.006z"/></svg>';
+const SVG_OPENAI = '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M9.205 8.658v-2.26c0-.19.072-.333.238-.428l4.543-2.616c.619-.357 1.356-.523 2.117-.523 2.854 0 4.662 2.212 4.662 4.566 0 .167 0 .357-.024.547l-4.71-2.759a.797.797 0 0 0-.856 0l-5.97 3.473zm10.609 8.8V12.06c0-.333-.143-.57-.429-.737l-5.97-3.473 1.95-1.118a.433.433 0 0 1 .476 0l4.543 2.617c1.309.76 2.189 2.378 2.189 3.948 0 1.808-1.07 3.473-2.76 4.163zM7.802 12.703l-1.95-1.142c-.167-.095-.239-.238-.239-.428V5.899c0-2.545 1.95-4.472 4.591-4.472 1 0 1.927.333 2.712.928L8.23 5.067c-.285.166-.428.404-.428.737v6.898zM12 15.128l-2.795-1.57v-3.33L12 8.658l2.795 1.57v3.33L12 15.128zm1.796 7.23c-1 0-1.927-.332-2.712-.927l4.686-2.712c.285-.166.428-.404.428-.737v-6.898l1.974 1.142c.167.095.238.238.238.428v5.233c0 2.545-1.974 4.472-4.614 4.472zm-5.637-5.303l-4.544-2.617c-1.308-.761-2.188-2.378-2.188-3.948A4.482 4.482 0 0 1 4.21 6.327v5.423c0 .333.143.571.428.738l5.947 3.449-1.95 1.118a.432.432 0 0 1-.476 0zm-.262 3.9c-2.688 0-4.662-2.021-4.662-4.519 0-.19.024-.38.047-.57l4.686 2.71c.286.167.571.167.856 0l5.97-3.448v2.26c0 .19-.07.333-.237.428l-4.543 2.616c-.619.357-1.356.523-2.117.523zm5.899 2.83a5.947 5.947 0 0 0 5.827-4.756C22.287 18.339 24 15.84 24 13.296c0-1.665-.713-3.282-1.998-4.448.119-.5.19-.999.19-1.498 0-3.401-2.759-5.947-5.946-5.947-.642 0-1.26.095-1.88.31A5.962 5.962 0 0 0 10.205 0a5.947 5.947 0 0 0-5.827 4.757C1.713 5.447 0 7.945 0 10.49c0 1.666.713 3.283 1.998 4.448-.119.5-.19 1-.19 1.499 0 3.401 2.759 5.946 5.946 5.946.642 0 1.26-.095 1.88-.309a5.96 5.96 0 0 0 4.162 1.713z"/></svg>';
+const SVG_GEMINI = '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 0 0-.975 0 14.134 14.134 0 0 1-3.679 6.452 14.155 14.155 0 0 1-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 0 0 0 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 0 1 4.45 3.001 14.112 14.112 0 0 1 3.679 6.453.502.502 0 0 0 .975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 0 1 3.001-4.45 14.113 14.113 0 0 1 6.453-3.678.503.503 0 0 0 0-.975 13.245 13.245 0 0 1-2.003-.678z"/></svg>';
+const SVG_OPENCODE = '<svg viewBox="0 0 240 300" fill="currentColor"><path fill-rule="evenodd" d="M0 0h240v300H0V0zm60 60v180h120V60H60z"/><rect x="60" y="120" width="120" height="120" opacity=".45"/></svg>';
+const SVG_SHELL = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="4 17 10 11 4 5"/><line x1="12" y1="19" x2="20" y2="19"/></svg>';
+const SVG_BROWSER = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="2" y1="12" x2="22" y2="12"/><path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"/></svg>';
+const SVG_SYNABUN = '<svg viewBox="0 0 24 24" fill="currentColor"><rect x="8" y="5.5" width="11" height="5" rx="2.5" transform="rotate(-12 13.5 8)"/><rect x="4.5" y="12.5" width="11" height="5" rx="2.5" transform="rotate(-12 10 15)"/></svg>';
+
+const PROVIDER_META = {
+  assistant:     { id: 'assistant',   label: 'Assistant',   shortLabel: 'Assistant', icon: SVG_SYNABUN, color: '#FFD23C' },
+  'claude-code': { id: 'claude-code', label: 'Claude Code', shortLabel: 'Claude', icon: SVG_CLAUDE, color: '#D4A27F' },
+  codex:         { id: 'codex',       label: 'Codex',       shortLabel: 'Codex',  icon: SVG_OPENAI, color: '#74C7A5' },
+  opencode:      { id: 'opencode',    label: 'OpenCode',    shortLabel: 'OpenCode', icon: SVG_OPENCODE, color: '#E8E0DC' },
+  gemini:        { id: 'gemini',      label: 'Gemini',      shortLabel: 'Gemini', icon: SVG_GEMINI, color: '#669DF6' },
+  synabun:      { id: 'synabun',    label: 'SynaBun',     shortLabel: 'SynaBun', icon: SVG_SYNABUN, color: '#FFD23C' },
+  shell:         { id: 'shell',       label: 'Shell',       shortLabel: 'Shell', icon: SVG_SHELL, color: '#AAAAAA' },
+  browser:       { id: 'browser',     label: 'Browser',     shortLabel: 'Browser', icon: SVG_BROWSER, color: '#4FC3F7' },
+};
+
+const FALLBACK_PROVIDER = PROVIDER_META['claude-code'];
+
+export function getProviderMeta(providerId = 'claude-code') {
+  return PROVIDER_META[providerId] || FALLBACK_PROVIDER;
+}
+
+export { PROVIDER_META };