synabun 2.0.10 → 2.1.0

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

@@ -16,6 +16,7 @@
 // open. `synabun.route` events (phase card|auto|decided|pending|expired|
 // declined|cancelled) update the line in place by routeId.
 
+import { fetchClaudeAccounts, fetchCodexAccounts, getEffortLevelsForModel } from '../agent-runtime-options.js';
 import { getProviderMeta } from '../provider-icons.js';
 import { fetchManageCatalog, patchHiddenModels } from './asst-api.js';
 import { catalogModelRow, fmtModelPrice, hiddenModelFor, ICON_CARET, invalidateModelCatalog, openModelMenu } from './asst-brain-picker.js';
@@ -107,7 +108,7 @@ function normalizeRouteOption(o) {
     provider: normalizeProvider(src.provider, str(src.provider) || null),
     model: str(src.model),
     effort: str(src.effort) || null,
-    ...(Object.hasOwn(src, 'accountId') ? { accountId: src.accountId, account: obj(src.account), accountError: obj(src.accountError) } : {}),
+    ...(Object.hasOwn(src, 'accountId') ? { accountId: src.accountId, accountChoice: src.accountChoice || null, account: obj(src.account), accountError: obj(src.accountError) } : {}),
     label: str(src.label),
     badge: str(src.badge) || null,
     tier: str(src.tier) || null,
@@ -303,6 +304,7 @@ export function buildRouteResponse(n, choice = {}) {
       provider: normalizeProvider(target.provider, str(target.provider) || null),
       model: str(target.model),
       effort: str(target.effort) || null,
+      accountId: str(target.accountId) || null,
     };
   }
   return out;
@@ -804,11 +806,12 @@ export function renderRouteCard(container, input, hooks = {}) {
       row.classList.toggle('selected', on);
       row.tabIndex = on ? 0 : -1;
     }
