synabun 2.0.10 → 2.2.0

package/neural-interface/public/shared/ocp-v2/{ocp-v2-profile-inheritance.js → ocp-v2-tools-inheritance.js}

@@ -16,12 +16,12 @@ export function readOpenCodeSessionLink(event = {}) {
   };
 }
 
-export function bindOpenCodeChildSessionProfile({
+export function bindOpenCodeChildSessionTools({
   eventType,
   event,
   sourceRuntime,
   sessionToRuntime,
-  sessionProfiles,
+  sessionTools,
   runtimes,
 }) {
   if (!CHILD_LINK_EVENT_TYPES.has(eventType)) return { bound: false, reason: 'event-type' };
@@ -41,10 +41,10 @@ export function bindOpenCodeChildSessionProfile({
     runtimes?.get(previousRuntimeId)?.sessions?.delete(childSessionId);
   }
 
-  const profile = sourceRuntime.mcpProfile || sessionProfiles?.get(parentSessionId) || null;
+  const tools = sourceRuntime.tools || sessionTools?.get(parentSessionId) || null;
   sessionToRuntime.set(childSessionId, sourceRuntimeId);
-  if (profile) sessionProfiles.set(childSessionId, profile);
-  else sessionProfiles.delete(childSessionId);
+  if (tools) sessionTools.set(childSessionId, tools);
+  else sessionTools.delete(childSessionId);
   sourceRuntime.sessions?.add(childSessionId);
 
   return {
@@ -52,27 +52,27 @@ export function bindOpenCodeChildSessionProfile({
     childSessionId,
     parentSessionId,
     runtimeId: sourceRuntimeId,
-    profile,
+    tools,
   };
 }
 
 /**
- * The MCP profile a sub-agent panel starts with: its parent's. The primary
+ * The MCP tools a sub-agent panel starts with: its parent's. The primary
  * panel's store speaks for the parent only while it is bound to that parent
- * (`parentSessionId`): after a switch its profile is another session's, and
- * then the parent's saved choice (`savedProfile(parentSessionId)`) or what the
+ * (`parentSessionId`): after a switch its tools is another session's, and
+ * then the parent's saved choice (`savedTools(parentSessionId)`) or what the
  * child session itself carries is used. Without `parentSessionId` the parent
  * store is trusted as before.
  */
-export function inheritChildPanelMcpProfile(childStore, parentStore, childInfo = null, { parentSessionId, savedProfile } = {}) {
+export function inheritChildPanelTools(childStore, parentStore, childInfo = null, { parentSessionId, savedTools } = {}) {
   const parentState = parentStore?.getState?.() || null;
   const parentIsBound = !parentSessionId || parentState?.sessionId === parentSessionId;
-  const parentProfile = parentIsBound ? (parentState?.mcpProfile || null) : null;
+  const parentTools = parentIsBound ? (parentState?.tools || null) : null;
   let saved = null;
-  if (!parentProfile && parentSessionId && typeof savedProfile === 'function') {
-    try { saved = savedProfile(parentSessionId) || null; } catch { saved = null; }
+  if (!parentTools && parentSessionId && typeof savedTools === 'function') {
+    try { saved = savedTools(parentSessionId) || null; } catch { saved = null; }
   }
-  const profile = parentProfile || saved || childInfo?.mcpProfile || null;
-  if (profile) childStore?.setMcpProfile?.(profile);
-  return profile;
+  const tools = parentTools || saved || childInfo?.tools || null;
+  if (tools) childStore?.setTools?.(tools);
+  return tools;
 }

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

@@ -1,3 +1,5 @@
+import { t } from '../i18n.js';
+import { answerWorkerQuestion } from '../worker-questions.js';
 // ─────────────────────────────────────────────────────────────────────────────
 // OpenCode V2 — WebSocket client (multi-panel)
 // One WS connection serves every OCP v2 panel on the page. Panels register a
@@ -6,6 +8,7 @@
 // listeners (used by the panel manager to spawn child panels).
 // ─────────────────────────────────────────────────────────────────────────────
 
+import { createOutcomeNotifications } from './ocp-v2-outcome-notifications.js';
 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';
@@ -20,24 +23,19 @@ import { createAskTracker, createTurnClock, readOpenAsks, unreadAsksNotice, TURN
 // 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
+const _outcomes = createOutcomeNotifications();
 
 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();
+  // A sub-agent finishing is an intermediate step of its parent's task, not
+  // news on its own: ensureChildSpawn gives every Task/subagent call its own
+  // panel and store, so without this a multi-step turn popped one "done" per
+  // sub-agent plus one for the task itself. Its own errors still surface —
+  // those need attention wherever they happen.
+  if (type !== NOTIF_TYPE.ERROR && s.parentSessionId) return;
+  if (!_outcomes.take(s, type === NOTIF_TYPE.ERROR ? 'error' : 'done')) return;
   const baseLabel = s.sessionInfo?.title || s.sessionInfo?.info?.title || 'OpenCode';
   const label = s.parentSessionId ? `↳ ${baseLabel}` : baseLabel;
   try {
@@ -45,18 +43,6 @@ function _fireOutcomeNotify(store, type) {
   } 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;
@@ -146,7 +132,7 @@ function broadcastServerStatus(payload) {
 }
 
 // Why OpenCode cannot be used, as the server says it (an OpenCode version
-// SynaBun does not speak, a port held by an OpenCode 2 server it did not start,
+// SynaBun does not drive, a port held by an OpenCode server it did not start,
 // a web page where the API should be): one line in each panel's error list,
 // never a second copy of the same sentence while the panel keeps retrying.
 function broadcastServerProblem(text) {
@@ -173,7 +159,6 @@ export function disconnect() {
 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); };
@@ -252,7 +237,6 @@ function handleMessage(msg) {
     p.timeout.cancel();
     if (msg.type === 'init:result') {
       capabilities.set(msg.capabilities);
-      if (typeof msg.sdkVersion === 'string') _sdkVersion = msg.sdkVersion;
       if (msg.ready === false && msg.problem) broadcastServerProblem(msg.problem);
       asksReady();
     }
@@ -382,7 +366,7 @@ export function isKnownDescendantSession(sessionId, ancestorId) {
 // ── What waits on the user, read from the server ───────────────────────────
 // The stream says what is asked and answered while the socket is up. What was asked before (the page loaded,
 // a panel was bound to another session, the socket was down) is read from the server (permission:list and
-// question:list, on OpenCode 1 and 2 alike), one session at a time: its clocks wait until then. After a
+// question:list), one session at a time: its clocks wait until then. After a
 // reconnect every bound session is read again (rebuildAsks). A list that cannot be read is read again a few
 // times; then the session's clocks count again and its panel says so (noteUnreadAsks).
 
@@ -651,6 +635,41 @@ function request(payload, timeoutMs = 30000, { turnOf = '' } = {}) {
   });
 }
 
+const workerQuestionRuns = new Map();
+export const hasWorkerQuestions = (sessionId) => workerQuestionRuns.has(sessionId);
+export const forgetWorkerQuestions = (sessionId) => workerQuestionRuns.delete(sessionId);
+const workerQuestions = (run) => (run?.pending || []).filter((p) => p.kind === 'question').map((p) => ({ ...p.input, id: p.protocol?.id, sessionID: run.providerSessionId, _workerRequestId: p.requestId }));
+
+export function syncOpenCodeWorkerQuestions(run) {
+  if (run.runMode !== 'task') return;
+  const sid = run.providerSessionId;
+  const previous = workerQuestions(workerQuestionRuns.get(sid));
+  workerQuestionRuns.set(sid, run);
+  const next = workerQuestions(run);
+  for (const req of previous) if (!next.some((n) => n.id === req.id)) _asks.note('question.replied', { id: req.id, sessionID: sid });
+  for (const req of next) _asks.note('question.asked', req);
+  for (const store of _storesBySession.get(sid) || []) {
+    for (const req of previous) if (!next.some((n) => n.id === req.id)) store.removePendingQuestion(req.id);
+    for (const req of next) store.addPendingQuestion(req);
+  }
+}
+
+async function answerOpenCodeWorker({ sessionId, requestId, answers }, reject = false) {
+  let run = workerQuestionRuns.get(sessionId);
+  let pending = workerQuestions(run).find((q) => q.id === requestId);
+  // An SSE question can precede the run update. Read the authoritative pending request before answering.
+  if (!pending) {
+    const res = await fetch(`/api/assistant/runs/${encodeURIComponent(run.runId)}`);
+    if (!res.ok) throw new Error(t('workerQuestion.deliveryFailed'));
+    const body = await res.json();
+    if (!body.run) throw new Error(t('workerQuestion.deliveryFailed'));
+    run = body.run; pending = workerQuestions(run).find((q) => q.id === requestId);
+  }
+  if (pending) await answerWorkerQuestion(run.runId, pending._workerRequestId, { decision: reject ? 'deny' : 'answer', answers });
+  for (const store of _storesBySession.get(sessionId) || []) store.removePendingQuestion(requestId);
+  return { ok: true, data: true };
+}
+
 export const api = {
   init:           ()              => request({ type: 'init', windowId: nativeLoopWindowId }),
   // options: { search, archived, roots, limit }. A server without
@@ -663,17 +682,17 @@ export const api = {
   sessionMessages:(sessionId)     => request({ type: 'session:messages', sessionId }),
   sessionContext: ({ sessionId, cwd } = {}) => request({ type: 'session:context', sessionId, cwd }),
   // `human` / `greetingId`: lib/greeting/ (a server that does not know them ignores them).
-  send: ({ sessionId, parts, model, agent, mode, variant, cwd, mcpProfile, noAbortPrev, human, greetingId }) =>
-    request({ type: 'message:send', sessionId, parts, model, agent, mode, variant, cwd, mcpProfile, noAbortPrev: !!noAbortPrev, ...(human ? { human: true } : {}), ...(greetingId ? { greetingId } : {}) }, TURN_LIMIT_MS, { turnOf: sessionId }),
+  send: ({ sessionId, parts, model, agent, mode, variant, cwd, tools, noAbortPrev, human, greetingId }) =>
+    request({ type: 'message:send', sessionId, parts, model, agent, mode, variant, cwd, tools, noAbortPrev: !!noAbortPrev, ...(human ? { human: true } : {}), ...(greetingId ? { greetingId } : {}) }, TURN_LIMIT_MS, { turnOf: sessionId }),
   abort: (sessionId) => request({ type: 'message:abort', sessionId }),
-  compact: ({ sessionId, cwd, mcpProfile, model } = {}) => request({ type: 'session:compact', sessionId, cwd, mcpProfile, model }, 5 * 60 * 1000),
+  compact: ({ sessionId, cwd, tools } = {}) => request({ type: 'session:compact', sessionId, cwd, tools }, 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),
+  questionList:   ({ cwd, sessionId } = {})   => workerQuestionRuns.has(sessionId) ? Promise.resolve({ data: workerQuestions(workerQuestionRuns.get(sessionId)) }) : request({ type: 'question:list', cwd, sessionId }),
+  questionReply:  ({ requestId, answers, cwd, sessionId }) => workerQuestionRuns.has(sessionId) ? answerOpenCodeWorker({ requestId, answers, sessionId }) : request({ type: 'question:reply', requestId, answers, cwd, sessionId }),
+  questionReject: ({ requestId, sessionId })  => workerQuestionRuns.has(sessionId) ? answerOpenCodeWorker({ requestId, sessionId }, true) : request({ type: 'question:reject', requestId, sessionId }),
+  toolsGet:  (sessionId) => gated({ type: 'mcp:tools:get', sessionId }),
+  toolsSet:  (sessionId, tools) => gated({ type: 'mcp:tools:set', sessionId, tools }, 45_000),
 
   // ── Newer request types: sent only when the server lists them (see
   //    ocp-v2-caps.js); otherwise they resolve { ok:false, unsupported:true }.
@@ -684,16 +703,12 @@ export const api = {
   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 }, TURN_LIMIT_MS, { turnOf: sessionId }),
-  sessionShell:    ({ sessionId, command, agent, model, cwd, mcpProfile } = {}) =>
-    gated({ type: 'session:shell', sessionId, command, agent, model, cwd, mcpProfile }, 10 * 60 * 1000),
+  commandRun:      ({ sessionId, command, arguments: args, agent, model, variant, parts, cwd, tools } = {}) =>
+    gated({ type: 'command:run', sessionId, command, arguments: args, agent, model, variant, parts, cwd, tools }, TURN_LIMIT_MS, { turnOf: sessionId }),
+  sessionShell:    ({ sessionId, command, agent, model, cwd, tools } = {}) =>
+    gated({ type: 'session:shell', sessionId, command, agent, model, cwd, tools }, 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),
@@ -703,14 +718,9 @@ export const api = {
   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),

package/neural-interface/public/shared/page-session.js

@@ -0,0 +1,96 @@
+// ═══════════════════════════════════════════
+// SynaBun — the page secret's recovery: an open tab outlives a server restart
+// ═══════════════════════════════════════════
+//
+// The server tells the owner's own page from a local process by a secret it mints per boot and hands the page as
+// an HttpOnly cookie (lib/page-session.js). The page's code never sees or sends that cookie: the browser does. A
+// restart mints a new secret, and a tab that stayed open still carries the old cookie, so its first owner write
+// (a dispatch, Protect workers, a route card, a Skills Studio install…) would come back 403 UI_ONLY or
+// PAGE_SECRET_REQUIRED and the owner would have to reload. The owner wants zero friction, so this module wraps the
+// page's fetch once: when a same-origin write is refused with one of those two codes, it asks GET /api/page-session
+// (which sets this boot's cookie), then sends the very same request once more and hands back that answer. No
+// reload, no toast (the toast fires on the error jsonFetch throws, and it throws only on the final answer), no lost
+// action. Anything else (a read, another 403, a refusal the refresh did not cure, a body that cannot be sent
+// twice) is handed back as it came, so nothing changes for a request this is not about.
+//
+// No imports and nothing done at load under Node: tests load it with node --test and a fake fetch. In a browser it
+// installs itself on window.fetch when the page loads it (index.html, index2d.html and sidepanel-session.html load
+// it as their first module script, before any module that writes), and once only.
+
+/** The route that hands an open tab this boot's cookie (lib/page-session.js PAGE_SECRET_REFRESH_PATH). */
+export const PAGE_SECRET_REFRESH_PATH = '/api/page-session';
+/** The refusals that mean "the page secret is missing or stale", and nothing else. */
+export const PAGE_SECRET_CODES = Object.freeze(['UI_ONLY', 'PAGE_SECRET_REQUIRED']);
+const SAFE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+
+/** Whether an answer is the server refusing a write for want of this boot's page secret. */
+export function isPageSecretRefusal(status, body) {
+  return Number(status) === 403 && !!body && typeof body === 'object' && PAGE_SECRET_CODES.includes(body.code);
+}
+
+/**
+ * What a request is, for the retry: its method, whether it is same-origin, and the arguments that send it again,
+ * or null when it is not a write, goes elsewhere, or cannot be sent twice (a streamed body).
+ */
+export function replayPlan(input, init, origin = null) {
+  const isRequest = typeof Request !== 'undefined' && input instanceof Request;
+  const method = String(init?.method || (isRequest ? input.method : '') || 'GET').toUpperCase();
+  if (SAFE_METHODS.has(method)) return null;
+  const url = isRequest ? input.url : (input instanceof URL ? input.href : String(input ?? ''));
+  if (!sameOrigin(url, origin)) return null;
+  const body = init?.body;
+  if (body && typeof body === 'object' && typeof body.getReader === 'function') return null; // a stream is read once
+  // fetch(request) reads the request's body: a copy taken before the first send is what the second one sends.
+  const again = isRequest ? input.clone() : input;
+  return { method, url, args: init === undefined ? [again] : [again, init] };
+}
+
+function sameOrigin(url, origin) {
+  if (!/^[a-z][a-z0-9+.-]*:/i.test(url) && !url.startsWith('//')) return true; // a path of this page
+  if (!origin) return false;
+  try { return new URL(url).origin === new URL(origin).origin; } catch { return false; }
+}
+
+/**
+ * A fetch over `fetchImpl` that recovers the page secret once: the refresh is one request at a time (writes refused
+ * together share it), the refused request is sent again only when the refresh answered, and the second answer is
+ * final whatever it says.
+ */
+export function createPageSessionFetch(fetchImpl, { refreshPath = PAGE_SECRET_REFRESH_PATH, origin = null, onRecover = null } = {}) {
+  if (typeof fetchImpl !== 'function') throw new TypeError('createPageSessionFetch needs a fetch');
+  let refreshing = null;
+  function refreshCookie() {
+    if (!refreshing) {
+      refreshing = (async () => {
+        try {
+          const res = await fetchImpl(refreshPath, { method: 'GET', credentials: 'same-origin', cache: 'no-store', headers: { Accept: 'application/json' } });
+          return !!res && res.ok === true;
+        } catch { return false; } finally { refreshing = null; }
+      })();
+    }
+    return refreshing;
+  }
+  return async function pageSessionFetch(input, init) {
+    const plan = replayPlan(input, init, origin);
+    const res = await fetchImpl(input, init);
+    if (!plan || !res || res.status !== 403 || typeof res.clone !== 'function') return res;
+    let body = null;
+    try { body = await res.clone().json(); } catch { return res; }
+    if (!isPageSecretRefusal(res.status, body)) return res;
+    if (!(await refreshCookie())) return res;
+    try { onRecover?.({ method: plan.method, url: plan.url, code: body.code }); } catch { /* a listener's own error */ }
+    return fetchImpl(...plan.args);
+  };
+}
+
+/** Wrap `target.fetch` (the window's) once; returns true when it did, false when it already had or there is none. */
+export function installPageSessionRecovery(target = globalThis) {
+  if (!target || typeof target.fetch !== 'function' || target.__synabunPageSession) return false;
+  const original = target.fetch.bind(target);
+  const origin = target.location && typeof target.location.origin === 'string' ? target.location.origin : null;
+  target.fetch = createPageSessionFetch(original, { origin });
+  try { Object.defineProperty(target, '__synabunPageSession', { value: true, configurable: true }); } catch { target.__synabunPageSession = true; }
+  return true;
+}
+
+if (typeof window !== 'undefined' && typeof document !== 'undefined') installPageSessionRecovery(window);

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

@@ -4,7 +4,9 @@
 
 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>';
+// A line drawing: its paths carry fill="none" themselves, because some places fill every icon they hold
+// (`.resume-provider-icon svg { fill: currentColor }`), which would turn the strokes into a solid triangle.
+const SVG_ANTIGRAVITY = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M4.5 20 12 4l7.5 16" fill="none"/><path d="M8.2 20a3.8 3.8 0 0 1 7.6 0" fill="none"/></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>';
@@ -15,7 +17,7 @@ const PROVIDER_META = {
   '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' },
+  antigravity:   { id: 'antigravity', label: 'Antigravity', shortLabel: 'Antigravity', icon: SVG_ANTIGRAVITY, 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' },

package/neural-interface/public/shared/registry.js

@@ -5,8 +5,10 @@
 // Each variant (3D / 2D) registers its identity, capabilities, and UI
 // extensions on boot. Shared UI reads the registry to decide what to render.
 
+import { resolveViewVariant } from './view-variant.js';
+
 const _registry = {
-  variant: null,            // '3d' | '2d' | future variants
+  variant: resolveViewVariant(), // 3D only; the 2D implementation is deprecated
   capabilities: new Set(),  // e.g. 'camera-hud', 'minimap', 'hulls', 'lasso', 'controls-panel'
   navbarButtons: [],        // { zone, order, html, init }  (legacy, kept for compat)
   menuItems: [],            // { menu, order, type, id, label, shortcut?, init }
@@ -23,7 +25,7 @@ const _registry = {
  * @param {{ variant: string, capabilities?: string[] }} config
  */
 export function registerVariant(config) {
-  _registry.variant = config.variant;
+  _registry.variant = resolveViewVariant(config.variant);
   _registry.capabilities = new Set(config.capabilities || []);
 }
 
@@ -72,7 +74,7 @@ export function registerKeyboardShortcut(spec) {
 
 // ── Query API ──
 
-export function getVariant() { return _registry.variant; }
+export function getVariant() { return resolveViewVariant(_registry.variant); }
 export function hasCapability(name) { return _registry.capabilities.has(name); }
 export function getNavbarButtons() { return _registry.navbarButtons; }
 export function getMenuItems() { return _registry.menuItems; }

package/neural-interface/public/shared/retired-2d.js

@@ -0,0 +1,3 @@
+// Deprecated 2D page: static hosts also resolve old bookmarks to the supported 3D page.
+import { normalizeViewUrl } from './view-variant.js';
+window.location.replace(normalizeViewUrl(window.location.href));