synabun 2.0.10 → 2.2.0

package/neural-interface/public/shared/assistant/asst-routes-editor.js

@@ -3,13 +3,12 @@
 import { clampEffortId, getEffortLevelsForModel, modelEffortIds, fetchClaudeAccounts, fetchCodexAccounts, getCachedClaudeAccounts, getCachedCodexAccounts, getClaudeWorkerAccountId, getCodexWorkerAccountId } from '../agent-runtime-options.js';
 import { accountSummary, accountName, accountBadge, accountIdentity } from '../account-view.js';
 import { accountUsageText, autoAccountLabel } from '../account-usage.js';
-import { getProviderMeta } from '../provider-icons.js';
 import { getRouting, putRouting } from './asst-api.js';
 import { catalogModelRow, hiddenModelFor, ICON_CARET, openModelMenu } from './asst-brain-picker.js';
 import { closeMenu, currentMenu } from './asst-menu.js';
 import { loadRouteModels, routeModelLabel, routeModelsStatus, watchRouteModels } from './asst-route-models.js';
 import { designRouteSight, openModelsManager, routeCatalogRow, routeModeLabel } from './asst-route.js';
-import { DEFAULT_ROUTE_MODE, normalizeRouteMode, ROUTE_MODES } from './asst-state.js';
+import { DEFAULT_ROUTE_MODE, normalizeRouteMode, PROVIDERS, providerMeta, ROUTE_MODES } from './asst-state.js';
 
 const ICON_ROUTE = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M4 7h15l-4-4M20 17H5l4 4"/></svg>';
 const ICON_X = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"><path d="m6 6 12 12M18 6 6 18"/></svg>';