+    syncFields();
     runBtn.disabled = state.pending || state.resolved || state.expired || !state.selectedId;
   }
 
   function select(id, { focus = false } = {}) {
-    if (state.pending || state.resolved) return;
+    if (state.pending || state.resolved || state.expired) return;
     const o = allOptions().find(x => x.id === id);
     if (!o || o.disabled) return;
     state.selectedId = id;
@@ -816,8 +819,62 @@ export function renderRouteCard(container, input, hooks = {}) {
     if (focus) list.querySelector(`.asst-route-option[data-option-id="${CSS.escape(id)}"]`)?.focus();
   }
 
-  // Other model…
-  const otherBtn = el('button', 'asst-link asst-route-other', tr('assistant.routes.other', 'Other model…'));
+  // Task-local controls; these never edit the routing preference table.
+  const fields = el('div', 'asst-route-fields');
+  function taskField(className) {
+    const button = el('button', `asst-dd ${className}`);
+    button.type = 'button';
+    button.setAttribute('aria-haspopup', 'menu');
+    button.innerHTML = `<span class="asst-dd-label"></span><span class="asst-dd-caret" aria-hidden="true">${ICON_CARET}</span>`;
+    return button;
+  }
+  const effortBtn = taskField('asst-route-effort');
+  const accountBtn = taskField('asst-route-account');
+  const setFieldLabel = (button, text) => { button.querySelector('.asst-dd-label').textContent = text; button.title = text; };
+  const selected = () => allOptions().find(o => o.id === state.selectedId);
+  function editTarget(patch) {
+    if (state.pending || state.resolved || state.expired) return;
+    state.other = { ...selected(), accountId: selected()?.accountChoice || selected()?.accountId || null, accountChoice: Object.hasOwn(patch, 'accountId') ? patch.accountId : selected()?.accountChoice || null, disabled: false, disabledReason: null, accountError: null, ...patch, id: 'other', number: options.length + 1, badge: null, badgeText: tr('assistant.routes.badge.other', 'Your choice') };
+    state.selectedId = 'other';
+    renderOptions();
+  }
+  function syncFields() {
+    const target = selected();
+    setFieldLabel(otherBtn, target ? routeTargetLabel(target) : tr('assistant.routes.other', 'Other model…'));
+    otherBtn.setAttribute('aria-label', tr('assistant.brain.model', 'Model'));
+    otherBtn.disabled = state.pending || state.resolved || state.expired;
+    setFieldLabel(effortBtn, target?.effort || tr('assistant.routes.editorEffortAuto', 'Auto'));
+    effortBtn.setAttribute('aria-label', tr('assistant.brain.effort', 'Thinking effort'));
+    setFieldLabel(accountBtn, routeDisplayAccount(target, hooks.t) || tr('assistant.routes.account.workersDefault', 'Workers default'));
+    accountBtn.setAttribute('aria-label', tr('assistant.brain.account', 'Account profile'));
+    const levels = target ? getEffortLevelsForModel(target.provider, catalogModelRow(target.provider, target.model)) : [];
+    effortBtn.disabled = state.pending || state.resolved || state.expired || !levels.some(e => e.id !== 'off');
+    accountBtn.hidden = !['claude-code', 'codex'].includes(target?.provider);
+    accountBtn.disabled = state.pending || state.resolved || state.expired;
+  }
+  effortBtn.addEventListener('click', () => {
+    const target = selected();
+    const levels = getEffortLevelsForModel(target.provider, catalogModelRow(target.provider, target.model));
+    openMenu(effortBtn, { title: tr('assistant.brain.effort', 'Thinking effort'), placement: 'auto', items: [
+      { kind: 'radio', label: tr('assistant.routes.editorEffortAuto', 'Auto'), selected: !target.effort, onSelect: () => editTarget({ effort: null }) },
+      ...levels.filter(e => e.id !== 'off').map(e => ({ kind: 'radio', label: e.label || e.id, selected: target.effort === e.id, onSelect: () => editTarget({ effort: e.id }) })),
+    ] });
+  });
+  accountBtn.addEventListener('click', async () => {
+    const target = selected();
+    try {
+      const rows = await (target.provider === 'codex' ? fetchCodexAccounts() : fetchClaudeAccounts());
+      if (!card.isConnected || state.pending || state.resolved || state.expired || selected() !== target) return;
+      openMenu(accountBtn, { title: tr('assistant.brain.account', 'Account profile'), placement: 'auto', items: [
+        { kind: 'radio', label: tr('assistant.routes.account.workersDefault', 'Workers default'), selected: !(target.accountChoice || target.accountId), onSelect: () => editTarget({ accountId: null, account: null }) },
+        { kind: 'radio', label: autoAccountLabel(hooks.t), selected: (target.accountChoice || target.accountId) === 'auto', onSelect: () => editTarget({ accountId: 'auto', account: null }) },
+        ...(Array.isArray(rows) ? rows : []).map(a => ({ kind: 'radio', label: accountSummary(a, target.provider === 'codex' ? 'codex' : 'claude'), disabled: a.signedIn === false, selected: (target.accountChoice || target.accountId) === a.id, onSelect: () => editTarget({ accountId: a.id, account: a }) })),
+      ] });
+    } catch (error) { hooks.onToast?.(error.message); }
+  });
+
+  // Model menu, scoped to this task.
+  const otherBtn = taskField('asst-route-other');
   otherBtn.type = 'button';
   otherBtn.setAttribute('aria-haspopup', 'menu');
   otherBtn.hidden = !n.other.allowed;
@@ -827,21 +884,24 @@ export function renderRouteCard(container, input, hooks = {}) {
     const brain = normalizeBrain(hooks.getBrain?.() || { provider: n.brain.provider || 'claude-code', model: n.brain.model });
     openModelMenu(otherBtn, {
       brain,
+      shouldOpen: () => card.isConnected && !state.pending && !state.resolved && !state.expired,
       t: hooks.t,
       title: tr('assistant.routes.otherTitle', 'Run on another model'),
       placement: 'auto',
       providers: n.other.providers.length ? n.other.providers.map(p => normalizeProvider(p, p)) : null,
-      current: state.other ? { provider: state.other.provider, model: state.other.model } : null,
+      current: selected() ? { provider: selected().provider, model: selected().model } : null,
       onToast: hooks.onToast,
       // Image / video creation: only models that generate the medium (no custom id: its output is unknown).
       ...(n.requires ? { accept: (_p, m) => m?.outputs?.[n.requires] === true, allowCustom: false, emptyLabel: tr('assistant.routes.noCapableModel', 'No model in your catalog can make {medium} yet.', { medium: mediumWords(n.requires, tr) }) } : {}),
       // Design: only models that can see.
       ...(!n.requires && n.visionOnly ? { accept: (_p, m) => m?.vision === true && m?.status !== 'unavailable', allowCustom: false, emptyLabel: tr('assistant.routes.noSeeingModel', 'No model in your catalog can see images yet.') } : {}),
       onSelect: (target) => {
-        if (!target?.model) return;
-        const kind = n.dispatchOnly || (target.provider && target.provider !== brain.provider) ? 'dispatch' : 'direct';
+        if (!target?.model || !card.isConnected) return;
+        if (state.pending || state.resolved || state.expired) return;
+        const previous = selected();
+        const kind = n.dispatchOnly || previous?.kind === 'dispatch' || (target.provider && target.provider !== brain.provider) ? 'dispatch' : 'direct';
         state.other = {
-          id: 'other', kind, provider: target.provider, model: target.model, effort: null,
+          id: 'other', kind, provider: target.provider, model: target.model, effort: null, accountId: previous?.provider === target.provider ? previous.accountChoice || previous.accountId || null : null, account: previous?.provider === target.provider ? previous.account || null : null,
           label: target.label || '', badge: null, number: options.length + 1, here: false,
           title: target.label || target.model, badgeText: tr('assistant.routes.badge.other', 'Your choice'),
           vision: target.vision === true, price: target.price || null, reason: '', warning: null, disabled: false,
@@ -852,7 +912,8 @@ export function renderRouteCard(container, input, hooks = {}) {
       },
     });
   });
-  card.appendChild(otherBtn);
+  fields.append(otherBtn, effortBtn, accountBtn);
+  card.appendChild(fields);
 
   // Remember for ‹class› tasks
   let rememberInput = null;
@@ -906,7 +967,7 @@ export function renderRouteCard(container, input, hooks = {}) {
       decidedBy: 'user',
       optionId: state.selectedId,
       remembered: state.remember,
-      target: o ? { kind: o.kind || 'direct', provider: o.provider, model: o.model, effort: o.effort, label: o.label || (o.here ? routeTargetLabel(o) : o.title) } : null,
+      target: o ? { kind: o.kind || 'direct', provider: o.provider, model: o.model, effort: o.effort, accountId: o.accountId || null, label: o.label || (o.here ? routeTargetLabel(o) : o.title) } : null,
       alternatives: allOptions().filter(x => x.id !== state.selectedId).map(x => ({ provider: x.provider, model: x.model, effort: x.effort, label: x.label })),
     };
   }
@@ -926,6 +987,9 @@ export function renderRouteCard(container, input, hooks = {}) {
     state.line = line;
     state.collapsed = true;
     state.resolved = true;
+    // No longer waits: the renderer puts it back from the open card's slot at the transcript's bottom
+    // (asst-ask-tail.js) before it becomes the route line in its own place.
+    try { card._ask?.onChange?.(); } catch { /* the renderer is gone */ }
     if (card.isConnected) card.replaceWith(line.el);
     try { hooks.onCollapse?.(n.routeId, line); } catch { /* ignore */ }
     if (hadFocus) { try { hooks.onDone?.(); } catch { /* ignore */ } }
@@ -937,6 +1001,8 @@ export function renderRouteCard(container, input, hooks = {}) {
     if (state.line?.el?.isConnected) state.line.el.replaceWith(card);
     state.collapsed = false;
     state.resolved = false;
+    // Open again (ROUTE_INVALID): it waits on the user, so it goes back to the bottom slot.
+    try { card._ask?.onChange?.(); } catch { /* the renderer is gone */ }
   }
 
   function clearTimers() {
@@ -955,7 +1021,7 @@ export function renderRouteCard(container, input, hooks = {}) {
   }
 
   function cancel() {
-    if (state.pending || state.resolved) return;
+    if (state.pending || state.resolved || state.expired) return;
     if (!n.decline.allowed) {
       // Nothing to cancel on the server: leave the card and hand focus back.
       try { hooks.onCancel?.(buildRouteCancel(n, 'user'), n); } catch { /* ignore */ }
@@ -1021,11 +1087,16 @@ export function renderRouteCard(container, input, hooks = {}) {
       state.timer = null;
       countdown.textContent = tr('assistant.routes.state.expired', 'route expired');
       syncSelection();
+      // No answer is coming from the user any more: it goes back to its own place (asst-ask-tail.js).
+      try { card._ask?.onChange?.(); } catch { /* the renderer is gone */ }
     }
   }
-  if (expires && Number.isFinite(expires)) { tick(); state.timer = setInterval(tick, 1000); }
+  if (expires && Number.isFinite(expires)) { tick(); if (!state.expired) state.timer = setInterval(tick, 1000); }
 
   renderOptions();
+  // The renderer lifts a card that waits on the user to the transcript's bottom while it is open
+  // (asst-ask-tail.js): a route card waits like a follow-ups set or a question does.
+  card._ask = { el: card, presenter: null, isOpen: () => !state.collapsed && !state.resolved && !state.expired, onChange: null };
   if (container) container.appendChild(card);
   try { hooks.scrollEnd?.(); } catch { /* ignore */ }
 

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

@@ -118,6 +118,8 @@ export function runChip(run, t = tFallback) {
   const tone = runTone(run);
   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;

package/neural-interface/public/shared/assistant/asst-sidepanel.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,7 @@ let _toastTimer = null;
 let _renaming = false;
 const _tabs = [];   // { sessionId, viewport, toolbar, ctl, pill, label, userRenamed, status, brain }
 let _activeIdx = -1;
+let _tourPresenting = false;
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -408,13 +410,13 @@ 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 });
+    const res = await openAssistant(prompt ? { host: HOST_ID, prompt } : { host: HOST_ID });
     if (!_tabs.length) renderPlaceholder(res ? null : 'failed');
   } finally {
     _starting = false;
@@ -563,8 +565,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 +619,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']
+    .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()) {

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

@@ -7,7 +7,7 @@
 import { 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',
@@ -219,10 +219,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 +236,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 +246,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;
 }

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

@@ -64,7 +64,7 @@ export const DEFAULT_BRAIN = Object.freeze({
   effort: null,
   agent: null,
   project: null,
-  mcpProfile: '',
+  tools: Object.freeze(['all']),
   accountId: null,
   permissionMode: 'default',
   planMode: false,
@@ -105,7 +105,7 @@ export function normalizeBrain(raw, fallback = DEFAULT_BRAIN) {
     effort: str(src.effort) || null,
     agent: provider === 'opencode' ? (str(src.agent) || null) : null,
     project: str(src.project ?? src.cwd) || null,
-    mcpProfile: str(src.mcpProfile),
+    tools: provider === 'opencode' ? (Array.isArray(src.tools) ? [...src.tools] : null) : ['all'],
     accountId: ACCOUNT_PROVIDERS.has(provider) ? (str(src.accountId) || null) : null,
     permissionMode: modes.some(m => m.id === mode) ? mode : 'default',
     planMode: PLAN_MODE_PROVIDERS.has(provider) && (src.planMode === true || legacyPlan),
@@ -145,7 +145,7 @@ function pickDefault(list) {
  *   efforts: { [provider]: [{ id, tier? }] },
  *   accounts: { [provider]: [{ id, label }] },
  *   agents: [{ name, mode? }],                 // OpenCode
- *   mcpProfiles: { [id]: { label } }, defaultMcpProfile,
+ *   toolCatalog: { default, groups },
  *   projects: [{ path, label }],
  * }
  */
@@ -188,14 +188,8 @@ export function resolveBrainDefaults(brain, catalog = {}) {
     b.accountId = null;
   }
 
-  const profiles = catalog.mcpProfiles && typeof catalog.mcpProfiles === 'object' ? catalog.mcpProfiles : null;
-  if (profiles) {
-    const ids = Object.keys(profiles);
-    if (ids.length && !ids.includes(b.mcpProfile)) {
-      b.mcpProfile = ids.includes(catalog.defaultMcpProfile) ? catalog.defaultMcpProfile : (ids.includes('full') ? 'full' : ids[0]);
-    }
-  } else if (!b.mcpProfile && catalog.defaultMcpProfile) {
-    b.mcpProfile = catalog.defaultMcpProfile;
+  if (b.provider === 'opencode' && b.tools == null && catalog.toolCatalog) {
+    b.tools = [...new Set([...(catalog.toolCatalog.default || []).filter(id => id !== 'git'), 'browser'])];
   }
 
   if (!b.project && Array.isArray(catalog.projects) && catalog.projects.length === 1) {
@@ -285,7 +279,7 @@ export function emptyProjectView(project, projects = [], tr = (_key, fallback, p
 export function brainRequiresSwitch(a, b) {
   const x = normalizeBrain(a);
   const y = normalizeBrain(b);
-  return x.provider !== y.provider || x.accountId !== y.accountId || x.mcpProfile !== y.mcpProfile;
+  return x.provider !== y.provider || x.accountId !== y.accountId || JSON.stringify(x.tools) !== JSON.stringify(y.tools);
 }
 
 // ── Runs ────────────────────────────────────────────────────────────────────
@@ -295,9 +289,11 @@ export function isTerminalRunStatus(status) {
 }
 
 // Dispatcher views carry `state` (queued, awaiting_route, starting, running,
-// idle, awaiting_permission, completed, failed, stopped, interrupted); runtime
-// descriptors (sidepanel:run-*) carry `status`. The tray reads `status`.
-const STATE_STATUS = { queued: 'queued', awaiting_route: 'queued', starting: 'starting', running: 'running', idle: 'running', awaiting_permission: 'running' };
+// idle, awaiting_permission, suspended, resuming, completed, failed, stopped,
+// interrupted); runtime descriptors (sidepanel:run-*) carry `status`. The tray
+// reads `status`. A run a server restart suspended is still running; one being
+// resumed is starting.
+const STATE_STATUS = { queued: 'queued', awaiting_route: 'queued', starting: 'starting', running: 'running', idle: 'running', awaiting_permission: 'running', suspended: 'running', resuming: 'starting' };
 
 export function runStatusFromState(state) {
   const value = str(state);

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

@@ -0,0 +1,127 @@
+// ═══════════════════════════════════════════
+// SynaBun Assistant — what a stop names
+// ═══════════════════════════════════════════
+// Pure module (no DOM, no i18n import) so node:test can exercise it.
+//
+// A stop ends the work the user named and nothing else:
+//   resolveStopTarget   `/stop <target>`: the one run of this session the target names (its id, the
+//                       start of its id, its title or the words of its title), or why it names none.
+//                       Two candidates stop nothing: the user picks one.
+//   createConfirmGate   the agents tray's "Stop all": the first press arms it, a second press inside
+//                       the window stops every run of the session at once. A single stray click, a
+//                       double click or a held key never does (2026-10-24: one "Stop all" press
+//                       ended both runs of a session while the user meant one of them).
+// Words the user types to stop everything ("stop", "cancel") go to the brain, which stops runs
+// with agent_stop (assistant-persona.js): nothing here reads a message.
+
+import { isTerminalRunStatus } from './asst-state.js';
+
+/** How long an armed "Stop all" waits for its second press, and the least time between the two. */
+export const STOP_ALL_CONFIRM_MS = 4000;
+export const STOP_ALL_MIN_GAP_MS = 300;
+
+// Words that say "a run" without saying which one: "/stop the OpenCode settings run" names it by the rest.
+const FILLER = new Set(['the', 'a', 'an', 'that', 'this', 'my', 'our', 'one', 'run', 'runs', 'agent', 'agents', 'worker', 'workers', 'task', 'job', 'please', 'o', 'os', 'as', 'do', 'da', 'de']);
+const FULL_RUN_ID = /^[0-9a-f]{32}$/i;
+const ID_PREFIX = /^[0-9a-f][0-9a-f-]{3,}$/i;
+
+function words(text) {
+  return String(text ?? '').toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+}
+
+function unquote(text) {
+  const s = String(text ?? '').trim();
+  const m = s.match(/^(["'“‘])([\s\S]*)(["'”’])$/);
+  return m ? m[2].trim() : s;
+}
+
+/**
+ * The run `/stop <target>` names among `runs` (the tray's runs of this session).
+ * → { run, by: 'id' | 'prefix' | 'title' | 'words' }
+ *   | { error: 'empty' | 'none' | 'finished' | 'ambiguous', matches?: run[], run? }
+ * An exact id names that run whatever its state (the server says when it already ended). Every
+ * other way names a run that still works; one that ended is `finished`. A full id the tray does not
+ * know is handed on as `{ error: 'none', passthrough: id }`: the server knows more runs than a tray.
+ */
+export function resolveStopTarget(target, runs = []) {
+  const raw = unquote(target);
+  if (!raw) return { error: 'empty' };
+  const list = (Array.isArray(runs) ? runs : []).filter((run) => run && run.runId && run.removed !== true);
+  const live = list.filter((run) => !isTerminalRunStatus(run.status));
+  const one = (matches, by) => {
+    if (matches.length === 1) return isTerminalRunStatus(matches[0].status) ? { error: 'finished', run: matches[0] } : { run: matches[0], by };
+    if (matches.length > 1) return { error: 'ambiguous', matches };
+    return null;
+  };
+  const lower = raw.toLowerCase();
+
+  const exact = list.find((run) => String(run.runId).toLowerCase() === lower);
+  if (exact) return { run: exact, by: 'id' };
+  if (ID_PREFIX.test(raw)) {
+    const byPrefix = one(list.filter((run) => String(run.runId).toLowerCase().startsWith(lower)), 'prefix');
+    if (byPrefix) return byPrefix;
+  }
+
+  const title = (run) => words(run.title || run.task || '').join(' ');
+  const wanted = words(raw).join(' ');
+  if (wanted) {
+    const byTitle = one(live.filter((run) => title(run) === wanted), 'title');
+    if (byTitle) return byTitle;
+  }
+  // The words that say which run: each one is a word of its title, or the start of one.
+  const keys = words(raw).filter((word) => !FILLER.has(word));
+  if (keys.length) {
+    const fits = (run) => { const have = words(run.title || run.task || ''); return keys.every((key) => have.some((word) => word === key || (key.length >= 3 && word.startsWith(key)))); };
+    const byWords = one(live.filter(fits), 'words');
+    if (byWords) return byWords;
+    const ended = list.filter((run) => isTerminalRunStatus(run.status) && (title(run) === wanted || fits(run)));
+    if (ended.length === 1) return { error: 'finished', run: ended[0] };
+  }
+  return FULL_RUN_ID.test(raw) ? { error: 'none', passthrough: raw } : { error: 'none' };
+}
+
+/**
+ * A press that only counts as the second of two. `press()` → 'armed' (the first: `onChange(true)`),
+ * 'confirmed' (the second, inside `windowMs` and at least `minGapMs` after the first:
+ * `onChange(false)`, the caller stops everything) or 'ignored' (too soon after the first: a double
+ * click, a held key). The arm lapses after `windowMs` by itself (`onChange(false)`).
+ */
+export function createConfirmGate({
+  windowMs = STOP_ALL_CONFIRM_MS,
+  minGapMs = STOP_ALL_MIN_GAP_MS,
+  now = Date.now,
+  setTimer = (fn, ms) => setTimeout(fn, ms),
+  clearTimer = (id) => clearTimeout(id),
+  onChange = () => {},
+} = {}) {
+  let armedAt = null;
+  let timer = null;
+  const notify = (armed) => { try { onChange(armed); } catch { /* the button is gone */ } };
+  function reset() {
+    if (timer !== null) { clearTimer(timer); timer = null; }
+    if (armedAt === null) return false;
+    armedAt = null;
+    notify(false);
+    return true;
+  }
+  function press() {
+    const at = now();
+    // An arm whose timer never ran (a throttled background tab) has lapsed all the same.
+    if (armedAt !== null && at - armedAt > windowMs) reset();
+    if (armedAt === null) {
+      armedAt = at;
+      timer = setTimer(() => { timer = null; reset(); }, windowMs);
+      notify(true);
+      return 'armed';
+    }
+    if (at - armedAt < minGapMs) return 'ignored';
+    reset();
+    return 'confirmed';
+  }
+  return {
+    press,
+    reset,
+    isArmed: () => armedAt !== null,
+    destroy() { if (timer !== null) { clearTimer(timer); timer = null; } armedAt = null; },
+  };
+}