synabun 1.3.0 → 2.0.0

package/neural-interface/public/shared/cdx/cdx-ws.js

@@ -0,0 +1,363 @@
+// SynaBun — Codex Panel: WebSocket Transport
+
+import { windowId } from './cdx-icons.js';
+import { codexSocketMessageRejectionReason } from './cdx-protocol.js';
+
+// ── Shared heartbeat; reconnect ownership lives on each tab ──
+let _heartbeatInterval = null;
+
+// ═══════════════════════════════════════════
+//  Reconnect Timer
+// ═══════════════════════════════════════════
+
+export function clearReconnectTimer(tab) {
+  if (tab?.reconnectTimer) {
+    clearTimeout(tab.reconnectTimer);
+    tab.reconnectTimer = null;
+  }
+}
+
+export function scheduleReconnect(tab, reconnectFn, delayMs = 1200) {
+  if (!tab || tab.reconnectTimer) return;
+  tab.reconnectTimer = setTimeout(() => {
+    tab.reconnectTimer = null;
+    reconnectFn();
+  }, delayMs);
+}
+
+// ═══════════════════════════════════════════
+//  Heartbeat
+// ═══════════════════════════════════════════
+
+export function startHeartbeat(tabs) {
+  if (_heartbeatInterval) return;
+  _heartbeatInterval = setInterval(() => {
+    for (const tab of tabs) {
+      if (tab.ws?.readyState === WebSocket.OPEN) {
+        tab.ws.send(JSON.stringify({
+          type: 'heartbeat',
+          windowId,
+          sessionId: tab.id,
+          connectionEpoch: tab.connectionEpoch,
+        }));
+      }
+    }
+  }, 15_000);
+}
+
+export function stopHeartbeat() {
+  if (_heartbeatInterval) { clearInterval(_heartbeatInterval); _heartbeatInterval = null; }
+}
+
+// ═══════════════════════════════════════════
+//  Disconnect
+// ═══════════════════════════════════════════
+
+function closeSocket(tab, ws, { intentional = true } = {}) {
+  if (!tab || !ws) return;
+  if (ws.__cxpReleaseTimer) {
+    clearTimeout(ws.__cxpReleaseTimer);
+    ws.__cxpReleaseTimer = null;
+  }
+  ws.__cxpReleasePending = false;
+  ws.__cxpReleasePreviousState = null;
+  if (intentional) ws.__cxpIntentionalClose = true;
+  tab.connected = false;
+  tab.bootstrapped = false;
+  tab.pendingReattach = false;
+  if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+    try { ws.close(); } catch {}
+    return;
+  }
+  if (tab.ws === ws) tab.ws = null;
+}
+
+export function disconnectTab(tab, { releaseWriter = true } = {}) {
+  if (!tab || tab.closed) return;
+  clearReconnectTimer(tab);
+  const ws = tab.ws;
+  if (!ws) {
+    tab.connected = false;
+    tab.bootstrapped = false;
+    tab.pendingReattach = false;
+    tab.ws = null;
+    return;
+  }
+  if (releaseWriter && ws.readyState === WebSocket.OPEN && !ws.__cxpReleasePending) {
+    try {
+      ws.send(JSON.stringify({
+        type: 'release',
+        windowId,
+        sessionId: tab.id,
+        connectionEpoch: tab.connectionEpoch,
+        threadId: tab.threadId || null,
+      }));
+      ws.__cxpReleasePreviousState = {
+        connected: !!tab.connected,
+        bootstrapped: !!tab.bootstrapped,
+      };
+      ws.__cxpReleasePending = true;
+      ws.__cxpReconnectAfterRelease = false;
+      tab.connected = false;
+      tab.bootstrapped = false;
+      ws.__cxpReleaseTimer = setTimeout(() => closeSocket(tab, ws), 1500);
+      return;
+    } catch {}
+  }
+  if (ws.__cxpReleasePending) {
+    ws.__cxpReconnectAfterRelease = false;
+    return;
+  }
+  closeSocket(tab, ws);
+}
+
+// ═══════════════════════════════════════════
+//  Send
+// ═══════════════════════════════════════════
+
+export function sendSocket(msg, ws) {
+  if (ws?.readyState !== WebSocket.OPEN || ws.__cxpReleasePending) return false;
+  ws.send(JSON.stringify(msg));
+  return true;
+}
+
+// ═══════════════════════════════════════════
+//  handleSocketMessage  (internal router)
+// ═══════════════════════════════════════════
+
+/**
+ * Routes an incoming WebSocket message to the appropriate callback.
+ *
+ * @param {object} msg        — parsed JSON message from the server
+ * @param {object} tab        — the tab this message belongs to
+ * @param {object} callbacks  — handler map provided by the caller:
+ *   onReattachResult(msg, tab)
+ *   onReady(msg, tab)
+ *   onThreadList(msg)
+ *   onThreadStarted(msg)
+ *   onThreadRenamed(msg)
+ *   onHistory(msg)
+ *   onThread(msg)
+ *   onTurn(msg)
+ *   onNotify(msg)
+ *   onServerRequest(msg)
+ *   onInterruptAck(msg)
+ *   onError(msg)
+ *   onModelList(msg)
+ *   onGenericResponse(msg)       — account_info, config_data, mcp_status, etc.
+ *   onThreadForked(msg)
+ *   onClosed(msg, tab, ws)
+ */
+function handleSocketMessage(msg, tab, callbacks) {
+  switch (msg.type) {
+    case 'reattach_result':
+      callbacks.onReattachResult?.(msg, tab);
+      break;
+    case 'ready':
+      callbacks.onReady?.(msg, tab);
+      break;
+    case 'thread_list':
+      callbacks.onThreadList?.(msg);
+      break;
+    case 'thread_started':
+      callbacks.onThreadStarted?.(msg);
+      break;
+    case 'thread_renamed':
+      callbacks.onThreadRenamed?.(msg);
+      break;
+    case 'history':
+      callbacks.onHistory?.(msg);
+      break;
+    case 'thread':
+      callbacks.onThread?.(msg);
+      break;
+    case 'turn':
+      callbacks.onTurn?.(msg);
+      break;
+    case 'notify':
+      callbacks.onNotify?.(msg);
+      break;
+    case 'server_request':
+      callbacks.onServerRequest?.(msg);
+      break;
+    case 'interrupt_ack':
+      callbacks.onInterruptAck?.(msg);
+      break;
+    case 'error':
+      callbacks.onError?.(msg);
+      break;
+    case 'model_list':
+      callbacks.onModelList?.(msg);
+      break;
+    case 'catalogs_changed':
+    case 'attachment_added':
+    case 'gateway_oauth_state':
+    case 'gateway_oauth_started':
+    case 'gateway_oauth_canceled':
+    case 'verification_status':
+    case 'verification_enrolled':
+    case 'verification_deleted':
+    case 'verification_verified':
+    case 'verification_canceled':
+    case 'account_info':
+    case 'account_login_started':
+    case 'account_logged_out':
+    case 'account_list':
+    case 'account_switched':
+    case 'account_add_started':
+    case 'account_removed':
+    case 'account_renamed':
+    case 'config_data':
+    case 'config_requirements':
+    case 'experimental_features':
+    case 'skills_list':
+    case 'app_list':
+    case 'plugin_list':
+    case 'thread_loaded_list':
+    case 'review_started':
+    case 'thread_rolled_back':
+    case 'background_cleaned':
+    case 'turn_steered':
+    case 'rate_limits':
+    case 'status_snapshot':
+    case 'mcp_status':
+    case 'mcp_profile_changed':
+    case 'config_saved':
+    case 'mcp_refreshed':
+    case 'mcp_oauth_done':
+    case 'mcp_approval_updated':
+    case 'codex_config_repaired':
+    case 'permission_roots':
+    case 'permission_root_removed':
+    case 'storage_health':
+    case 'server_request_response_result':
+      callbacks.onGenericResponse?.(msg);
+      break;
+    case 'thread_forked':
+    case 'thread_archived':
+    case 'thread_unarchived':
+      callbacks.onThreadForked?.(msg);
+      break;
+    case 'closed':
+      callbacks.onClosed?.(msg, tab);
+      break;
+    default:
+      if (msg.requestId != null || msg.type === 'capabilities') callbacks.onGenericResponse?.(msg);
+      break;
+  }
+}
+
+// ═══════════════════════════════════════════
+//  connectTab
+// ═══════════════════════════════════════════
+
+/**
+ * Opens a WebSocket for the given tab and wires up event handlers.
+ *
+ * @param {object}   tab           — tab object; ws/connected/bootstrapped/pendingReattach are set on it
+ * @param {object}   callbacks     — message handlers (same shape as handleSocketMessage expects),
+ *                                   plus lifecycle hooks:
+ *   onConnecting(tab)             — called immediately when connection starts
+ *   onOpen(tab, ws, { shouldReattach, wasConnected })
+ *   onClose(tab, ws, { intentional, reconnectAfterRelease })
+ *   onMessageError(err, raw)      — parse/handler error
+ *   ... all handleSocketMessage callbacks
+ * @param {object}   opts
+ * @param {Function} opts.withTab  — withTab(tab, fn) context‑switch helper from the monolith
+ */
+export function connectTab(tab, callbacks, opts = {}) {
+  if (!tab || tab.closed) return;
+  if (tab.ws && (tab.ws.readyState === WebSocket.OPEN || tab.ws.readyState === WebSocket.CONNECTING)) {
+    if (tab.ws.__cxpReleasePending) tab.ws.__cxpReconnectAfterRelease = true;
+    return;
+  }
+
+  const wasConnected = !!tab.connected;
+  const shouldReattach = !!tab.pendingReattach;
+  const withTab = opts.withTab || ((t, fn) => fn());
+
+  clearReconnectTimer(tab);
+
+  const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+  const ws = new WebSocket(`${proto}//${location.host}/ws/codex-skin`);
+  const connectionEpoch = crypto.randomUUID();
+
+  // Establish transport ownership before entering a bound-tab scope. The
+  // binder commits its module-local `_ws` value when that scope exits; if the
+  // socket is first assigned inside the scope, that stale value can overwrite
+  // tab.ws and make the socket reject its own open event as stale.
+  tab.ws = ws;
+  tab.connectionEpoch = connectionEpoch;
+  tab.connected = false;
+  tab.bootstrapped = false;
+
+  withTab(tab, () => {
+    callbacks.onConnecting?.(tab);
+  });
+
+  ws.onopen = () => {
+    if (tab.closed || tab.ws !== ws || tab.connectionEpoch !== connectionEpoch) return;
+    withTab(tab, () => {
+      tab.connected = true;
+      callbacks.onOpen?.(tab, ws, { shouldReattach, wasConnected });
+    });
+  };
+
+  ws.onmessage = (event) => {
+    try {
+      const msg = JSON.parse(event.data);
+      if (msg.type === 'release_ack' && ws.__cxpReleasePending
+        && String(msg.sessionId || '') === String(tab.id || '')
+        && String(msg.connectionEpoch || '') === String(connectionEpoch)) {
+        if (ws.__cxpReleaseTimer) {
+          clearTimeout(ws.__cxpReleaseTimer);
+          ws.__cxpReleaseTimer = null;
+        }
+        const previousState = ws.__cxpReleasePreviousState;
+        ws.__cxpReleasePending = false;
+        if (msg.accepted || tab.closed) {
+          closeSocket(tab, ws);
+        } else {
+          ws.__cxpReconnectAfterRelease = false;
+          ws.__cxpReleasePreviousState = null;
+          tab.connected = previousState?.connected ?? true;
+          tab.bootstrapped = previousState?.bootstrapped ?? true;
+          withTab(tab, () => callbacks.onReleaseRejected?.(tab, ws));
+        }
+        return;
+      }
+      if (tab.closed || tab.ws !== ws || tab.connectionEpoch !== connectionEpoch) {
+        callbacks.onIgnoredMessage?.(null, tab, 'stale_socket');
+        return;
+      }
+      const rejectionReason = codexSocketMessageRejectionReason(msg, tab);
+      if (rejectionReason) {
+        callbacks.onIgnoredMessage?.(msg, tab, rejectionReason);
+        return;
+      }
+      withTab(tab, () => handleSocketMessage(msg, tab, callbacks));
+    } catch (err) {
+      if (callbacks.onMessageError) {
+        callbacks.onMessageError(err, event.data?.slice?.(0, 200));
+      } else {
+        console.error('[cxp-ws] onmessage error:', err, 'raw:', event.data?.slice?.(0, 200));
+      }
+    }
+  };
+
+  ws.onclose = () => {
+    if (tab.ws !== ws || tab.connectionEpoch !== connectionEpoch) return;
+    withTab(tab, () => {
+      if (ws.__cxpReleaseTimer) {
+        clearTimeout(ws.__cxpReleaseTimer);
+        ws.__cxpReleaseTimer = null;
+      }
+      const intentional = !!ws.__cxpIntentionalClose || tab.closed;
+      const reconnectAfterRelease = !!ws.__cxpReconnectAfterRelease && !tab.closed;
+      tab.connected = false;
+      tab.bootstrapped = false;
+      if (tab._reattachTimer) { clearTimeout(tab._reattachTimer); tab._reattachTimer = null; }
+      callbacks.onClose?.(tab, ws, { intentional, reconnectAfterRelease });
+    });
+  };
+}