@@ -37,7 +36,8 @@ function choiceKey(p) { return p ? JSON.stringify([p.kind || 'direct', p.provide
 export function routeAccountView(pref, task, brain, accounts, workers = {}, t = null) {
   const tr = translator(t);
   const empty = { label: tr('assistant.routes.editorUnusedValue', '—'), readOnly: true, options: [], hint: '' };
-  if (!pref || pref.provider === 'opencode') return empty;
+  // Only Claude Code and Codex run under an account (OpenCode and Antigravity sign in inside their own CLIs).
+  if (!pref || pref.provider === 'opencode' || pref.provider === 'antigravity') return empty;
   const direct = task.id === 'chat' || routeExecutionKind(pref, task, brain) === 'direct';
   const provider = task.id === 'chat' ? brain.provider : pref.provider;
   if (!['claude-code', 'codex'].includes(provider)) return empty;
@@ -381,7 +381,8 @@ export async function openRoutesEditor(hooks = {}) {
       state.menuFocus = modelBtn.dataset.focusKey;
       const emptyLabel = task.requires ? tr('assistant.routes.noCapableModel', 'No model in your catalog can make {medium} yet.', { medium: tr(`assistant.routes.medium.${task.requires === 'video' ? 'videos' : 'images'}`, task.requires) }) : tr('assistant.routes.noSeeingModel', 'No model in your catalog can see images yet.');
       const menu = await openModelMenu(modelBtn, {
-        brain: brain(), t: hooks.t, includeHere: true, hereLabel: tr('assistant.routes.brainDecides', 'Assistant chooses'), title: task.label,
+        // Every provider a route can name (Antigravity included).
+        brain: brain(), t: hooks.t, includeHere: true, hereLabel: tr('assistant.routes.brainDecides', 'Assistant chooses'), title: task.label, providers: PROVIDERS,
         current: pref ? { provider: pref.provider, model: pref.model } : null, onToast: hooks.onToast,
         routingEditor: true, onManageModels: () => manageModels(modelBtn.dataset.focusKey),
         ...(task.requires ? { accept: (_p, m) => m.outputs?.[task.requires] === true, allowCustom: false, emptyLabel } : {}),
@@ -400,7 +401,7 @@ export async function openRoutesEditor(hooks = {}) {
     // Keys are stable across translations; accessible names use the translated field.
     modelBtn.dataset.focusKey = `${task.id}-model`; caret(modelBtn); modelBtn.setAttribute('aria-haspopup', 'dialog');
     modelBtn.title = label;
-    if (pref?.provider) { const mark = el('span', 'asst-icon'); mark.setAttribute('aria-hidden', 'true'); mark.innerHTML = getProviderMeta(pref.provider).icon; mark.style.color = getProviderMeta(pref.provider).color; modelBtn.prepend(mark); }
+    if (pref?.provider) { const mark = el('span', 'asst-icon'); mark.setAttribute('aria-hidden', 'true'); mark.innerHTML = providerMeta(pref.provider).icon; mark.style.color = providerMeta(pref.provider).color; modelBtn.prepend(mark); }
     modelCell.append(modelBtn);
     const source = el('span', 'asst-routes-source');
     let sourceText = pref ? tr('assistant.routes.source.yours', 'Your choice') : tr('assistant.routes.source.default', 'Assistant chooses');
@@ -433,14 +434,14 @@ export async function openRoutesEditor(hooks = {}) {
     if (effortValue !== unusedValue && effortValue !== effortText) effortBtn.setAttribute('aria-label', tr('assistant.routes.fieldLabel', '{task}: {field}, {value}', { task: task.label, field: tr('assistant.routes.columns.effort', 'Effort'), value: `${effortValue} · ${effortText}` }));
     const effortCell = el('div', 'asst-routes-cell asst-routes-effort-cell'); effortCell.append(el('span', 'asst-routes-cell-label', tr('assistant.routes.columns.effort', 'Effort')), effortBtn); node.append(effortCell);
     const kind = routeExecutionKind(pref, task, brain());
-    const runLabel = task.id === 'chat' ? tr('assistant.routes.inConversation', 'In conversation') : !pref ? task.dispatchOnly ? tr('assistant.routes.workerChooses', 'Worker · assistant chooses') : tr('assistant.routes.brainDecides', 'Assistant chooses') : kind === 'direct' ? tr('assistant.routes.inConversation', 'In conversation') : tr('assistant.routes.onWorker', '{provider} worker', { provider: getProviderMeta(pref.provider).label });
+    const runLabel = task.id === 'chat' ? tr('assistant.routes.inConversation', 'In conversation') : !pref ? task.dispatchOnly ? tr('assistant.routes.workerChooses', 'Worker · assistant chooses') : tr('assistant.routes.brainDecides', 'Assistant chooses') : kind === 'direct' ? tr('assistant.routes.inConversation', 'In conversation') : tr('assistant.routes.onWorker', '{provider} worker', { provider: providerMeta(pref.provider).label });
     const run = fieldButton('asst-routes-run', task, tr('assistant.routes.columns.run', 'Runs in'), runLabel, () => openMenuFor(run, tr('assistant.routes.columns.run', 'Runs in'), [
       { kind: 'radio', id: 'direct', label: tr('assistant.routes.inConversation', 'In conversation'), desc: tr('assistant.routes.conversationDesc', 'Continue this conversation on the chosen model for this task.'), selected: kind === 'direct', onSelect: () => setChoice(task.id, { ...pref, kind: 'direct' }, run.dataset.focusKey) },
-      { kind: 'radio', id: 'dispatch', label: tr('assistant.routes.onWorker', '{provider} worker', { provider: getProviderMeta(pref?.provider).label }), desc: tr('assistant.routes.workerDesc', 'Hand the task to a worker and show its result here.'), selected: kind === 'dispatch', onSelect: () => setChoice(task.id, { ...pref, kind: 'dispatch' }, run.dataset.focusKey) },
+      { kind: 'radio', id: 'dispatch', label: tr('assistant.routes.onWorker', '{provider} worker', { provider: providerMeta(pref?.provider).label }), desc: tr('assistant.routes.workerDesc', 'Hand the task to a worker and show its result here.'), selected: kind === 'dispatch', onSelect: () => setChoice(task.id, { ...pref, kind: 'dispatch' }, run.dataset.focusKey) },
     ]));
     run.dataset.focusKey = `${task.id}-run`; run.disabled = !pref || task.dispatchOnly || pref.provider !== brain().provider || task.id === 'chat';
     const inConversation = task.id === 'chat' || (pref && kind === 'direct');
-    const runValue = inConversation ? tr('assistant.routes.editorInConversation', 'This conversation') : pref ? getProviderMeta(pref.provider).label : unusedValue;
+    const runValue = inConversation ? tr('assistant.routes.editorInConversation', 'This conversation') : pref ? providerMeta(pref.provider).label : unusedValue;
     run.querySelector('.asst-dd-label').textContent = runValue;
     if (inConversation) run.setAttribute('aria-label', tr('assistant.routes.fieldLabel', '{task}: {field}, {value}', { task: task.label, field: tr('assistant.routes.columns.run', 'Runs in'), value: runValue }));
     if (!run.disabled) caret(run);

package/neural-interface/public/shared/assistant/asst-scenes.js

@@ -116,8 +116,12 @@ export function runChip(run, t = tFallback) {
   }
   if (awaitsAnswer(run)) return { tone: 'action', label: t('assistant.run.waitingInput', 'waiting for your answer') };
   const tone = runTone(run);
+  // A held run whose card the user answered "here": the assistant does it, this worker never started.
+  if (run?.completionReason === 'route_here') return { tone, label: t('assistant.run.routedHere', 'not started: done here instead') };
   if (run?.turnState === 'awaiting_permission') return { tone, label: t('assistant.run.needsApproval', 'needs approval') };
   if (run?.turnState === 'needs_input') return { tone, label: t('assistant.run.needsInput', 'needs input') };
+  // A Claude Code worker a server restart cut off, until the next start has resumed it (lib/assistant-dispatch.js).
+  if (run?.state === 'suspended' || run?.state === 'resuming') return { tone, label: t('assistant.run.resuming', 'resuming after a server restart') };
   if (run?.queued && run.status !== 'running') return { tone, label: t('assistant.run.queued', 'queued') };
   if (isRunIdle(run)) {
     const outcome = run.outcome || run.lastResult?.status;
@@ -167,6 +171,46 @@ export const CODEX_ITEM_EVENTS = Object.freeze({
  */
 export const OPENCODE_TOOL_STATES = Object.freeze(['running', 'completed', 'error']);
 
+// The path-like fields of an Antigravity tool call's arguments (lib/worker-confinement.js reads the same ones).
+const ACP_PATH_KEYS = ['path', 'file_path', 'filePath', 'Path', 'AbsolutePath', 'TargetFile', 'DirectoryPath', 'SearchPath'];
+
+/**
+ * An Antigravity (ACP) tool call as an activity: its `kind` says what it does (read, edit, delete,
+ * move, search, execute, think, fetch, switch_mode, other), its `rawInput` holds the tool's own
+ * arguments and its `locations` the files it touches. Another tool (an MCP server's) is read by its
+ * name, as for the other providers. null for a mode switch.
+ */
+function acpToolActivity(call) {
+  const args = obj(call.rawInput);
+  const kind = str(call.kind) || 'other';
+  const title = str(call.title).trim();
+  const paths = [...new Set([
+    ...(Array.isArray(call.locations) ? call.locations : []).map((location) => str(location?.path)),
+    ...ACP_PATH_KEYS.map((key) => (typeof args[key] === 'string' ? args[key] : '')),
+  ].filter(Boolean))];
+  const pick = (...values) => values.map((v) => (typeof v === 'string' ? v.trim() : '')).find(Boolean) || '';
+  switch (kind) {
+    case 'execute': {
+      const command = Array.isArray(args.command) ? args.command.map(str).join(' ') : pick(args.command, args.CommandLine, args.cmd);
+      return { kind: 'shell', name: 'exec_command', input: { command: command || title } };
+    }
+    case 'read': return { kind: 'read', name: 'read', input: { file_path: paths[0] || title } };
+    case 'edit': case 'delete': case 'move':
+      return { kind: 'edit', name: kind === 'edit' ? 'edit' : 'apply_patch', input: paths.length > 1 ? { changes: paths.map((path) => ({ path })) } : { file_path: paths[0] || title } };
+    case 'search': return { kind: 'search', name: 'grep', input: { pattern: pick(args.pattern, args.query, args.Query, args.Pattern) || title, path: paths[0] || '' } };
+    case 'fetch': {
+      const url = pick(args.url, args.Url, args.href);
+      return url ? { kind: 'web', name: 'WebFetch', input: { url } } : { kind: 'web', name: 'WebSearch', input: { query: pick(args.query, args.Query) || title } };
+    }
+    case 'think': return { kind: 'think', name: 'thinking', input: {} };
+    case 'switch_mode': return null;
+    default: {
+      const name = pick(call.name, args.toolName, title) || 'tool';
+      return { kind: kindOf(name, args), name, input: args };
+    }
+  }
+}
+
 /**
  * A worker's provider event ({ provider, eventType?, event }, the payload of
  * sync:sidepanel:provider-event) as what it is doing: { kind, name, input }
@@ -175,7 +219,11 @@ export const OPENCODE_TOOL_STATES = Object.freeze(['running', 'completed', 'erro
  * stage and the tray keep only compactActivity() of it. OpenCode names its
  * tools bash, read, edit, write, patch, glob, grep, list, webfetch,
  * websearch, codesearch, task, todowrite, and MCP tools `<server>_<tool>`
- * (SynaBun_browser_navigate): kindOf() reads all of them.
+ * (SynaBun_browser_navigate): kindOf() reads all of them. An Antigravity
+ * worker's events are ACP session updates (eventType = their `sessionUpdate`):
+ * a tool call when it is announced (`tool_call`, or an update that starts it
+ * and names its kind), a thought chunk as thinking, a plan as planning; its
+ * message text is no activity, as for the others.
  */
 export function activityOf(payload) {
   const provider = str(payload?.provider);
@@ -220,6 +268,13 @@ export function activityOf(payload) {
     const input = obj(part.state?.input);
     return { kind: kindOf(name, input), name, input };
   }
+  if (provider === 'antigravity') {
+    const type = str(payload.eventType || event.sessionUpdate);
+    if (type === 'agent_thought_chunk') return { kind: 'think', name: 'thinking', input: {} };
+    if (type === 'plan') return { kind: 'plan', name: 'update_plan', input: { todos: Array.isArray(event.entries) ? event.entries : [] } };
+    if (type === 'tool_call' || (type === 'tool_call_update' && str(event.kind) && event.status === 'in_progress')) return acpToolActivity(event);
+    return null;
+  }
   return null;
 }
 

package/neural-interface/public/shared/assistant/asst-sidepanel.js

@@ -22,7 +22,7 @@ import { getProviderMeta } from '../provider-icons.js';
 import { showGuestToast } from '../ui-sync.js';
 import { registerSidepanel, setSidepanelVisible, syncSidepanelLayout, focusSidepanel } from '../ui-sidepanel-windows.js';
 import {
-  assistantBlocked, assistantOwnerOf, fetchLiveAssistantSessions, noteAssistantFocus, openAssistant, registerAssistantHost,
+  assistantBlocked, assistantOwnerOf, noteAssistantFocus, openAssistant, readLiveAssistantSessions, registerAssistantHost,
 } from '../ui-assistant.js';
 import { mountAssistant } from './asst-panel.js';
 import { openModelsManager } from './asst-route.js';
@@ -30,6 +30,7 @@ import { brainLabel, readStoredBrain, restoredSessionName } from './asst-state.j
 import { closeMenu, isMenuOpen, openMenu } from './asst-menu.js';
 import { injectAssistantSidepanelStyles } from './asst-sidepanel-styles.js';
 import { createMascot, mascotCameoSvg } from '../synabun-mascot.js';
+import { createTutorialPreview } from '../ui-tutorial-preview.js';
 
 const PANEL_OWNER = 'assistant-sidepanel';
 const HOST_ID = 'sidepanel';
@@ -55,6 +56,12 @@ let _toastTimer = null;
 let _renaming = false;
 const _tabs = [];   // { sessionId, viewport, toolbar, ctl, pill, label, userRenamed, status, brain }
 let _activeIdx = -1;
+let _tourPresenting = false;
+// The saved tabs ({ activeIdx, tabs }) while the session list could not be read (a server that is
+// starting answers before its Assistant routes exist): they stay saved and are asked about again.
+let _unrestored = null;
+let _restoring = null; // that restore under way: a session start waits for it
+const RESTORE_RETRY_MS = [500, 1000, 2000, 4000, 8000, 15_000];
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -92,11 +99,13 @@ function conversationOf(tab) {
 
 function saveTabs() {
   try {
-    if (!_tabs.length) { storage.removeItem(KEYS.ASSISTANT_PANEL_TABS); return; }
+    // Saved tabs not restored yet stay saved (their names with them), after the open ones.
+    const waiting = (_unrestored?.tabs || []).filter(entry => !findTab(entry.sessionId));
+    if (!_tabs.length) { if (!waiting.length) storage.removeItem(KEYS.ASSISTANT_PANEL_TABS); return; }
     storage.setItem(KEYS.ASSISTANT_PANEL_TABS, JSON.stringify({
       v: 1,
       activeIdx: Math.max(0, _activeIdx),
-      tabs: _tabs.map(tab => ({ sessionId: tab.sessionId, label: tab.userRenamed ? tab.label : '', userRenamed: !!tab.userRenamed })),
+      tabs: [..._tabs.map(tab => ({ sessionId: tab.sessionId, label: tab.userRenamed ? tab.label : '', userRenamed: !!tab.userRenamed })), ...waiting],
     }));
   } catch { /* storage unavailable */ }
 }
@@ -408,13 +417,23 @@ function focusSession(sessionId, { prompt = '' } = {}) {
   if (prompt) _tabs[idx].ctl?.send(prompt);
 }
 
-async function startSession() {
+async function startSession(prompt = '') {
   if (_starting || _tabs.length) return;
   _starting = true;
   _startError = '';
   renderPlaceholder('starting');
   try {
-    const res = await openAssistant({ host: HOST_ID });
+    // The saved tabs come back before a new session is made: the restore under way (the server is
+    // starting), or once more for the ones it could not ask about.
+    if (!_restoring && _unrestored) startRestore(_unrestored, []);
+    if (_restoring) await _restoring.catch(() => { /* a new session, then */ });
+    if (_tabs.length) {
+      const tab = activeTab() || _tabs[0];
+      switchTo(_tabs.indexOf(tab));
+      if (prompt) { tab.ctl?.insertText?.(prompt); tab.ctl?.focus?.(); } // a conversation's draft, never sent for them
+      return;
+    }
+    const res = await openAssistant(prompt ? { host: HOST_ID, prompt } : { host: HOST_ID });
     if (!_tabs.length) renderPlaceholder(res ? null : 'failed');
   } finally {
     _starting = false;
@@ -563,8 +582,8 @@ function applyVisibility(nextVisible) {
   const tab = activeTab();
   if (_visible) {
     state.lastActivePanel = 'assistant';
-    if (!_tabs.length) startSession();
-    else if (tab) {
+    if (!_tabs.length && !_tourPresenting) startSession();
+    else if (tab && !_tourPresenting) {
       if (tab.status === 'done') tab.status = 'idle';
       try { tab.ctl?.onShown(); } catch { /* ignore */ }
       noteAssistantFocus(tab.sessionId, HOST_ID);
@@ -617,6 +636,67 @@ export function assistantPanelPeekable() {
   return !assistantBlocked() && _tabs.length > 0;
 }
 
+/**
+ * Present the panel for the Workspace tour (ui-tutorial.js), reversibly: it never
+ * creates a session. The tour plays on the active tab when its empty state shows
+ * its character (the tab's own controls, composer and director: tourHost());
+ * otherwise (no tab, or a conversation on screen) on a session-free preview laid
+ * over the tab. Returns { host, live, restore({ reason }) } or null when the
+ * Assistant is blocked. restore() puts back the panel's visibility, the docked
+ * peers and the last-active panels, unless the tour ended on its hand-off to a
+ * live tab ('done'): then the panel stays and the tab's composer takes the focus.
+ */
+export function beginAssistantTour({ onPreviewSend = () => {} } = {}) {
+  if (assistantBlocked()) return null;
+  ensurePanel();
+  const wasVisible = _visible;
+  const previousPanel = state.lastActivePanel;
+  const previousSidepanel = state.lastActiveSidepanel;
+  const peers = ['#topright-claude-panel-btn', '#topright-codex-panel-btn', '#topright-opencode-panel-btn', '#topright-antigravity-panel-btn']
+    .map(s => document.querySelector(s)).filter(b => b?.classList.contains('active'));
+  _tourPresenting = true;
+  const tab = activeTab();
+  let liveHost = null;
+  try { liveHost = tab?.ctl?.tourHost?.() || null; } catch { liveHost = null; }
+  const preview = liveHost ? null : createTutorialPreview(_panel, { onSend: (text) => onPreviewSend(text) });
+  if (preview) _panel.classList.add('tour-covering');
+  setVisible(true);
+  let restored = false;
+  const host = liveHost || preview.host;
+  return {
+    host,
+    live: !!liveHost,
+    /**
+     * The user sent `text` from the preview's composer (after restore({ reason: 'sent' })):
+     * with no session, it starts one with that message (the user's own send); with a
+     * conversation on screen, it becomes that conversation's draft, never sent for them.
+     */
+    deliver(text) {
+      const message = String(text || '').trim();
+      if (!message) return;
+      const current = activeTab();
+      if (current?.ctl) { focusSession(current.sessionId); current.ctl.insertText?.(message); current.ctl.focus?.(); return; }
+      startSession(message);
+    },
+    restore({ reason = 'skip' } = {}) {
+      if (restored) return;
+      restored = true;
+      closeMenu();
+      preview?.destroy();
+      _panel.classList.remove('tour-covering');
+      _tourPresenting = false;
+      const keep = (reason === 'done' && !!liveHost) || reason === 'sent';
+      if (keep) {
+        if (tab && findTab(tab.sessionId)) { try { tab.ctl?.onShown(); } catch { /* ignore */ } }
+        return;
+      }
+      if (!wasVisible) setVisible(false);
+      for (const button of peers) if (!button.classList.contains('active')) button.click();
+      state.lastActivePanel = previousPanel; state.lastActiveSidepanel = previousSidepanel;
+    },
+  };
+}
+
 /** The top-right SynaBun button. */
 export async function toggleAssistantPanel() {
   if (assistantBlocked()) {
@@ -668,7 +748,30 @@ export async function initAssistantPanel() {
 
   const saved = readSavedTabs();
   if (!saved?.tabs.length) return;
-  const live = await fetchLiveAssistantSessions();
+  await startRestore(saved, RESTORE_RETRY_MS);
+}
+
+function startRestore(saved, retries) {
+  _restoring = restoreSavedTabs(saved, retries).finally(() => { _restoring = null; });
+  return _restoring;
+}
+
+/**
+ * The saved tabs come back (hidden, as pills) for the sessions the server still has open. A list
+ * that cannot be read restores nothing and forgets nothing: the tabs stay saved, names included
+ * (saveTabs), the list is asked again after each wait of `retries`, then at the next session start.
+ */
+async function restoreSavedTabs(saved, retries) {
+  _unrestored = saved;
+  let live = await readLiveAssistantSessions();
+  for (const wait of retries) {
+    if (live || assistantBlocked()) break;
+    await new Promise(done => setTimeout(done, wait));
+    live = await readLiveAssistantSessions();
+  }
+  if (!live) return;
+  _unrestored = null;
+  const hadTabs = _tabs.length > 0; // one opened meanwhile stays the one showing
   for (const entry of saved.tabs) {
     const meta = live.get(entry.sessionId);
     if (!meta) continue;
@@ -683,8 +786,12 @@ export async function initAssistantPanel() {
       restoring: true,
     });
   }
-  if (_tabs.length) {
-    _activeIdx = Math.min(Math.max(0, saved.activeIdx), _tabs.length - 1);
+  if (_tabs.length && !hadTabs) {
+    // The tab that was showing, by its session: a saved tab before it that did not come back (a draft,
+    // an ended session) must not hand the header to its neighbour.
+    const shownId = saved.tabs[saved.activeIdx]?.sessionId;
+    const shown = _tabs.findIndex(tab => tab.sessionId === shownId);
+    _activeIdx = shown >= 0 ? shown : Math.min(Math.max(0, saved.activeIdx), _tabs.length - 1);
     markActive();
     renderHeader();
     renderPills();

package/neural-interface/public/shared/assistant/asst-slash.js

@@ -4,10 +4,10 @@
 // Pure module (no DOM, no i18n import) so node:test can exercise it. The
 // composer resolves `descKey` through i18n and falls back to `desc`.
 
-import { normalizeComputerMode, normalizeProvider, normalizeRouteMode } from './asst-state.js';
+import { isBrainProvider, normalizeComputerMode, normalizeProvider, normalizeRouteMode } from './asst-state.js';
 
 export const SLASH_COMMANDS = [
-  { name: 'dispatch', usage: '/dispatch <provider> [--model m] [--effort e] [--agent a] [--project p] [--mcp profile] [--account id] [--ask] [--title "t"] <task>', descKey: 'assistant.slash.dispatch', desc: 'Dispatch a task to a sidepanel agent' },
+  { name: 'dispatch', usage: '/dispatch <provider> [--model m] [--effort e] [--agent a] [--project p] [--tools a,b] [--account id] [--ask] [--title "t"] <task>', descKey: 'assistant.slash.dispatch', desc: 'Dispatch a task to a sidepanel agent' },
   { name: 'agents', usage: '/agents [all]', descKey: 'assistant.slash.agents', desc: 'List dispatched runs' },
   { name: 'recall', usage: '/recall <query>', descKey: 'assistant.slash.recall', desc: 'Search memories' },
   { name: 'remember', usage: '/remember <text>', descKey: 'assistant.slash.remember', desc: 'Store a memory' },
@@ -17,7 +17,7 @@ export const SLASH_COMMANDS = [
   { name: 'models', usage: '/models [list | archived | hide <id…> | show <id…>]', descKey: 'assistant.slash.models', desc: 'Switch models off or on for the Assistant (or open the Models list)' },
   { name: 'budget', usage: '/budget', descKey: 'assistant.slash.budget', desc: 'Set the session budget and view provider shares' },
   { name: 'computer', usage: '/computer [on|off]', descKey: 'assistant.slash.computer', desc: 'Let the assistant use your Mac' },
-  { name: 'stop', usage: '/stop [runId|all]', descKey: 'assistant.slash.stop', desc: 'Stop a run, everything, or the current turn' },
+  { name: 'stop', usage: '/stop [runId|title|all]', descKey: 'assistant.slash.stop', desc: 'Stop a run, everything, or the current turn' },
   { name: 'new', usage: '/new [provider]', descKey: 'assistant.slash.new', desc: 'Start a fresh session' },
   { name: 'resume', usage: '/resume [sessionId]', descKey: 'assistant.slash.resume', desc: 'Resume a previous session' },
   { name: 'compact', usage: '/compact', descKey: 'assistant.slash.compact', desc: 'Compact the context' },
@@ -33,7 +33,7 @@ export const DISPATCH_FLAGS = {
   effort: 'effort', e: 'effort',
   agent: 'agent',
   project: 'project', p: 'project', cwd: 'project',
-  mcp: 'mcp', profile: 'mcp',
+  tools: 'tools',
   account: 'account', a: 'account',
   title: 'title', t: 'title',
   budget: 'budget',
@@ -143,6 +143,8 @@ function parseModel(rest) {
     provider = normalizeProvider(first);
     model = null;
   }
+  // /model switches the brain: a provider that only runs dispatched work (none of the four today) is refused, not swapped.
+  if (provider && !isBrainProvider(provider)) return { name: 'model', provider, model, effort: tokens[1] || null, error: 'not_brain' };
   return { name: 'model', provider, model, effort: tokens[1] || null };
 }
 
@@ -182,7 +184,11 @@ export function parseSlashCommand(text) {
       return enabled == null ? { name, mode: null, error: 'invalid_mode', value: restTrim } : { name, mode: enabled ? 'on' : 'off' };
     }
     case 'stop': return { name, target: restTrim && !/^all$/i.test(restTrim) ? restTrim : null, all: /^all$/i.test(restTrim) };
-    case 'new': return { name, provider: restTrim ? normalizeProvider(restTrim) : null };
+    case 'new': {
+      const provider = restTrim ? normalizeProvider(restTrim) : null;
+      // A new session's brain: a provider that only runs dispatched work cannot be one (Antigravity can, since it runs the brain too).
+      return provider && !isBrainProvider(provider) ? { name, provider, error: 'not_brain' } : { name, provider };
+    }
     case 'resume': return { name, sessionId: restTrim || null };
     case 'compact':
     case 'clear':
@@ -219,10 +225,10 @@ export function matchSlashCommands(query) {
 
 /**
  * Build the POST /api/assistant/dispatch body from a parsed /dispatch command.
- * Only explicit flags set model/effort — the brain's project, MCP profile and
+ * Only explicit flags set model/effort — the brain's project and
  * (same-provider) account are inherited, models are left to the server default.
  */
-export function buildDispatchSpec(parsed, brain = {}, { assistantSessionId = null } = {}) {
+export function buildDispatchSpec(parsed, brain = {}, { assistantSessionId = null, toolCatalog = null } = {}) {
   if (!parsed || parsed.name !== 'dispatch' || parsed.error) return null;
   const o = parsed.options || {};
   const spec = {
@@ -236,8 +242,7 @@ export function buildDispatchSpec(parsed, brain = {}, { assistantSessionId = nul
   if (o.model) spec.model = o.model;
   if (o.effort) spec.effort = o.effort;
   if (o.agent) spec.agent = o.agent;
-  const mcp = o.mcp || brain.mcpProfile;
-  if (mcp) spec.mcpProfile = mcp;
+  if (o.tools !== undefined) spec.tools = String(o.tools).split(',').map(id => id.trim()).filter(Boolean);
   const account = o.account || (brain.provider === parsed.provider ? brain.accountId : null);
   if (account) {
     if (parsed.provider === 'codex') spec.codexAccountId = account;
@@ -247,6 +252,9 @@ export function buildDispatchSpec(parsed, brain = {}, { assistantSessionId = nul
   if (o.budget !== undefined && Number.isFinite(Number(o.budget))) spec.budgetUsd = Number(o.budget);
   if (o.minutes !== undefined && Number.isFinite(Number(o.minutes))) spec.maxMinutes = Number(o.minutes);
   if (o.browser) spec.usesBrowser = true;
+  // A browser-reading slash launch uses the workspace guard, just like a routed browser task.
+  // Group metadata comes from the catalog, never from a second list of browser ids.
+  if (o.browser || (spec.tools || []).some(id => id === 'all' || toolCatalog?.groups?.some(group => group.id === id && group.browser))) spec.capability = 'workspace';
   if (assistantSessionId) spec.assistantSessionId = assistantSessionId;
   return spec;
 }