synabun 2.0.0 → 2.0.5

package/neural-interface/public/shared/ui-sidepanel-runtime.js

@@ -11,7 +11,8 @@ export function routeSidepanelEvent(event, data) {
   const host = sidepanelHost();
   if (!host) return false;
   if (hostedSidepanelId) {
-    if (!['open-plan-editor', 'open-changelog-editor', 'browser:reconnect'].includes(event)) return false;
+    // The code editor lives in the main window: what opens it from a detached session goes there.
+    if (!['open-plan-editor', 'open-changelog-editor', 'open-file-editor', 'browser:reconnect'].includes(event)) return false;
     host.emitFromSession(hostedSidepanelId, event, data);
     return true;
   }

package/neural-interface/public/shared/ui-sync.js

@@ -74,6 +74,18 @@ const SYNC_HANDLERS = {
   // Assistant → Models toggles (every provider): the Assistant's model menus,
   // Routes editor and Models manager reload their lists.
   'assistant:hidden-models-changed': (msg) => emit('sync:assistant:hidden-models-changed', msg),
+  // A provider lists other models than before (CLI update, account change, OpenCode
+  // provider connected): the same menus reload.
+  'assistant:catalog-changed': (msg) => emit('sync:assistant:catalog-changed', msg),
+
+  // Settings → Automation behavior switched in another window: an open Settings follows.
+  'assistant:user-context-changed': (msg) => emit('sync:assistant:user-context-changed', msg),
+
+  // Code editor preferences saved in another window (word wrap, font size…): the editor follows.
+  'editor:config-changed': (msg) => emit('sync:editor:config-changed', msg),
+
+  // Settings → Greeting switched in another window: an open Settings follows.
+  'greeting:changed': (msg) => emit('sync:greeting:changed', msg),
 
   // Card sync (relayed from other clients)
   'card:opened':    (msg) => emit('sync:card:opened', msg),
@@ -178,6 +190,10 @@ const SYNC_HANDLERS = {
   // Skin change sync
   'skin:changed': (msg) => emit('sync:skin:changed', msg),
 
+  // The server says it is restarting, before it goes: every window shows the
+  // restart, not only the one that asked for it (ui-loading.js).
+  'server:restarting': (msg) => emit('server:restarting', msg),
+
   // Session indexing progress
   'indexing:started':          (msg) => emit('ws:message', msg),
   'indexing:session-started':  (msg) => emit('ws:message', msg),

package/neural-interface/public/shared/ui-terminal.js

@@ -20,7 +20,7 @@ import { readinessKind, typeWhenReady } from './term-ready.js';
 import { initRendererManager, acquireRenderer, disposeRenderer, hasWebgl, noteFocus, adoptRenderer, rendererState, rendererStats } from './term-renderer.js';
 import { mountAssistant } from './assistant/asst-panel.js';
 import { getAssistantSession } from './assistant/asst-api.js';
-import { brainLabel, normalizeBrain, readStoredBrain } from './assistant/asst-state.js';
+import { brainLabel, normalizeBrain, readStoredBrain, restoredSessionName, sessionNameGivenUp } from './assistant/asst-state.js';
 import { initAssistant, registerAssistantHost, openAssistant, assistantOwnerOf, fetchLiveAssistantSessions, isAssistantSessionLive } from './ui-assistant.js';
 
 const $ = (id) => document.getElementById(id);
@@ -3467,7 +3467,7 @@ function _updateAssistantBrainChip(session) {
   chip.hidden = !label;
 }
 
-/** After a tab/float rename, push the new label into the panel (marks it user-renamed). */
+/** After a tab/float rename, push the new label into the panel (marks it user-renamed; the panel writes it to the session record). */
 function _syncAssistantLabel(session) {
   if (!session?._isAssistant || !session._assistant) return;
   if (session._assistant.getTitle() !== session.label) session._assistant.setTitle(session.label);
@@ -3484,6 +3484,11 @@ function _mountAssistantSession(sessionId, { meta = null, saved = null, brain =
   if (existing) { if (!_restoringLayout) _focusAssistantTab(existing); return existing; }
 
   const resolvedBrain = normalizeBrain(brain || meta?.brain || saved?.brain || readStoredBrain(storage));
+  // A renamed session comes back under its name: the session record's (a rename made in either
+  // host, the one the Sessions menu lists), else the rename saved with this tab. A record whose
+  // name was given up says so: the label and the renamed flag saved with a tab are stale.
+  const named = restoredSessionName(meta, label);
+  const givenUp = sessionNameGivenUp(meta);
   const viewport = document.createElement('div');
   viewport.className = 'term-viewport assistant-viewport';
   viewport.dataset.sessionId = sessionId;
@@ -3495,13 +3500,13 @@ function _mountAssistantSession(sessionId, { meta = null, saved = null, brain =
     id: sessionId,
     profile: 'assistant',
     cwd: resolvedBrain.project || null,
-    label: label || saved?.label || meta?.title || profileDef?.label || 'Assistant',
+    label: named || (givenUp ? '' : saved?.label) || meta?.title || profileDef?.label || 'Assistant',
     term: null, fitAddon: null, searchAddon: null,
     ws: null,               // no PTY socket — the panel owns /ws/assistant/:id
     viewport, ro: null, renderer: null,
     dead: false,
     pinned: saved?.pinned || false,
-    _userRenamed: saved?.userRenamed || !!label,
+    _userRenamed: !givenUp && (saved?.userRenamed || !!named),
     _floatColor: saved?.floatColor || null,
     _isAssistant: true,     // flag for tab-type-specific logic
     _assistant: null,       // controller (set right after mount)
@@ -3525,6 +3530,19 @@ function _mountAssistantSession(sessionId, { meta = null, saved = null, brain =
       if (titleEl && titleEl.contentEditable !== 'true') titleEl.textContent = next;
       saveSessionRegistry();
     },
+    // A rename the panel could not save: the tab and its saved label go back to the record's name.
+    setName(text, renamed) {
+      const s = live();
+      const next = String(text || '').trim();
+      if (!next) return;
+      s.label = next;
+      s._userRenamed = !!renamed;
+      renderTabBar();
+      const titleEl = _detachedTabs.get(sessionId)?.el?.querySelector('.term-float-tab-title');
+      if (titleEl && titleEl.contentEditable !== 'true') titleEl.textContent = next;
+      saveSessionRegistry();
+      saveTerminalLayout();
+    },
     setStatus(status) { setSessionStatusBadge(sessionId, status); },
     setBrain(b) {
       const s = live();
@@ -3539,7 +3557,7 @@ function _mountAssistantSession(sessionId, { meta = null, saved = null, brain =
     requestDetach() { const idx = _sessions.findIndex(s => s.id === sessionId); if (idx >= 0 && !_detachedTabs.has(sessionId)) detachTab(idx); },
   };
   session._assistant = mountAssistant(viewport, { sessionId, brain: resolvedBrain, host, session: meta, label: session.label, reattach });
-  if (session._userRenamed && session.label) session._assistant.setTitle(session.label);
+  if (session._userRenamed && session.label) session._assistant.setTitle(session.label, { restored: true });
 
   renderTabBar();
   if (_restoringLayout) {

package/neural-interface/public/shared/ui-tunnel.js

@@ -0,0 +1,130 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — the public address: the page side
+// ═══════════════════════════════════════════
+//
+// What the two cards that start the Cloudflare tunnel share (the Share menu's
+// Connection block in ui-invite.js, Settings → Automations → Online access in
+// ui-settings.js): asking the server, starting and stopping, asking again
+// while something is on its way (a download, the wait for an address), and
+// the reading of each answer in the page's language. What an answer means is
+// tunnel-view.js; how it is drawn is each card's own.
+//
+// The requests are sent with fetch as they are: same origin, no body. The
+// server takes a start or a stop from the app's own pages only
+// (lib/http-guards.js ownerRouteGuard), and a refusal is shown in the card
+// like any other failure, not as the app-wide "forbidden" notice.
+
+import { getLocale, t } from './i18n.js';
+import { tunnelView } from './tunnel-view.js';
+
+const POLL_MS = 1000;
+/** How long a card keeps asking by itself. A download or a start that takes longer is shown again on the next look. */
+const POLL_LIMIT_MS = 20 * 60 * 1000;
+
+const translate = (key, params) => t(`tunnel.${key}`, params);
+function number(value, digits) {
+  try { return value.toLocaleString(getLocale(), { minimumFractionDigits: digits, maximumFractionDigits: digits }); } catch { return value.toFixed(digits); }
+}
+
+/** tunnel-view.js tunnelView() in the page's language. */
+export function readTunnel(status) {
+  return tunnelView(status, { t: translate, number });
+}
+
+/** The sentence a card shows where it offers the remote MCP address and no access key exists. */
+export function mcpKeyNeededText() {
+  return translate('mcpKeyNeeded');
+}
+
+async function ask(path, method = 'GET') {
+  const res = await fetch(path, { method });
+  let body = null;
+  try { body = await res.json(); } catch { body = null; }
+  return { status: res.status, ok: res.ok, body };
+}
+
+/**
+ * One card's hold on the tunnel.
+ *
+ * @param {object} [o]
+ * @param {(view: object, status: object | null) => void} [o.onChange] called with every new reading
+ * @param {() => boolean} [o.alive] false once the card is gone: the asking-again stops
+ * @returns {{ view: () => object, status: () => (object | null), show: (status: object) => object,
+ *   refresh: () => Promise<object>, start: () => Promise<object>, stop: () => Promise<object>, dispose: () => void }}
+ */
+export function createTunnelCard({ onChange = () => {}, alive = () => true } = {}) {
+  let status = null;
+  let timer = null;
+  let since = 0;
+  let disposed = false;
+
+  function schedule(view) {
+    clearTimeout(timer);
+    timer = null;
+    if (disposed || !view.poll || !alive()) { since = 0; return; }
+    if (!since) since = Date.now();
+    if (Date.now() - since > POLL_LIMIT_MS) return;
+    timer = setTimeout(refresh, POLL_MS);
+  }
+
+  /** Take an answer as the state of things, tell the card, and ask again later when it will change by itself. */
+  function show(next) {
+    status = next && typeof next === 'object' ? next : null;
+    const view = readTunnel(status);
+    if (!disposed) { try { onChange(view, status); } catch (error) { console.warn('[tunnel] The card could not be drawn:', error); } }
+    schedule(view);
+    return view;
+  }
+
+  async function refresh() {
+    if (disposed) return readTunnel(status);
+    try {
+      const got = await ask('/api/tunnel/status');
+      if (got.ok && got.body) return show(got.body);
+    } catch { /* the server is away for a moment: what is shown stays, and the next look asks again */ }
+    const view = readTunnel(status);
+    schedule(view);
+    return view;
+  }
+
+  /** A start or a stop that the server did not take: shown in the card, with what the card knew before. */
+  function refused(got, error) {
+    // A server from before the tunnel program came with SynaBun answers a start with 400 when no cloudflared is
+    // installed, and its words tell the user to install one. What is missing is a restart: the card says that.
+    if (got?.status === 400 && !status?.cloudflared) return show({ ok: true, available: false, running: false, starting: false, url: null });
+    const failure = got?.status === 403
+      ? { code: 'refused', message: got.body?.error || '' }
+      : { code: 'unknown', message: got?.body?.error || error?.message || '' };
+    return show({ ...(status || {}), ok: true, running: false, starting: false, url: null, state: 'failed', error: failure, cloudflared: status?.cloudflared || { state: 'missing' } });
+  }
+
+  async function send(path) {
+    let got = null;
+    try { got = await ask(path, 'POST'); } catch (error) { return refused(null, error); }
+    if (!got.ok || got.body?.ok === false) return refused(got);
+    return refresh();
+  }
+
+  return {
+    view: () => readTunnel(status),
+    status: () => status,
+    show,
+    refresh,
+    start: () => send('/api/tunnel/start'),
+    stop: () => send('/api/tunnel/stop'),
+    dispose() { disposed = true; clearTimeout(timer); timer = null; },
+  };
+}
+
+/**
+ * Put new markup into a card's block without disturbing the person using it: nothing happens when the markup is
+ * what is there already, and a button that had the keyboard's focus has it again afterwards (by its id).
+ */
+export function drawInto(container, html) {
+  if (!container || container.__tunnelHtml === html) return false;
+  const focused = container.contains(document.activeElement) ? document.activeElement?.id : '';
+  container.innerHTML = html;
+  container.__tunnelHtml = html;
+  if (focused) { try { container.querySelector(`#${CSS.escape(focused)}`)?.focus({ preventScroll: true }); } catch { /* the button is gone with its state */ } }
+  return true;
+}

package/neural-interface/public/shared/ui-tutorial-steps.js

@@ -82,11 +82,15 @@ const ASSISTANT_BUTTON = ['#topright-assistant-panel-btn', 'closed'];
 const ACTIVE_TAB = '#assistant-panel.open .asp-viewport.active';
 const ACTIVE_BAR = '#assistant-panel.open .asp-tab-bar.active';
 
+// With the workspace tools hidden (the toolbar's toggle) their controls are off screen, and the step outlines the
+// toggle that shows them.
+const TOOLS_TOGGLE = ['#topright-tools-btn'];
+
 export const FEATURE_STEPS = [
-  { id: 'explain-memory-explorer', chapter: 'memory', targets: [['#topright-memory-explorer-btn']] },
+  { id: 'explain-memory-explorer', chapter: 'memory', targets: [['#topright-memory-explorer-btn'], TOOLS_TOGGLE] },
   { id: 'explain-graph', chapter: 'memory', copy: { '2d': 'body2d' }, targets: [['[data-menu="graph"] > .menubar-label']] },
   { id: 'explain-focus', chapter: 'workspace', targets: [['#wb-toolbar'], ['#titlebar-viz-toggle', 'graph']] },
-  { id: 'explain-workspaces', chapter: 'workspace', targets: [['#ws-indicator']] },
+  { id: 'explain-workspaces', chapter: 'workspace', targets: [['#ws-indicator'], TOOLS_TOGGLE] },
   { id: 'explain-terminals', chapter: 'tools', menu: 'apps', targets: [['#menu-terminal-claude', 'body', '#menu-terminal-opencode']] },
   { id: 'explain-browser', chapter: 'tools', menu: 'apps', targets: [['#menu-terminal-browser']] },
   { id: 'explain-side-panel', chapter: 'tools', targets: [['#topright-claude-panel-btn', 'body', '#topright-opencode-panel-btn']] },

package/neural-interface/public/shared/ui-whiteboard.js

@@ -2882,6 +2882,11 @@ export function isSidepanelKeyTarget(el) {
   return !!el?.closest?.('[data-sidepanel-provider]');
 }
 
+// A key pressed inside the File Explorer's code editor (shared/editor/editor-panel.js) is the editor's.
+export function isEditorPanelKeyTarget(el) {
+  return !!el?.closest?.('#fe-editor-panel');
+}
+
 function onKeyDown(e) {
   if (!isWhiteboardActive()) return;
 
@@ -2897,6 +2902,13 @@ function onKeyDown(e) {
   // Nor while it is inside a side panel: Escape there stops a turn, and Delete, Backspace or
   // Ctrl+A/Z/C on one of its controls is not a board edit.
   if (isSidepanelKeyTarget(e.target) || isSidepanelKeyTarget(ae)) return;
+  // Nor while it is inside the code editor's panel: on one of its tabs, header or status-bar buttons, in one of
+  // its menus, its palette or its popover (all attached inside the panel), M, Delete, Backspace or
+  // Ctrl+A/Z/Y/C is the editor's key, or nobody's, and never a board edit.
+  if (isEditorPanelKeyTarget(e.target) || isEditorPanelKeyTarget(ae)) return;
+  // Nor while it is in the File Explorer, or in what it opens over the page (its menu, preview and questions):
+  // Delete there deletes a file, and a letter is the name of a row being typed.
+  if (ae?.closest?.('#file-explorer-panel, .fe-ctx-flyout, .fe-modal-overlay, .fe-git-popover')) return;
 
   const isEditingText = !!document.activeElement?.closest('.wb-text.editing');
   const editingListLi = document.activeElement?.closest('.wb-list.editing li') || null;

package/neural-interface/public/shared/ui-worker-end.js

@@ -0,0 +1,245 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — how a dispatched worker's tab ends: the page side
+// ═══════════════════════════════════════════
+//
+// What the three provider sidepanels (Claude Code, Codex, OpenCode) share for
+// the end of a worker the Assistant dispatched: following the run until it
+// has something to show, asking the dispatcher how it went (GET
+// /api/assistant/runs/:runId, then its `assistant:dispatch` events), the card
+// itself, and the way back to the Assistant session that dispatched it. What
+// the card says is worker-end.js; where it goes in a transcript, how it looks
+// and how its tab closes are each panel's own (every panel passes its own
+// classes and its own close action, so the card wears that panel's styles).
+//
+// The way back closes the worker's tab with the close the panel's own X runs
+// (it never deletes the run record: the Assistant still reads its result, and
+// the agents dock still lists it) and then shows the session through
+// `assistant:show` with the sidepanel as the host for a session that is open
+// nowhere: the terminal tab or the sidepanel that has it keeps it. Closing the
+// tab of a worker that finished its task completes its run instead of
+// stopping it (endWorkerRunOnClose): the Assistant reads it as done, never as
+// stopped by the user.
+
+import { emit, on } from './state.js';
+import { t } from './i18n.js';
+import { TERMINAL_STATES, WORKER_END_CLASS, isDispatchedRun, isRunWorking, mayHaveEnded, workerEndView } from './worker-end.js';
+
+export { WORKER_END_CLASS };
+
+const translate = (key, params) => t(`workerEnd.${key}`, params);
+
+// runId → { run, dispatch, settled, wasWorking, busy, apply, readKey, sig }
+const _runs = new Map();
+let _wired = false;
+
+function newer(next, current) {
+  if (!current) return true;
+  const a = Number(next?.version) || 0;
+  const b = Number(current?.version) || 0;
+  if (a !== b) return a > b;
+  return String(next?.updatedAt || '') >= String(current?.updatedAt || '');
+}
+
+function wire() {
+  if (_wired) return;
+  _wired = true;
+  // Every change of a run the dispatcher makes (a turn, a result, the end, a
+  // failure's cause judged later) reaches the tab without another request.
+  on('sync:assistant:dispatch', (message) => {
+    const view = message?.run;
+    const entry = view?.runId ? _runs.get(view.runId) : null;
+    if (!entry || !newer(view, entry.dispatch)) return;
+    noteDispatch(entry, view);
+    paint(entry);
+  });
+}
+
+function noteDispatch(entry, view) {
+  entry.dispatch = view;
+  entry.settled = true;
+  // What the run was doing before it ended: a stop in the middle of a turn is a stop.
+  if (!TERMINAL_STATES.has(String(view.state || ''))) entry.wasWorking = isRunWorking(null, view);
+}
+
+function paint(entry) {
+  const view = workerEndView(entry.run, entry.dispatch, { t: translate, busy: entry.busy, stoppedMidTurn: entry.wasWorking });
+  // An ended run is drawn once the dispatcher has answered: never "Stopped" first and "Task complete" a moment later.
+  if (view && !entry.settled) return;
+  const sig = view?.sig || '';
+  if (sig === entry.sig) return;
+  entry.sig = sig;
+  try { entry.apply(view); } catch (error) { console.warn('[worker-end] a panel failed to draw the end of a run', error); }
+}
+
+async function read(entry) {
+  const run = entry.run;
+  const key = `${run.status}|${run.turnState || ''}|${run.version || 0}`;
+  if (entry.readKey === key) return;
+  entry.readKey = key;
+  try {
+    const response = await fetch(`/api/assistant/runs/${encodeURIComponent(run.runId)}`);
+    const data = response.ok ? await response.json() : null;
+    if (_runs.get(run.runId) !== entry) return;
+    if (data?.run && newer(data.run, entry.dispatch)) noteDispatch(entry, data.run);
+  } catch {
+    if (_runs.get(run.runId) !== entry) return;
+  }
+  // No answer (an older server, a run the dispatcher no longer keeps): the runtime's own reading is drawn.
+  entry.settled = true;
+  paint(entry);
+}
+
+/**
+ * Follow a run attached to a provider tab. Call it on every attach (the
+ * router attaches again on each change of the run): `apply(view)` is called
+ * with the card to show, or null to take it away, only when that changes.
+ * A run the Assistant did not dispatch gets `apply(null)` and is not followed.
+ *
+ * @param {object} run the runtime descriptor the panel was attached with
+ * @param {object} o
+ * @param {(view: object | null) => void} o.apply draw the card (or remove it)
+ * @param {boolean} [o.busy] the tab sees background work of the run still going
+ */
+export function trackWorkerEnd(run, { apply, busy = false } = {}) {
+  if (!run?.runId || typeof apply !== 'function') return;
+  if (!isDispatchedRun(run)) {
+    _runs.delete(run.runId);
+    apply(null);
+    return;
+  }
+  wire();
+  let entry = _runs.get(run.runId);
+  if (!entry) {
+    entry = { run: null, dispatch: null, settled: false, wasWorking: false, busy: false, apply, readKey: '', sig: null };
+    _runs.set(run.runId, entry);
+  }
+  entry.apply = apply;
+  entry.busy = !!busy;
+  if (newer(run, entry.run)) entry.run = run;
+  if (!TERMINAL_STATES.has(String(entry.run.status || '')) && !TERMINAL_STATES.has(String(entry.dispatch?.state || ''))) {
+    entry.wasWorking = isRunWorking(entry.run, null);
+  }
+  paint(entry);
+  if (mayHaveEnded(entry.run)) read(entry);
+}
+
+/** The tab saw its background work change: the card of a warm worker waits for it. */
+export function updateWorkerEndBusy(runId, busy) {
+  const entry = _runs.get(runId);
+  if (!entry || entry.busy === !!busy) return;
+  entry.busy = !!busy;
+  paint(entry);
+}
+
+/** The tab of the run closed (or let the run go): stop following it. */
+export function forgetWorkerEnd(runId) {
+  if (runId) _runs.delete(runId);
+}
+
+/**
+ * The run reported its task done and waits warm for a follow-up, with no
+ * background work of its own going: its card is (or would be) a warm "Task
+ * complete". Known only for a run the tab follows, so ask before forgetWorkerEnd().
+ */
+export function isFinishedWarmWorker(runId, { busy = false } = {}) {
+  const entry = runId ? _runs.get(runId) : null;
+  if (!entry?.settled || !entry.run) return false;
+  const view = workerEndView(entry.run, entry.dispatch, { busy: busy || entry.busy, stoppedMidTurn: entry.wasWorking });
+  return view?.kind === 'complete' && view.warm;
+}
+
+/**
+ * End the run of a worker tab the user closes (its X, or Back to Assistant).
+ * A worker that finished its task and waits warm for a follow-up is completed
+ * (POST /api/assistant/runs/:runId/tab-closed: completed, reason `tab_closed`,
+ * its result untouched). Any other run, a run the server finds working after
+ * all, and a server without that route get `stop()`: the panel's own stop,
+ * what its X always did. Decided when called: call it before forgetWorkerEnd().
+ *
+ * @param {string} runId
+ * @param {() => void} stop the panel's stop (POST /api/loop/stop)
+ * @param {object} [o]
+ * @param {boolean} [o.busy] the tab sees background work of the run still going
+ * @returns {Promise<'completed' | 'stopped'>}
+ */
+export function endWorkerRunOnClose(runId, stop, { busy = false } = {}) {
+  const stopped = () => { stop(); return 'stopped'; };
+  if (!isFinishedWarmWorker(runId, { busy })) return Promise.resolve(stopped());
+  return fetch(`/api/assistant/runs/${encodeURIComponent(runId)}/tab-closed`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: '{}',
+  }).then(async (response) => {
+    const data = response.ok ? await response.json().catch(() => null) : null;
+    return data?.ok ? 'completed' : stopped();
+  }).catch(stopped);
+}
+
+/**
+ * Show the Assistant session that dispatched a run: focused where it is open
+ * (the terminal tab or the sidepanel), else opened in the Assistant sidepanel.
+ */
+export function backToAssistant(assistantSessionId) {
+  if (!assistantSessionId) return false;
+  emit('assistant:show', { sessionId: assistantSessionId, host: 'sidepanel' });
+  return true;
+}
+
+/**
+ * The card. Every element takes the owning panel's classes, so it is drawn in
+ * that panel's type and colours; `data-tone` (ok, warn, err, off) is what the
+ * panel's styles colour the title by, and the title always says the state in
+ * words. The button is there only for a run with a dispatching session, and
+ * works once.
+ *
+ * @param {object} view a workerEndView() result
+ * @param {object} [o]
+ * @param {{ card?: string, title?: string, detail?: string, meta?: string, note?: string, actions?: string, button?: string }} [o.classes]
+ * @param {(view: object) => (void | boolean | Promise<void | boolean>)} [o.onBack] close the tab, then
+ *   backToAssistant(); `false` when the tab stayed (the button works again)
+ */
+export function buildWorkerEndCard(view, { classes = {}, onBack = null } = {}) {
+  const card = document.createElement('div');
+  card.className = [WORKER_END_CLASS, classes.card].filter(Boolean).join(' ');
+  card.dataset.workerEnd = view.kind;
+  card.dataset.tone = view.tone;
+  card.setAttribute('role', 'status');
+
+  const title = document.createElement('div');
+  title.className = ['worker-end-title', classes.title].filter(Boolean).join(' ');
+  title.textContent = view.title;
+  card.appendChild(title);
+
+  for (const part of ['detail', 'meta', 'note']) {
+    if (!view[part]) continue;
+    const el = document.createElement('div');
+    el.className = [`worker-end-${part}`, classes[part]].filter(Boolean).join(' ');
+    el.textContent = view[part];
+    card.appendChild(el);
+  }
+
+  if (view.assistantSessionId && typeof onBack === 'function') {
+    const actions = document.createElement('div');
+    actions.className = ['worker-end-actions', classes.actions].filter(Boolean).join(' ');
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.className = ['worker-end-back', classes.button].filter(Boolean).join(' ');
+    button.textContent = view.backLabel;
+    button.title = view.backHint;
+    button.addEventListener('click', () => {
+      if (button.disabled) return;
+      button.disabled = true;
+      Promise.resolve()
+        .then(() => onBack(view))
+        // `false`: the panel asked first and the user kept the tab.
+        .then((done) => { if (done === false) button.disabled = false; })
+        .catch((error) => {
+          console.warn('[worker-end] going back to the Assistant failed', error);
+          button.disabled = false;
+        });
+    });
+    actions.appendChild(button);
+    card.appendChild(actions);
+  }
+  return card;
+}

package/neural-interface/public/shared/ui-workspaces.js

@@ -4,7 +4,8 @@
 //
 // Save/load full scene snapshots: open cards, graph node positions,
 // camera state (3D), active category filters, and selection.
-// Floating overlay in top-right of the canvas.
+// The switcher leads the top-right dock; Snap to grid and Tile terminals are on
+// the whiteboard rail and in View.
 // Export/import as JSON for backup.
 //
 // Events emitted:
@@ -20,6 +21,7 @@
 import { state, emit, on } from './state.js';
 import { KEYS } from './constants.js';
 import { storage } from './storage.js';
+import { t } from './i18n.js';
 import { posStore } from './node-positions-store.js';
 import { getVariant } from './registry.js';
 import {
@@ -525,18 +527,13 @@ function updateIndicator() {
   if (!indicator || !nameEl) return;
 
   const activeId = getActiveId();
-  if (activeId) {
-    const workspaces = getWorkspaces();
-    const active = workspaces.find(w => w.id === activeId);
-    if (active) {
-      nameEl.textContent = active.name;
-      indicator.classList.add('has-workspace');
-      return;
-    }
-  }
-
-  nameEl.textContent = 'No workspace';
-  indicator.classList.remove('has-workspace');
+  const active = activeId ? getWorkspaces().find(w => w.id === activeId) : null;
+  nameEl.textContent = active ? active.name : 'No workspace';
+  indicator.classList.toggle('has-workspace', !!active);
+  // The name is cut short in the bar, or not shown at all where the band is narrow: the tooltip has it whole.
+  const label = active ? t('toolbar.workspaceActive', { name: active.name }) : t('toolbar.workspaceNone');
+  indicator.dataset.tooltip = label;
+  indicator.setAttribute('aria-label', label);
 }
 
 
@@ -552,6 +549,7 @@ function openDropdown() {
   _isOpen = true;
   dropdown.style.display = '';
   indicator?.classList.add('open');
+  indicator?.setAttribute('aria-expanded', 'true');
   renderList();
 
   emit('panel:close-all-dropdowns-except', 'workspace');
@@ -565,6 +563,7 @@ function closeDropdown() {
   _isOpen = false;
   dropdown.style.display = 'none';
   indicator?.classList.remove('open');
+  indicator?.setAttribute('aria-expanded', 'false');
 }
 
 function toggleDropdown() {
@@ -668,25 +667,33 @@ export function initWorkspaces() {
     });
   }
 
-  // Grid snap toggle
+  // Grid snap: the whiteboard rail's toggle and View → Snap to grid (the rail shows in Focus Mode only)
   const gridBtn = $('ws-grid-toggle');
+  const gridMenu = $('menu-toggle-grid-snap');
+  const showGridSnap = () => {
+    gridBtn?.classList.toggle('active', state.gridSnap);
+    gridBtn?.setAttribute('aria-pressed', String(state.gridSnap));
+    gridMenu?.classList.toggle('active', state.gridSnap);
+    document.body.classList.toggle('grid-active', state.gridSnap);
+  };
+  const toggleGridSnap = () => {
+    state.gridSnap = !state.gridSnap;
+    showGridSnap();
+    storage.setItem(KEYS.GRID_SNAP, state.gridSnap);
+  };
+  if (storage.getItem(KEYS.GRID_SNAP) === 'true') {
+    state.gridSnap = true;
+    showGridSnap();
+  }
   if (gridBtn) {
-    const saved = storage.getItem(KEYS.GRID_SNAP);
-    if (saved === 'true') {
-      state.gridSnap = true;
-      gridBtn.classList.add('active');
-      document.body.classList.add('grid-active');
-    }
     gridBtn.addEventListener('click', (e) => {
       e.stopPropagation();
-      state.gridSnap = !state.gridSnap;
-      gridBtn.classList.toggle('active', state.gridSnap);
-      document.body.classList.toggle('grid-active', state.gridSnap);
-      storage.setItem(KEYS.GRID_SNAP, state.gridSnap);
+      toggleGridSnap();
     });
   }
+  if (gridMenu) gridMenu.addEventListener('click', toggleGridSnap);
 
-  // Tile floating terminals
+  // Tile floating terminals: the rail's button and View → Tile terminals
   const tileBtn = $('ws-tile-btn');
   if (tileBtn) {
     tileBtn.addEventListener('click', (e) => {
@@ -694,12 +701,19 @@ export function initWorkspaces() {
       tileFloatingTerminals();
     });
   }
+  const tileMenu = $('menu-tile-terminals');
+  if (tileMenu) {
+    tileMenu.addEventListener('click', () => {
+      emit('panel:close-all-dropdowns');
+      tileFloatingTerminals();
+    });
+  }
 
-  // Close dropdown on click outside
+  // Close dropdown on click outside (the session pills hang inside #topright-controls, but are not the toolbar)
   document.addEventListener('click', (e) => {
     if (!_isOpen) return;
     const container = $('topright-controls') || $('workspace-overlay');
-    if (container && !container.contains(e.target)) {
+    if (container && (!container.contains(e.target) || e.target.closest('#term-minimized-tray'))) {
       closeDropdown();
     }
   });