package/neural-interface/public/shared/cli-status.js

@@ -0,0 +1,169 @@
+// ═══════════════════════════════════════════
+// SynaBun — CLI Status (shared)
+// Detects whether Claude / Codex / OpenCode CLIs are installed by
+// querying /api/system/tool-versions. Caches the response, fans out
+// updates to subscribers, and auto-polls (every 30s) while at least
+// one subscribed tool reports installed=null.
+// ═══════════════════════════════════════════
+
+const TOOL_KEYS = ['claude-code', 'codex', 'opencode', 'gemini'];
+
+const CLI_DOC_URLS = {
+  'claude-code': 'https://docs.claude.com/en/docs/claude-code/setup',
+  'codex':       'https://developers.openai.com/codex/cli/',
+  'opencode':    'https://opencode.ai/docs/',
+  'gemini':      'https://github.com/google-gemini/gemini-cli',
+};
+
+// Fallback only. The server computes the channel-correct command (see
+// buildInstallCommand in lib/cli-update-planner.js) and returns it as
+// `installCommand`, so a Homebrew user is told `brew install --cask codex`
+// rather than an npm command that would create a second conflicting install.
+// These npm defaults apply only before the first tool-versions response.
+const CLI_INSTALL_CMDS = {
+  'claude-code': 'npm install -g @anthropic-ai/claude-code',
+  'codex':       'npm install -g @openai/codex',
+  'opencode':    'npm install -g opencode-ai',
+  'gemini':      'npm install -g @google/gemini-cli',
+};
+
+const CLI_LABELS = {
+  'claude-code': 'Claude Code',
+  'codex':       'Codex',
+  'opencode':    'OpenCode',
+  'gemini':      'Gemini CLI',
+};
+
+const POLL_INTERVAL_MS = 30000;
+const CACHE_TTL_MS = 10000;
+
+let _cache = { fetchedAt: 0, tools: null };
+let _inflight = null;
+const _subscribers = new Map();
+let _pollTimer = null;
+
+export function getCliDocUrl(toolKey) {
+  return CLI_DOC_URLS[toolKey] || null;
+}
+
+export function getCliInstallCommand(toolKey) {
+  return _cache.tools?.[toolKey]?.installCommand || CLI_INSTALL_CMDS[toolKey] || '';
+}
+
+export function getCliLabel(toolKey) {
+  return CLI_LABELS[toolKey] || toolKey;
+}
+
+async function _fetchToolVersions(force) {
+  if (!force && _cache.tools && (Date.now() - _cache.fetchedAt) < CACHE_TTL_MS) {
+    return _cache.tools;
+  }
+  if (_inflight) return _inflight;
+  const url = force ? '/api/system/tool-versions?force=1' : '/api/system/tool-versions';
+  _inflight = (async () => {
+    try {
+      const res = await fetch(url);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const data = await res.json();
+      _cache = { fetchedAt: Date.now(), tools: data?.tools || {} };
+      return _cache.tools;
+    } finally {
+      _inflight = null;
+    }
+  })();
+  return _inflight;
+}
+
+// `force` makes a deliberate re-check notify subscribers even when the
+// version string is unchanged. Without it the Re-check button was a no-op by
+// construction: a panel that latched a "CLI not installed" banner after a
+// spawn error could only clear the latch from this callback, but the version
+// had not changed, so the callback never fired and the banner was permanent.
+// The background poller deliberately keeps the change-only behaviour.
+function _emitChange(prevTools, nextTools, { force = false } = {}) {
+  for (const key of TOOL_KEYS) {
+    const prev = prevTools?.[key]?.installed ?? null;
+    const next = nextTools?.[key]?.installed ?? null;
+    const subs = _subscribers.get(key);
+    if (!subs || !subs.size) continue;
+    if (force || prev !== next || prevTools == null) {
+      const info = nextTools?.[key] || { installed: null };
+      for (const cb of subs) {
+        try { cb(info); } catch (e) { console.error('[cli-status] subscriber error:', e); }
+      }
+    }
+  }
+}
+
+function _hasMissingSubscribed() {
+  for (const key of _subscribers.keys()) {
+    const subs = _subscribers.get(key);
+    if (!subs?.size) continue;
+    const installed = _cache.tools?.[key]?.installed ?? null;
+    if (!installed) return true;
+  }
+  return false;
+}
+
+function _maybeStartPoller() {
+  if (_pollTimer) return;
+  if (!_hasMissingSubscribed()) return;
+  _pollTimer = setInterval(async () => {
+    if (document.hidden) return;
+    if (!_hasMissingSubscribed()) {
+      _stopPoller();
+      return;
+    }
+    const prev = _cache.tools;
+    try {
+      const next = await _fetchToolVersions(true);
+      _emitChange(prev, next);
+      if (!_hasMissingSubscribed()) _stopPoller();
+    } catch { /* ignore — retry next tick */ }
+  }, POLL_INTERVAL_MS);
+}
+
+function _stopPoller() {
+  if (_pollTimer) {
+    clearInterval(_pollTimer);
+    _pollTimer = null;
+  }
+}
+
+export async function getCliStatus(toolKey, { force = false } = {}) {
+  const tools = await _fetchToolVersions(force);
+  return tools?.[toolKey] || { installed: null, latest: null };
+}
+
+export function subscribeCliStatus(toolKey, callback) {
+  if (!TOOL_KEYS.includes(toolKey)) return () => {};
+  let set = _subscribers.get(toolKey);
+  if (!set) { set = new Set(); _subscribers.set(toolKey, set); }
+  set.add(callback);
+
+  const cached = _cache.tools?.[toolKey];
+  if (cached) {
+    try { callback(cached); } catch (e) { console.error('[cli-status] subscriber error:', e); }
+    _maybeStartPoller();
+  } else {
+    _fetchToolVersions(false).then((tools) => {
+      try { callback(tools?.[toolKey] || { installed: null }); } catch {}
+      _maybeStartPoller();
+    }).catch(() => {});
+  }
+
+  return () => {
+    const s = _subscribers.get(toolKey);
+    if (!s) return;
+    s.delete(callback);
+    if (!s.size) _subscribers.delete(toolKey);
+    if (!_hasMissingSubscribed()) _stopPoller();
+  };
+}
+
+export async function recheckCliStatus(toolKey) {
+  const prev = _cache.tools;
+  const next = await _fetchToolVersions(true);
+  _emitChange(prev, next, { force: true });
+  return next?.[toolKey] || { installed: null };
+}

