synabun 2.0.0 → 2.0.7

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

@@ -20,8 +20,8 @@ import { escapeHtml } from './utils.js';
 import * as kit from './settings/settings-kit.js';
 import { emit, on } from './state.js';
 import {
-  waView, confirmLine, formatCountdown, clockTime, levelLabel, modeLabel, chooseNote, connectorSize, brainLimitText,
-  brainChoiceInUse, brainChoiceLabel, brainChoiceNotes,
+  waView, confirmLine, formatCountdown, levelLabel, modeLabel, chooseNote, connectorSize, brainLimitText,
+  brainChoiceInUse, brainChoiceLabel, brainChoiceNotes, connectionWarningText, transcriptionLine,
   localizedCopy, localize, setTranslator,
 } from './whatsapp/wa-view.js';
 import { normalizePhone, PHONE_ERRORS as PHONE_ERROR_SOURCE } from './whatsapp/wa-phone.js';
@@ -59,8 +59,9 @@ const attr = (s) => String(s ?? '').replace(/&/g, '&').replace(/"/g, '"
 const esc = (s) => escapeHtml(String(s ?? ''));
 const num = (n) => Number(n || 0).toLocaleString('en-US');
 const btn = (id, label, cls = '', extra = '') => `<button class="wa-btn${cls ? ` ${cls}` : ''}" id="${id}" type="button" ${extra}>${esc(label)}</button>`;
-// `named`: the row's <strong id="<id>-label"> and <small id="<id>-help"> name and describe the switch.
-const toggle = (id, named = false) => `<label class="recall-toggle"><input type="checkbox" id="${id}"${named ? ` aria-labelledby="${id}-label" aria-describedby="${id}-help"` : ''}><span class="recall-toggle-track"></span></label>`;
+// `named`: the row's <strong id="<id>-label"> and <small id="<id>-help"> name and describe the switch
+// (`alsoDescribedBy`: the id of one more line that describes it, such as a status line).
+const toggle = (id, named = false, alsoDescribedBy = '') => `<label class="recall-toggle"><input type="checkbox" id="${id}"${named ? ` aria-labelledby="${id}-label" aria-describedby="${id}-help${alsoDescribedBy ? ` ${alsoDescribedBy}` : ''}"` : ''}><span class="recall-toggle-track"></span></label>`;
 const tile = (id, label) => `<div class="db-stat"><span class="db-stat-label">${esc(label)}</span><span class="db-stat-value" id="${id}">—</span></div>`;
 const radios = (name, options, invId = '') => `<div class="wa-radios" role="radiogroup"${invId ? ` ${kit.inv(invId)}` : ''}>${options.map((o) => `
   <label class="wa-radio"><input type="radio" name="${name}" value="${attr(o.value)}"><span><strong>${esc(o.label)}</strong>${o.hint ? `<small>${esc(o.hint)}</small>` : ''}</span></label>`).join('')}</div>`;
@@ -114,6 +115,7 @@ export function buildWhatsAppTab() {
       <ol class="wa-steps" id="wa-steps" hidden>${steps}</ol>
 
       ${section({ id: 'wa-sec-setup', badgeId: 'wa-setup-badge', body: `
+        <div class="wa-callout wa-callout-warn" id="wa-conn-warning" role="status" hidden></div>
         <div class="wa-pane" data-pane="loading"><div class="settings-hint">${kit.te('settings.redesign.whatsapp.askingSynabunForTheWhatsappStatus')}</div></div>
         <div class="wa-pane" data-pane="unavailable" hidden><div class="settings-hint" id="wa-unavailable-text"></div></div>
 
@@ -233,6 +235,7 @@ export function buildWhatsAppTab() {
         <div class="settings-field"><label>${kit.te('settings.redesign.whatsapp.longAnswers')}</label>${radios('wa-max', MAX_MESSAGE_OPTIONS, 'WA045')}<div class="settings-hint">${kit.te('settings.redesign.whatsapp.longerAnswersAreCutThereWith')}</div></div>
         <div class="settings-field"><label>${kit.te('settings.redesign.whatsapp.freshConversation')}</label>${radios('wa-rotation', ROTATION_OPTIONS, 'WA046')}</div>
         <div class="settings-field" id="wa-trigger-field"><label>${kit.te('settings.redesign.whatsapp.inMessageYourself')}</label>${radios('wa-trigger', TRIGGER_OPTIONS, 'WA047')}</div>
+        <div class="settings-field wa-toggle-row" id="wa-voice-field" hidden><span><strong id="wa-voice-label">${kit.te('settings.redesign.whatsapp.transcribeVoiceNotes')}</strong><small id="wa-voice-help">${kit.te('settings.redesign.whatsapp.voiceNotesAreTurnedIntoText')}</small><small id="wa-voice-status" role="status"></small></span>${toggle('wa-voice', true, 'wa-voice-status')}</div>
         <div class="settings-field"><label>${kit.te('settings.redesign.whatsapp.commandsYouCanSend')}</label>
           <ul class="wa-commands">${COMMANDS.map((c) => `<li><code>${esc(c.name)}</code> ${esc(c.text)}</li>`).join('')}</ul>
           <div class="settings-hint">${kit.te('settings.redesign.whatsapp.answerAQuestionOrAnApproval')}</div>
@@ -381,6 +384,10 @@ export function wireWhatsAppTab(overlay, { toast = () => {} } = {}) {
     const pane = state.showChoose && ['link_expired', 'logged_out'].includes(status?.state) ? 'choose' : view.pane;
     for (const el of tabBody.querySelectorAll('.wa-pane')) show(el, el.dataset.pane === pane);
     renderPaneActions(view);
+    // A 440 / 403 the link keeps retrying: why, while it lasts (status.warning).
+    const warning = connectionWarningText(status);
+    setText($('wa-conn-warning'), warning);
+    show($('wa-conn-warning'), !!warning);
     renderSetupDetails(status, view, pane);
     renderConnector(status);
     renderConversation(status);
@@ -422,7 +429,7 @@ export function wireWhatsAppTab(overlay, { toast = () => {} } = {}) {
         [kit.tx('settings.redesign.whatsapp.mode'), modeLabel(s.mode)],
         [kit.tx('settings.redesign.whatsapp.account'), [s.account?.name && s.account.name !== '~' ? s.account.name : null, s.account?.masked].filter(Boolean).join(' · ') || '—'],
         [kit.tx('settings.redesign.whatsapp.owner'), s.owner?.masked ? `${s.owner.masked}${s.owner.boundAt ? (" " + kit.tx('settings.redesign.whatsapp.ownerSince', { date: new Date(s.owner.boundAt).toLocaleDateString() })) : ''}` : '—'],
-        [kit.tx('settings.redesign.whatsapp.level'), `${levelLabel(s.level)}${s.level === 'autonomous' && s.levelExpiresAt ? (" " + kit.tx('settings.redesign.whatsapp.levelUntil', { time: clockTime(s.levelExpiresAt) })) : ''}`],
+        [kit.tx('settings.redesign.whatsapp.level'), levelLabel(s.level)],
       ];
       const html = lines.map(([k, v]) => `<div><strong>${esc(k)}</strong> ${esc(v)}</div>`).join('');
       if ($('wa-connected-facts').innerHTML !== html) $('wa-connected-facts').innerHTML = html;
@@ -457,6 +464,13 @@ export function wireWhatsAppTab(overlay, { toast = () => {} } = {}) {
     setRadio('wa-rotation', cfg.rotation);
     setRadio('wa-trigger', cfg.selfTrigger);
     show($('wa-trigger-field'), s.mode !== 'dedicated');
+    // Voice notes (a server without them sends neither the field nor status.transcription: the row stays hidden).
+    const voiceKnown = typeof cfg.transcriptionEnabled === 'boolean' && !!s.transcription;
+    show($('wa-voice-field'), voiceKnown);
+    if (voiceKnown) {
+      setChecked($('wa-voice'), cfg.transcriptionEnabled);
+      setText($('wa-voice-status'), transcriptionLine(s));
+    }
     const session = s.session;
     setText($('wa-session-line'), session?.id ? kit.tx('settings.redesign.whatsapp.sessionCurrent', { title: session.title || kit.tx('settings.redesign.whatsapp.whatsappConversation') }) : kit.tx('settings.redesign.whatsapp.noConversationYetYourFirstMessage'));
     $('wa-open-conversation').disabled = !session?.id;
@@ -562,7 +576,7 @@ export function wireWhatsAppTab(overlay, { toast = () => {} } = {}) {
     const box = $('wa-allow-box');
     const e = state.escalation;
     if (!e || Date.now() > e.expiresAt) { show(box, false); return; }
-    const html = `<strong>${kit.te('settings.redesign.whatsapp.nowOnYourPhone')}</strong> ${kit.te('settings.redesign.whatsapp.send')} <code class="wa-allow-code">ALLOW ${esc(e.code)}</code> ${kit.te('settings.redesign.whatsapp.inTheWhatsappChatWithSynabun')} <span id="wa-allow-countdown">${esc(formatCountdown(e.expiresAt - Date.now()))}</span>${kit.te('settings.redesign.whatsapp.autonomousThenRunsFor8Hours')}`;
+    const html = `<strong>${kit.te('settings.redesign.whatsapp.nowOnYourPhone')}</strong> ${kit.te('settings.redesign.whatsapp.send')} <code class="wa-allow-code">ALLOW ${esc(e.code)}</code> ${kit.te('settings.redesign.whatsapp.inTheWhatsappChatWithSynabun')} <span id="wa-allow-countdown">${esc(formatCountdown(e.expiresAt - Date.now()))}</span>${kit.te('settings.redesign.whatsapp.autonomousUntilTurnedOff')}`;
     if (box.dataset.sig !== e.code) { box.innerHTML = html; box.dataset.sig = e.code; }
     show(box, true);
   }
@@ -847,6 +861,7 @@ export function wireWhatsAppTab(overlay, { toast = () => {} } = {}) {
   radioSave('wa-rotation', 'rotation');
   radioSave('wa-trigger', 'selfTrigger');
   $('wa-forward').addEventListener('change', () => putConfig({ forwardBackground: $('wa-forward').checked }));
+  $('wa-voice').addEventListener('change', () => putConfig({ transcriptionEnabled: $('wa-voice').checked }));
   $('wa-label').addEventListener('input', renderLabelPreview);
   $('wa-label-save').addEventListener('click', () => putConfig({ replyLabel: $('wa-label').value.trim() || null }).then((r) => { if (r.ok !== false) toast(kit.tx('settings.redesign.whatsapp.replyLabelSaved')); }));
 

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();
     }
   });

package/neural-interface/public/shared/whatsapp/wa-view.js

@@ -69,7 +69,7 @@ export const MODE_CARDS = Object.freeze([
 export const LEVEL_CARDS = Object.freeze([
   { id: 'read-only', title: 'Read-only', body: 'SynaBun answers, researches and plans. It never changes files, runs commands or starts agents from WhatsApp; a plan can only be approved on this computer.' },
   { id: 'ask', title: 'Ask on my phone', badge: 'Default', body: 'Before anything that would change your files, run a command or start an agent, SynaBun asks on WhatsApp and acts only on your yes. Any other message approves nothing: the conversation just carries on.' },
-  { id: 'autonomous', title: 'Autonomous', body: 'SynaBun acts without asking, like the Assistant on this computer. Turning it on takes a second click here and an ALLOW code sent from your phone within 5 minutes. It turns back to Ask after 8 hours. Autonomous can read any file your computer account can, including SynaBun\'s WhatsApp login. Use it only with a locked phone, ideally on a second number.' },
+  { id: 'autonomous', title: 'Autonomous', body: 'SynaBun acts without asking, like the Assistant on this computer. Turning it on takes a second click here and an ALLOW code sent from your phone within 5 minutes. It stays on until you turn it off. Autonomous can read any file your computer account can, including SynaBun\'s WhatsApp login. Use it only with a locked phone, ideally on a second number.' },
 ]);
 
 /** Ask and Autonomous need a Claude brain: the Safety warning when the WhatsApp conversation runs on another one (status.brainLimit). */
@@ -155,9 +155,35 @@ export const ROTATION_OPTIONS = Object.freeze([
 ]);
 export const TRIGGER_OPTIONS = Object.freeze([
   { value: 'all', label: 'Every message in "Message yourself"', hint: 'Everything you write in your own chat goes to SynaBun.' },
-  { value: 'prefix', label: 'Only messages that start with sb', hint: 'Keep using "Message yourself" for notes; start a message with sb (or sb:) to talk to SynaBun. Commands like /stop, the ALLOW code and replies to SynaBun\'s own messages always reach it.' },
+  { value: 'prefix', label: 'Only messages that start with sb', hint: 'Keep using "Message yourself" for notes; start a message with sb (or sb:) to talk to SynaBun, or say "sb" first in a voice note. Commands like /stop, the ALLOW code and replies to SynaBun\'s own messages always reach it.' },
 ]);
 
+/** Voice notes (status.transcription): what each missing part is called. */
+export const VOICE_PARTS = Object.freeze({
+  engine: 'whisper.cpp (whisper-cli)',
+  model: 'the speech model (ggml-small.bin)',
+  ffmpeg: 'FFmpeg',
+});
+/**
+ * The line under the voice-note switch: transcribed here, set up but off, or what is missing
+ * ('' for a server without voice notes).
+ */
+export function transcriptionLine(status) {
+  const t = status?.transcription;
+  if (!t || typeof t !== 'object') return '';
+  if (t.available === true) {
+    return t.enabled === false
+      ? say('voice.readyOff', 'Voice notes can be transcribed on this computer; turned off.')
+      : say('voice.ready', 'Voice notes are transcribed on this computer.');
+  }
+  const invalid = Array.isArray(t.invalid) ? t.invalid : [];
+  const parts = (Array.isArray(t.missing) ? t.missing : []).filter((id) => Object.prototype.hasOwnProperty.call(VOICE_PARTS, id)).map((id) => {
+    const name = pick('voice.part', VOICE_PARTS, id);
+    return invalid.includes(id) ? say('voice.partInvalid', '{name}: the path set for it does not work', { name }) : name;
+  });
+  return say('voice.notSetUp', 'Voice notes: not set up — missing {missing}.', { missing: parts.length ? parts.join(', ') : say('voice.part.tools', 'the transcription tools') });
+}
+
 export const COMMANDS = Object.freeze([
   { name: '/status', text: 'what SynaBun is doing, its spend and level' },
   { name: '/stop', text: 'stop the current task, its agents and anything waiting for your answer' },
@@ -170,12 +196,13 @@ export const COMMANDS = Object.freeze([
 ]);
 
 export const LIMITS = Object.freeze([
-  'Text and pictures (up to 4 per message, 5 MB each). Voice notes, videos, documents and stickers are not read yet.',
+  'Text and pictures (up to 4 per message, 5 MB each), and voice notes transcribed on this computer (up to 10 minutes and 20 MB each). Videos, documents and stickers are not read yet.',
   'At most 20 messages a minute and 300 a day; 5 messages can wait in line while SynaBun works.',
   'Messages older than 10 minutes when SynaBun comes back online are skipped (it tells you how many).',
   'Answers are split into messages of 3,500 characters; the rest stays in SynaBun.',
   'Computer use from WhatsApp is off until you turn it on above. Then: never at Read-only or while paused, after one yes per task at Ask on my phone, and without asking while Autonomous is active. Agents started from WhatsApp never get it.',
   'Levels, models and settings change only here, never from the phone.',
+  'A voice note is an ordinary message: it never approves anything and never runs a command. Approvals take a typed yes.',
 ]);
 
 export const PRIVACY_STAYS = Object.freeze([
@@ -213,6 +240,7 @@ export const HELP = Object.freeze({
     'With "Only messages that start with sb", a note without sb never reaches SynaBun and is not logged; commands, the ALLOW code and replies to SynaBun\'s messages always get through.',
     'The QR code expires after about a minute. Press "Show a new code" and scan faster, or link with your phone number instead.',
     'Stuck on "Reconnecting"? Check this computer\'s internet connection, then press Reconnect now.',
+    'Voice notes not transcribed? This computer needs whisper.cpp, its speech model and FFmpeg, which you install yourself; the line under "Transcribe voice notes" says what is missing.',
   ],
   browserTools: 'Not the same as the WhatsApp browser tools. The whatsapp MCP profile lets agents read WhatsApp Web in SynaBun\'s browser; this tab is you chatting with SynaBun from your phone. They do not share a session.',
   uninstall: 'Uninstalling SynaBun does not unlink WhatsApp. Use Unlink or Remove here first, or log SynaBun out under WhatsApp → Settings → Linked devices.',
@@ -252,8 +280,11 @@ export const INSTALL_ERRORS = Object.freeze({
   UNKNOWN: 'Something unexpected happened. The install log has the details.',
 });
 
+// RECONNECT_LIMIT and REPLACED only come from a server older than this page (the link now retries
+// forever, and a 440 is retried with a warning: WARNING_TEXT); HOST_HELD is a connector process of
+// another SynaBun version (crashes are always retried).
 export const ERROR_TEXT = Object.freeze({
-  HOST_HELD: 'The WhatsApp connector kept crashing, so SynaBun stopped it. Reconnect to try again; the install log may help.',
+  HOST_HELD: 'The WhatsApp connector does not match this SynaBun version (it was updated while SynaBun ran), so SynaBun stopped it. Restart SynaBun to load the matching one.',
   HOST_UNAVAILABLE: 'The WhatsApp connector did not start.',
   REPLACED: 'Another copy of this WhatsApp link connected from somewhere else and took over. Reconnect here to take it back.',
   LOCKED: 'Another SynaBun is using the WhatsApp session files. Close it, then reconnect.',
@@ -272,7 +303,20 @@ export const LOGOUT_TEXT = Object.freeze({
   removed: { title: 'Logged out from the phone', sub: 'SynaBun was removed under Linked devices, or WhatsApp ended the session. Link again to keep chatting.' },
   inactive: { title: 'Logged out after a long time offline', sub: 'WhatsApp logs out linked devices that stay offline for a long time. Link again to keep chatting.' },
   banned: { title: 'WhatsApp refused this account', sub: 'WhatsApp blocked the account from linking devices, possibly a temporary or permanent ban. Check the WhatsApp app on the phone.' },
+  invalid_session: { title: 'The saved WhatsApp session is invalid', sub: 'WhatsApp rejected this device session (badSession). Link again to pair it; automatic retries cannot repair the credentials.' },
+});
+
+/** Why a saved session keeps retrying (status.warning: 440 another copy, 403 a refused account). */
+export const WARNING_TEXT = Object.freeze({
+  replaced: 'Another copy is using this WhatsApp session. SynaBun retries every 5 minutes; close the other copy or unlink and link again.',
+  forbidden: 'WhatsApp refused this account; it may be restricted or banned. SynaBun retries every 5 minutes; check WhatsApp on the phone.',
 });
+/** The warning Settings shows while the link retries a 440 / 403 ('' for none, or once the link is not up or retrying). */
+export function connectionWarningText(status) {
+  if (!Object.prototype.hasOwnProperty.call(WARNING_TEXT, status?.warning)) return '';
+  if (!['connected', 'reconnecting', 'paused'].includes(status?.state)) return '';
+  return pick('warning', WARNING_TEXT, status.warning);
+}
 
 export const ACTIVITY_KINDS = Object.freeze({
   inbound: 'Received', reply: 'Sent', ignored: 'Ignored', state: 'Status', security: 'Security', error: 'Problem', settings: 'Settings',
@@ -355,9 +399,8 @@ export function waView(status, { now = Date.now() } = {}) {
     }
     case 'connected': {
       const who = accountLine(s);
-      const until = s.level === 'autonomous' && s.levelExpiresAt ? ` ${say('view.connected.until', 'until {time}', { time: clockTime(s.levelExpiresAt) })}` : '';
       // A Codex / OpenCode brain holds the conversation at read-only whatever the level.
-      const applies = s.brainLimit?.provider ? say('view.connected.readOnlyBrain', 'Read-only ({brain} brain)', { brain: s.brainLimit.label || s.brainLimit.provider }) : `${level}${until}`;
+      const applies = s.brainLimit?.provider ? say('view.connected.readOnlyBrain', 'Read-only ({brain} brain)', { brain: s.brainLimit.label || s.brainLimit.provider }) : level;
       return view('ok', say('view.connected.title', 'Connected'), [mode, who, applies].filter(Boolean).join(' · '), { primary: button('open-conversation', say('button.openConversation', 'Open conversation')), secondary: button('test', say('button.test', 'Send a test message')), step: 'done', pane: 'connected', nav: 'connected' });
     }
     case 'reconnecting': {
@@ -404,8 +447,8 @@ export function localizedCopy() {
     COMMANDS: localize('commands', COMMANDS), LIMITS: localize('limits', LIMITS),
     PRIVACY_STAYS: localize('privacyStays', PRIVACY_STAYS), PRIVACY_NEVER: localize('privacyNever', PRIVACY_NEVER),
     HELP: localize('help', HELP), STAGE_TEXT: localize('stage', STAGE_TEXT), INSTALL_ERRORS: localize('installError', INSTALL_ERRORS),
-    ERROR_TEXT: localize('error', ERROR_TEXT), LOGOUT_TEXT: localize('logout', LOGOUT_TEXT), ACTIVITY_KINDS: localize('activity', ACTIVITY_KINDS),
+    ERROR_TEXT: localize('error', ERROR_TEXT), LOGOUT_TEXT: localize('logout', LOGOUT_TEXT), WARNING_TEXT: localize('warning', WARNING_TEXT), ACTIVITY_KINDS: localize('activity', ACTIVITY_KINDS),
     LEVEL_LABELS: localize('levelLabel', LEVEL_LABELS), PHONE_HINT: localize('phoneHint', PHONE_HINT), TEST_HINT: localize('testHint', TEST_HINT),
-    BRAIN_COPY: localize('brainCopy', BRAIN_COPY),
+    BRAIN_COPY: localize('brainCopy', BRAIN_COPY), VOICE_PARTS: localize('voice.part', VOICE_PARTS),
   };
 }