package/neural-interface/public/shared/command-runner-model.js

@@ -0,0 +1,30 @@
+// Pure library selection; saved command text and user ordering stay untouched.
+const normalize = value => String(value ?? '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLocaleLowerCase();
+const byOrder = (a, b) => (a.order ?? 0) - (b.order ?? 0);
+const lastRun = command => Number(command.lastRunAt) || 0;
+
+export function selectCommandGroups(data, { query = '', categoryId = '', sort = 'saved' } = {}) {
+  const terms = normalize(query).trim().split(/\s+/).filter(Boolean);
+  const groups = [...data.categories].sort(byOrder)
+    .filter(category => !categoryId || category.id === categoryId)
+    .map(category => {
+      const commands = data.commands.filter(command => {
+        if (command.categoryId !== category.id) return false;
+        const text = normalize([command.name, command.command, command.cwd, category.name].join(' '));
+        return terms.every(term => text.includes(term));
+      }).sort(sort === 'recent' ? (a, b) => lastRun(b) - lastRun(a) || byOrder(a, b) : byOrder);
+      return { category, commands };
+    }).filter(group => !terms.length || group.commands.length);
+  if (sort === 'recent') groups.sort((a, b) =>
+    Math.max(0, ...b.commands.map(lastRun)) - Math.max(0, ...a.commands.map(lastRun)) || byOrder(a.category, b.category));
+  return groups;
+}
+
+export function commandLaunchPayload(command) {
+  return { command: command.command, cwd: command.cwd || null, label: command.name };
+}
+
+// Internet connectivity does not gate commands served by the local workspace.
+export function isCommandLaunchAvailable(online, hostname) {
+  return online !== false || ['localhost', '127.0.0.1', '[::1]', '::1'].includes(hostname);
+}

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

@@ -23,17 +23,13 @@ export const KEYS = {
   SELECTED_NODE:       'neural-selected-node',
   SELECTED_SWITCH:     'neural-selected-node-switch',   // sessionStorage — preserve selection across variant switch
   UI_SCALE:            'neural-ui-scale',
-  GFX_CONFIG_3D:       'neural-gfx-config',
   GFX_CONFIG_2D:       'neural-gfx-config-2d',
-  GFX_PRESET:          'neural-gfx-preset',
   LAYOUT_PRESETS_3D:   'neural-layout-presets',
   LAYOUT_PRESETS_2D:   'neural-user-presets-2d',
   PANEL_PREFIX:        'neural-panel-',
   NODE_POS_3D:         'synabun-node-positions',
   NODE_POS_2D:         'synabun-node-positions-2d',
-  CAM_HUD_PINNED:      'neural-cam-hud-pinned',
-  CAM_HUD_POS:         'neural-cam-hud-pos',
-  LAYOUT_VERSION:      'synabun-layout-version',
+  MAP_VIEW:            'neural-map-view',        // 3D memory map options {neighbors, recency, grid}
   INTERFACE_CONFIG:    'neural-interface-config',
   EXPLORER_CAT_ORDER:  'neural-explorer-cat-order',
   EXPLORER_COLLAPSED:  'neural-explorer-collapsed',
@@ -47,6 +43,7 @@ export const KEYS = {
   TERMINAL_SESSIONS:   'neural-terminal-active-sessions',
   TERMINAL_SPLIT_RATIO: 'neural-terminal-split-ratio',
   TERMINAL_NOTIFICATIONS: 'neural-terminal-notifications',
+  TERMINAL_FONT_SIZE:  'neural-terminal-font-size',   // Cmd+= / Cmd+− / Cmd+0 (9–24 px)
   NOTIF_SOUND:           'neural-notif-sound',
   NOTIF_SOUND_VOLUME:    'neural-notif-sound-volume',
   NOTIF_SOUND_TYPE:      'neural-notif-sound-type',
@@ -59,6 +56,7 @@ export const KEYS = {
   NOTIF_TRIGGER_ACTION:  'neural-notif-trigger-action',
   NOTIF_TRIGGER_ASK:     'neural-notif-trigger-ask',
   NOTIF_TRIGGER_ERROR:   'neural-notif-trigger-error',
+  SETTINGS_LAST_PAGE:    'neural-settings-last-page',   // the Settings page shown last (a page id from settings/settings-ia.js)
   NOTIF_TOAST:           'neural-notif-toast',
   NOTIF_TOAST_DURATION:  'neural-notif-toast-duration',
   NOTIF_TOAST_POSITION:  'neural-notif-toast-position',
@@ -68,6 +66,7 @@ export const KEYS = {
   GRID_SNAP:           'neural-grid-snap',
   CATEGORIES_VISIBLE:  'neural-categories-visible',
   WHITEBOARD:          'neural-whiteboard',
+  WHITEBOARD_RULESET_ALERT_DISMISSED: 'neural-whiteboard-ruleset-alert-dismissed',
   TUTORIAL_COMPLETED:  'neural-tutorial-completed',
   TUTORIAL_SKIPPED:    'neural-tutorial-skipped',
   TUTORIAL_STEP:       'neural-tutorial-step',
@@ -92,6 +91,14 @@ export const KEYS = {
   COST_WIDGET_DOCKED:     'neural-cost-widget-docked',
   NODE_LIMIT:             'neural-node-limit',
   MINIMAP_POS:            'synabun-2d-minimap-pos',
+  // Assistant (CLI-region tab) — last-used brain + per-tab state prefix
+  ASSISTANT_BRAIN:        'neural-assistant-brain',
+  ASSISTANT_TAB_PREFIX:   'neural-assistant-tab:',
+  ASSISTANT_DOCK_OPEN:    'neural-assistant-dock-open',
+  ASSISTANT_DOCK_SHOW_ALL:'neural-assistant-dock-show-all',
+  ASSISTANT_ROUTE_MODE:   'neural-assistant-route-mode', // last-used route mode (always-ask|ask-unsure|never)
+  // Assistant sidepanel — open tabs {v:1, activeIdx, tabs:[{sessionId,label,userRenamed}]}
+  ASSISTANT_PANEL_TABS:   'synabun-assistant-panel-tabs',
 };
 
 /** Default keybind mappings — action ID → combo string.
@@ -109,13 +116,17 @@ export const DEFAULT_KEYBINDS = {
   'toggle-focus-mode':   'v',
   'toggle-minimap':      'm',
   'open-keybinds':       'n',
+  'launch-assistant':    'a',
+  'toggle-assistant':    'Ctrl+a',
   'launch-claude':       '1',
   'launch-codex':        '2',
   'launch-gemini':       '3',
+  'launch-opencode':     '4',
   'launch-browser':      'b',
   'launch-youtube':      'y',
   'toggle-file-explorer': 'e',
   'open-settings':       's',
+  'map-frame-all':       'h',
 };
 
 /** Display metadata for each rebindable action. */
@@ -130,12 +141,18 @@ export const KEYBIND_META = {
   'toggle-explorer':     { label: 'Toggle Explorer',       group: 'Navigation' },
   'toggle-focus-mode':   { label: 'Toggle Focus Mode',     group: 'Navigation' },
   'toggle-minimap':      { label: 'Toggle Minimap',        group: 'View' },
+  'toggle-toolbar':      { label: 'Hide All Toolbars',    group: 'View' },
   'open-settings':       { label: 'Open Settings',          group: 'Settings' },
   'open-keybinds':       { label: 'Open Keybinds',         group: 'Settings' },
+  'launch-assistant':    { label: 'Assistant',             group: 'Launch App', icon: 'assistant' },
+  'toggle-assistant':    { label: 'Toggle Assistant',      group: 'Launch App', icon: 'assistant' },
+  'toggle-assistant-panel': { label: 'Toggle Assistant Sidepanel', group: 'Launch App', icon: 'assistant' },
   'launch-claude':       { label: 'Claude Code',           group: 'Launch App', icon: 'claude' },
   'launch-codex':        { label: 'Codex CLI',             group: 'Launch App', icon: 'codex' },
   'launch-gemini':       { label: 'Gemini CLI',            group: 'Launch App', icon: 'gemini' },
+  'launch-opencode':     { label: 'OpenCode',              group: 'Launch App', icon: 'opencode' },
   'launch-browser':      { label: 'Browser',               group: 'Launch App', icon: 'browser' },
   'launch-youtube':      { label: 'YouTube',               group: 'Launch App', icon: 'youtube' },
   'toggle-file-explorer': { label: 'Toggle File Explorer', group: 'Navigation' },
+  'map-frame-all':       { label: 'Frame Whole Map',       group: 'View' },
 };