synabun 2.0.10 → 2.1.0

package/neural-interface/public/shared/ui-crash-notice.js

@@ -0,0 +1,187 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — the notice after an automatic restart: the page side
+// ═══════════════════════════════════════════
+//
+// Asks GET /api/system/crash-notice when the page starts and every time its sync
+// socket connects: a page that was open through the crash is not reloaded, its
+// sockets reconnect (ui-sync.js `session:info`). What crash-notice-view.js says is
+// drawn in the update toast's shape (bottom right, styles.css .update-check-toast,
+// .crash-notice) once the loading screen is gone, and stays until it is dismissed.
+// Dismiss asks the server to drop it (POST /api/system/crash-notice/dismiss), which
+// tells every other window (`sync:crash-notice:changed`); this browser also keeps
+// the id it dismissed, for a server that could not remove its record. Open logs
+// is Settings > App's own: the desktop app's bridge, or POST
+// /api/system/app/open-folder, which only a page on this computer may ask. Never
+// asked by an invite guest, and never drawn for one, whatever reaches its sync
+// socket: /api/system is the owner's (the server sends `crash-notice:` to the
+// owner's pages only).
+
+import { on } from './state.js';
+import { getLocale, t } from './i18n.js';
+import { desktopApp } from './desktop-bridge.js';
+import { isGuest } from './ui-sync.js';
+import { crashNoticeView, isLoopbackHost, readCrashNotice } from './crash-notice-view.js';
+
+const NOTICE_URL = '/api/system/crash-notice';
+const OPEN_FOLDER_URL = '/api/system/app/open-folder';
+const WRITE = Object.freeze({ 'Content-Type': 'application/json', 'X-SynaBun-UI': '1', Accept: 'application/json' });
+const DISMISSED_KEY = 'synabun-crash-notice-dismissed';
+const NOTICE_ID = 'crash-notice';
+
+const translate = (key, params) => t(`crashNotice.${key}`, params);
+
+let _wired = false;
+let _asking = null;
+let _current = null; // { id, el }
+let _waiting = null; // the notice that waits for the loading screen to go
+let _guest = false;  // what the last `session:info` said (ui-sync.js isGuest() is the socket's own word)
+
+const guestPage = () => _guest || isGuest();
+
+function esc(value) {
+  return String(value ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+function dismissedHere(id) {
+  try { return localStorage.getItem(DISMISSED_KEY) === id; } catch { return false; }
+}
+
+function rememberDismissed(id) {
+  try { localStorage.setItem(DISMISSED_KEY, id); } catch { /* storage refused: the server's word is enough */ }
+}
+
+function canOpenLogs() {
+  if (typeof desktopApp()?.openFolder === 'function') return true;
+  return isLoopbackHost(location.hostname);
+}
+
+function hide() {
+  const current = _current;
+  _current = null;
+  if (!current) return;
+  current.el.classList.remove('show');
+  setTimeout(() => current.el.remove(), 250);
+}
+
+/** The loading screen covers the page while it starts: the notice waits for it to go. */
+function whenPageShown(run) {
+  const overlay = document.getElementById('loading-overlay');
+  if (!overlay || overlay.classList.contains('hidden')) { run(); return; }
+  const watch = new MutationObserver(() => {
+    if (!overlay.classList.contains('hidden')) return;
+    watch.disconnect();
+    run();
+  });
+  watch.observe(overlay, { attributes: true, attributeFilter: ['class'] });
+}
+
+function show(view) {
+  hide();
+  document.querySelectorAll(`#${NOTICE_ID}`).forEach((el) => el.remove());
+  const el = document.createElement('div');
+  el.className = 'update-check-toast crash-notice';
+  el.id = NOTICE_ID;
+  el.setAttribute('role', 'status');
+  el.setAttribute('aria-label', view.label);
+  el.dataset.noticeId = view.id;
+  const buttons = view.actions.map((item) => `<button class="action-btn action-btn--ghost crash-notice-btn" type="button" data-crash-action="${esc(item.id)}" id="crash-notice-${esc(item.id)}">${esc(item.label)}</button>`).join('');
+  el.innerHTML = `
+      <div class="utc-icon utc-icon--err" aria-hidden="true">!</div>
+      <div class="utc-body">
+        <div class="utc-title" id="crash-notice-title">${esc(view.title)}</div>
+        <div class="utc-sub" id="crash-notice-when">${esc(view.when)}</div>
+        ${view.how ? `<div class="utc-sub" id="crash-notice-how">${esc(view.how)}</div>` : ''}
+        <div class="crash-notice-lost-title" id="crash-notice-lost-title">${esc(view.lostTitle)}</div>
+        <ul class="utc-list crash-notice-lost" aria-labelledby="crash-notice-lost-title">${view.lost.map((line) => `<li>${esc(line)}</li>`).join('')}</ul>
+        <div class="utc-sub crash-notice-note" id="crash-notice-note" role="status" hidden></div>
+        <div class="update-notice-actions">${buttons}</div>
+      </div>`;
+  el.querySelectorAll('[data-crash-action]').forEach((btn) => {
+    btn.addEventListener('click', (event) => {
+      event.stopPropagation();
+      if (btn.dataset.crashAction === 'dismiss') dismiss(view.id);
+      else if (btn.dataset.crashAction === 'logs') openLogs(el);
+    });
+  });
+  document.body.appendChild(el);
+  requestAnimationFrame(() => el.classList.add('show'));
+  _current = { id: view.id, el };
+}
+
+/** Show this notice (or none): once per crash, never one this browser dismissed, never on a guest's page. */
+function present(notice) {
+  if (!notice || guestPage()) {
+    _waiting = null;
+    hide();
+    return;
+  }
+  // A notice something else took off the page is drawn again: it stays until it is dismissed.
+  if (_current && !_current.el.isConnected) _current = null;
+  if (dismissedHere(notice.id) || _current?.id === notice.id || _waiting?.id === notice.id) return;
+  _waiting = notice;
+  whenPageShown(() => {
+    if (_waiting !== notice) return;
+    _waiting = null;
+    if (dismissedHere(notice.id) || guestPage()) return;
+    show(crashNoticeView(notice, { t: translate, locale: getLocale(), canOpenLogs: canOpenLogs() }));
+  });
+}
+
+/** Ask the server; an older server (404) or a guest (403) has nothing to say. */
+export function checkCrashNotice() {
+  if (guestPage()) return Promise.resolve(null);
+  if (_asking) return _asking;
+  _asking = (async () => {
+    try {
+      const res = await fetch(NOTICE_URL, { headers: { Accept: 'application/json' }, cache: 'no-store' });
+      if (!res.ok) return null;
+      const notice = readCrashNotice(await res.json());
+      present(notice);
+      return notice;
+    } catch {
+      return null;
+    }
+  })().finally(() => { _asking = null; });
+  return _asking;
+}
+
+async function dismiss(id) {
+  rememberDismissed(id);
+  hide();
+  try {
+    const res = await fetch(`${NOTICE_URL}/dismiss`, { method: 'POST', headers: WRITE, body: JSON.stringify({ id }) });
+    const next = res.ok ? readCrashNotice(await res.json()) : null;
+    // A newer crash came while this one was shown: that one is news.
+    if (next && next.id !== id) present(next);
+  } catch { /* the server is away: this browser keeps it dismissed */ }
+}
+
+async function openLogs(el) {
+  const note = el.querySelector('#crash-notice-note');
+  const bridge = desktopApp();
+  let ok = false;
+  if (typeof bridge?.openFolder === 'function') {
+    try { ok = !!(await bridge.openFolder('logs'))?.ok; } catch { ok = false; }
+  } else {
+    try {
+      const res = await fetch(OPEN_FOLDER_URL, { method: 'POST', headers: WRITE, body: JSON.stringify({ which: 'logs' }) });
+      ok = res.ok;
+    } catch { ok = false; }
+  }
+  if (!note) return;
+  note.hidden = ok;
+  note.textContent = ok ? '' : translate('openLogsFailed');
+}
+
+/** Wire the notice once: ask now, and again every time the sync socket connects. */
+export function initCrashNotice() {
+  if (_wired) return;
+  _wired = true;
+  on('session:info', (info) => {
+    _guest = !!info?.isGuest;
+    if (_guest) present(null);
+    else checkCrashNotice();
+  });
+  on('sync:crash-notice:changed', (message) => present(readCrashNotice(message)));
+  checkCrashNotice();
+}

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

@@ -14,7 +14,8 @@ import { storage } from './storage.js';
 import { catColor } from './colors.js';
 import { truncate, formatMemoryContent, exportMemoryAsMarkdown, rafThrottle, escapeHtml } from './utils.js';
 import { t, getLocale } from './i18n.js';
-import { savePanelLayout, restorePanelLayout } from './ui-panels.js';
+import { savePanelLayout, restorePanelLayout, clampPanelToFrame } from './ui-panels.js';
+import { frameRect } from './app-frame.js';
 import { sendSync as _sendSync, hasPermission, isGuest } from './ui-sync.js';
 
 // Wrap sendSync — skip card events when guest lacks cards permission
@@ -546,9 +547,11 @@ function bringToFront(cardEl) {
 function getNextCardPosition() {
   const count = _openCards.size;
   const offset = count * 30;
+  // Cascading from 200 / 80 px of the window (192 / 24 px into the app frame), inside the frame.
+  const f = frameRect();
   return {
-    left: Math.min(window.innerWidth - 540, 200 + (offset % 300)) + 'px',
-    top: Math.min(window.innerHeight - 300, 80 + (offset % 200)) + 'px',
+    left: Math.max(f.left, Math.min(f.right - 540, f.left + 192 + (offset % 300))) + 'px',
+    top: Math.max(f.top, Math.min(f.bottom - 300, f.top + 24 + (offset % 200))) + 'px',
   };
 }
 
@@ -587,6 +590,13 @@ export function getOpenCardCount() {
   return _openCards.size;
 }
 
+/** Press an open card's Linked button from outside it (the context menu), unless it is on already. */
+export function focusLinkedMemories(memoryId) {
+  const card = _openCards.get(memoryId);
+  if (!card || state.focusedNodeId === memoryId) return;
+  q(card.el, 'focus-btn')?.click();
+}
+
 export function restoreOpenCards() {
   const raw = storage.getItem(KEYS.OPEN_CARDS);
   if (!raw) return;
@@ -1062,6 +1072,8 @@ export function openMemoryCard(node, savedPosition) {
   // ── Add to DOM and state ──
   _openCards.set(node.id, cardState);
   document.body.appendChild(card);
+  // A position saved in another window size, or with the explorers closed, comes back inside the app frame.
+  if (savedPosition) clampPanelToFrame(card);
   bringToFront(card);
 
   // Trigger entrance animation on next frame

package/neural-interface/public/shared/ui-image-gallery.js

@@ -8,6 +8,7 @@ import { emit, on } from './state.js';
 import { fetchImages, toggleImageFavorite, deleteImage } from './api.js';
 import { addImageToWhiteboard } from './ui-whiteboard.js';
 import { escapeHtml } from './utils.js';
+import { centeredInFrame } from './app-frame.js';
 
 const $ = (id) => document.getElementById(id);
 
@@ -23,33 +24,33 @@ let _lightboxImg = null;    // filename currently in lightbox
 let isVisible = false;
 
 // ── Drag state ──
-let _dragging = false;
-let _dragOff = { x: 0, y: 0 };
-let _dragRaf = 0;
-let _pendingDrag = null;
-
-function applyDragPosition() {
-  _dragRaf = 0;
-  if (!_panel || !_pendingDrag) return;
-  _panel.style.left = _pendingDrag.left + 'px';
-  _panel.style.top = _pendingDrag.top + 'px';
-}
-
-function scheduleDragPosition(left, top) {
-  _pendingDrag = { left, top };
-  if (!_dragRaf) _dragRaf = requestAnimationFrame(applyDragPosition);
-}
-
-function flushDragPosition() {
-  if (_dragRaf) {
-    cancelAnimationFrame(_dragRaf);
-    _dragRaf = 0;
-  }
-  applyDragPosition();
-}
-
-// ── Icons ──
-const ICON_CLOSE = '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"><path d="M4 4l8 8M12 4l-8 8"/></svg>';
+let _dragging = false;
+let _dragOff = { x: 0, y: 0 };
+let _dragRaf = 0;
+let _pendingDrag = null;
+
+function applyDragPosition() {
+  _dragRaf = 0;
+  if (!_panel || !_pendingDrag) return;
+  _panel.style.left = _pendingDrag.left + 'px';
+  _panel.style.top = _pendingDrag.top + 'px';
+}
+
+function scheduleDragPosition(left, top) {
+  _pendingDrag = { left, top };
+  if (!_dragRaf) _dragRaf = requestAnimationFrame(applyDragPosition);
+}
+
+function flushDragPosition() {
+  if (_dragRaf) {
+    cancelAnimationFrame(_dragRaf);
+    _dragRaf = 0;
+  }
+  applyDragPosition();
+}
+
+// ── Icons ──
+const ICON_CLOSE = '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"><path d="M4 4l8 8M12 4l-8 8"/></svg>';
 const ICON_REFRESH = '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M2.5 8a5.5 5.5 0 019.2-4M13.5 8a5.5 5.5 0 01-9.2 4"/><path d="M11.5 2v2.5H14M4.5 14v-2.5H2"/></svg>';
 const ICON_HEART = '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M8 13.7C4.3 11 2 8.7 2 6.3A3.3 3.3 0 018 4.6a3.3 3.3 0 016 1.7c0 2.4-2.3 4.7-6 7.4z"/></svg>';
 const ICON_HEART_FILL = '<svg viewBox="0 0 16 16" fill="currentColor" stroke="none"><path d="M8 13.7C4.3 11 2 8.7 2 6.3A3.3 3.3 0 018 4.6a3.3 3.3 0 016 1.7c0 2.4-2.3 4.7-6 7.4z"/></svg>';
@@ -388,13 +389,13 @@ function wirePanel() {
     header.addEventListener('mousedown', (e) => {
       if (e.target.closest('button')) return;
       _dragging = true;
-      _panel.classList.add('dragging');
-      const rect = _panel.getBoundingClientRect();
-      _dragOff = { x: e.clientX - rect.left, y: e.clientY - rect.top };
-      _pendingDrag = null;
-      e.preventDefault();
-    });
-  }
+      _panel.classList.add('dragging');
+      const rect = _panel.getBoundingClientRect();
+      _dragOff = { x: e.clientX - rect.left, y: e.clientY - rect.top };
+      _pendingDrag = null;
+      e.preventDefault();
+    });
+  }
 
   // Keyboard in lightbox
   document.addEventListener('keydown', handleKey);
@@ -425,24 +426,26 @@ function openPanel() {
   _panel.innerHTML = buildPanelHTML();
   document.body.appendChild(_panel);
 
-  _panel.style.left = Math.max(20, (window.innerWidth - 780) / 2) + 'px';
-  _panel.style.top = Math.max(48, (window.innerHeight - 560) / 2) + 'px';
+  // Centred in the app frame
+  const at = centeredInFrame(780, 560);
+  _panel.style.left = at.left + 'px';
+  _panel.style.top = at.top + 'px';
 
   wirePanel();
   isVisible = true;
   refreshImages();
 
-  // Global mouse handlers for drag
-  const onMouseMove = (e) => {
-    if (!_dragging) return;
-    scheduleDragPosition(e.clientX - _dragOff.x, e.clientY - _dragOff.y);
-  };
-  const onMouseUp = () => {
-    if (!_dragging) return;
-    _dragging = false;
-    flushDragPosition();
-    if (_panel) _panel.classList.remove('dragging');
-  };
+  // Global mouse handlers for drag
+  const onMouseMove = (e) => {
+    if (!_dragging) return;
+    scheduleDragPosition(e.clientX - _dragOff.x, e.clientY - _dragOff.y);
+  };
+  const onMouseUp = () => {
+    if (!_dragging) return;
+    _dragging = false;
+    flushDragPosition();
+    if (_panel) _panel.classList.remove('dragging');
+  };
   document.addEventListener('mousemove', onMouseMove);
   document.addEventListener('mouseup', onMouseUp);
 

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

@@ -26,7 +26,7 @@ let _recording = null;            // { actionId, originalCombo } when recording
 let _pendingBindings = null;      // working copy during modal editing
 let _modalOpen = false;
 // Actions that were removed ("toggle-toolbar" was "Hide all toolbars"): a saved key for one is dropped on load.
-const RETIRED_ACTIONS = ['toggle-toolbar'];
+const RETIRED_ACTIONS = ['toggle-toolbar', 'toggle-minimap'];
 
 // ── Combo building ──
 
@@ -94,6 +94,31 @@ export function getBinding(actionId) {
   return _bindings[actionId] || null;
 }
 
+/** The key an action is bound to as a menu shows it, or '' while it has none (the context menu, read at each open). */
+export function getShortcutLabel(actionId) {
+  const combo = _bindings[actionId];
+  return combo ? comboToDisplay(combo) : '';
+}
+
+/** Whether a module registered an action with this id. */
+export function hasAction(actionId) {
+  return _actions.has(actionId);
+}
+
+/** The action a key press is bound to, or null (a key the user bound stays that action, Shift+F10 included). */
+export function actionForKey(e) {
+  const combo = buildCombo(e);
+  return (combo && _reverseMap.get(combo)) || null;
+}
+
+/** Run a registered action as its key would. False when nothing registered it. */
+export function runAction(actionId) {
+  const handler = _actions.get(actionId);
+  if (!handler) return false;
+  handler();
+  return true;
+}
+
 // ── Central dispatcher ──
 
 function centralKeyHandler(e) {

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

@@ -12,12 +12,12 @@ import { openHelp } from './ui-help.js';
 import { armPwaInstallHandoff, initPwaInstall, installGuideUrl, isStandalone, requestPwaInstall } from './pwa-install.js';
 import { registerAction } from './ui-keybinds.js';
 import { isGuest, hasPermission } from './ui-sync.js';
-import { sendToPanel } from './ui-claude-panel.js';
 import { forceCheckToolUpdates, showUpdateToast, TOOL_LABELS } from './ui-tool-updates.js';
 import { forceCheckSynabunUpdate, openSynabunUpdateModal, synabunUpdateSourceLabel } from './ui-update.js';
 import { requestServerRestart } from './ui-loading.js';
 import { desktopBridge, isDesktopApp } from './desktop-bridge.js';
 import { t } from './i18n.js';
+import { frameRect } from './app-frame.js';
 
 const $ = (id) => document.getElementById(id);
 
@@ -221,7 +221,7 @@ function fitDropdown(item) {
   dropdown.style.maxHeight = '';
   dropdown.classList.remove('menubar-dropdown--scroll');
   const top = item.getBoundingClientRect().bottom + 14;
-  const room = Math.floor(window.innerHeight - top - 12);
+  const room = Math.floor(frameRect().bottom - top - 12); // down to the app frame's bottom edge
   if (room > 120 && dropdown.scrollHeight > room) {
     dropdown.style.maxHeight = room + 'px';
     dropdown.classList.add('menubar-dropdown--scroll');
@@ -278,12 +278,6 @@ function wireSubmenus() {
     sync();
   });
   window.addEventListener('resize', () => { if (openSub) placeSubmenu(openSub.parent, openSub.panel); });
-  // The tour shows a submenu by name (ui-tutorial.js showStage); null closes it.
-  on('menubar:submenu', (name) => {
-    const row = name ? [...SUBMENUS.keys()].find(r => r.dataset.submenu === name) : null;
-    if (row && !row.hidden) openSubmenu(row);
-    else closeSubmenu();
-  });
 }
 
 function openSubmenu(row, { focusFirst = false } = {}) {
@@ -377,8 +371,9 @@ function submenuEntries(panel) {
     .filter(el => !el.hidden && !el.classList.contains('disabled') && getComputedStyle(el).display !== 'none');
 }
 
-// Right of the dropdown with its first entry level with the row; on the left when the window has no room
-// on the right, and kept inside the window. The dropdown's laid-out place (offsetTop/Left) is what its
+// Right of the dropdown with its first entry level with the row; on the left when the app frame has no room
+// on the right, and kept inside its right and bottom edges (the menu hangs from the bar, which is outside the
+// frame, so its left stays the window's). The dropdown's laid-out place (offsetTop/Left) is what its
 // drop-in animation does not move, so a submenu opened together with the menu (the tour) lines up too.
 function placeSubmenu(row, panel) {
   const dropdown = row.parentElement, host = panel.parentElement;
@@ -386,9 +381,10 @@ function placeSubmenu(row, panel) {
   const first = submenuEntries(panel)[0];
   const lead = first ? first.getBoundingClientRect().top - panelBox.top : 0;
   const top = dropdown.offsetTop + row.getBoundingClientRect().top - dropdown.getBoundingClientRect().top - lead;
+  const f = frameRect();
   let left = dropdown.offsetLeft + dropdown.offsetWidth + SUBMENU_GAP;
-  if (hostBox.left + left + panelBox.width > innerWidth - VIEWPORT_MARGIN) left = dropdown.offsetLeft - SUBMENU_GAP - panelBox.width;
-  const maxTop = innerHeight - VIEWPORT_MARGIN - panelBox.height - hostBox.top;
+  if (hostBox.left + left + panelBox.width > f.right - VIEWPORT_MARGIN) left = dropdown.offsetLeft - SUBMENU_GAP - panelBox.width;
+  const maxTop = f.bottom - VIEWPORT_MARGIN - panelBox.height - hostBox.top;
   panel.style.left = `${Math.max(VIEWPORT_MARGIN - hostBox.left, left)}px`;
   panel.style.top = `${Math.max(VIEWPORT_MARGIN - hostBox.top, Math.min(top, maxTop))}px`;
 }
@@ -611,7 +607,6 @@ function wireTerminalMenu() {
     'menu-terminal-discord': () => emit('browser:open', { url: 'https://discord.com/app' }),
     'menu-terminal-x':       () => emit('browser:open', { url: 'https://x.com' }),
     'menu-terminal-whatsapp': () => emit('browser:open', { url: 'https://web.whatsapp.com' }),
-    'menu-app-leonardo':     () => { emit('browser:open', { url: 'https://app.leonardo.ai' }); emit('leonardo:launch'); },
     'menu-open-styleguide':  () => emit('styleguide:open'),
     'menu-command-runner':   () => emit('command-runner:open'),
     'menu-terminal-link':    () => emit('link:toggle'),
@@ -645,11 +640,6 @@ function wireTerminalMenu() {
     if (el) el.addEventListener('click', () => { closeAll(); handler(); });
   });
 
-  // Leonardo.AI — open panel with /leonardo skill after browser launches
-  on('leonardo:launch', () => {
-    setTimeout(() => sendToPanel('/leonardo', { newTab: true, tabLabel: 'Leonardo.AI', autoSubmit: true }), 500);
-  });
-
   // Keyboard shortcuts: toggle terminal (via central keybinds)
   registerAction('toggle-terminal', () => emit('terminal:toggle'));
   registerAction('toggle-terminal-alt', () => emit('terminal:toggle'));

package/neural-interface/public/shared/ui-native-loop-router-state.js

@@ -3,6 +3,11 @@ export function isNewerRunDescriptor(next, current, terminalStatuses) {
   const nextTerminal = terminalStatuses.has(next.status);
   const currentTerminal = terminalStatuses.has(current.status);
   if (currentTerminal !== nextTerminal) return nextTerminal;
+  // A run resumed after a server restart (`resumes` only grows) is newer whatever its version: a crash can lose the
+  // last ledger writes, and with them versions a page already saw.
+  const nextResumes = Number(next.resumes) || 0;
+  const currentResumes = Number(current.resumes) || 0;
+  if (nextResumes !== currentResumes) return nextResumes > currentResumes;
   const nextVersion = Number(next.version) || 0;
   const currentVersion = Number(current.version) || 0;
   if (nextVersion !== currentVersion) return nextVersion > currentVersion;

package/neural-interface/public/shared/ui-native-loop-router.js

@@ -13,7 +13,10 @@ import {
 const DISMISSED_KEY = 'synabun-native-loop-dismissed';
 const CLAIM_TTL_MS = 90_000;
 const TERMINAL_RESTORE_LIMIT = 10;
+// 'suspended' is not among them: a dispatched worker a server restart cut off keeps its tab until the next start
+// resumes it (or ends it as interrupted).
 const TERMINAL_STATUSES = new Set(['completed', 'failed', 'stopped', 'interrupted']);
+const LIVE_STATUSES = new Set(['starting', 'running', 'suspended']);
 const _windowId = nativeLoopWindowId;
 
 const _attached = new Map();
@@ -355,7 +358,7 @@ async function reconcileRuns() {
     const newestFirst = (data.runs || [])
       .filter(hasIdentity)
       .sort((a, b) => String(b.updatedAt || b.startedAt || '').localeCompare(String(a.updatedAt || a.startedAt || '')));
-    const activeRuns = newestFirst.filter((run) => run.status === 'starting' || run.status === 'running');
+    const activeRuns = newestFirst.filter((run) => LIVE_STATUSES.has(run.status));
     const terminalRuns = newestFirst.filter((run) => {
       if (!TERMINAL_STATUSES.has(run.status)) return false;
       if (new Date(run.updatedAt || run.startedAt || 0).getTime() < cutoff) return false;
@@ -403,6 +406,9 @@ export function initNativeLoopRouter() {
   on('sync:sidepanel:run-completed', route);
   on('sync:sidepanel:run-failed', route);
   on('sync:sidepanel:run-stopped', route);
+  // The sync socket (re)connected (ui-sync.js 'connected'): after a server restart the runs are read again at once,
+  // not at the next 30 s heartbeat, so a tab whose run was suspended sees it resume (or end) as soon as it can.
+  on('session:info', () => { scheduleReconcile(); });
   on('sync:sidepanel:provider-event', (message) => {
     // An OpenCode worker's panel streams from its own serve: the sync copy of its tool calls is the Assistant's.
     if (message?.event?.provider === 'opencode') return;

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

@@ -1,12 +1,11 @@
 import { initDetachedAgentSessions } from './ui-sidepanel-sessions.js';
 // ═══════════════════════════════════════════
 // SynaBun Neural Interface — Navbar
-// Initializes the 2D/3D view toggle, right-side icon buttons, and menubar action buttons.
+// Initializes right-side icon buttons and menubar action buttons. The memory map is 3D only.
 // Menu items (View, Graph, Bookmarks, Layouts) are handled by ui-menubar.js.
 // ═══════════════════════════════════════════
 
 import { state, emit, on } from './state.js';
-import { getVariant } from './registry.js';
 import { KEYS } from './constants.js';
 import { storage } from './storage.js';
 import { t } from './i18n.js';
@@ -23,6 +22,7 @@ import { toggleImageGallery } from './ui-image-gallery.js';
 import { toggleScheduleQueue } from './ui-schedule-queue.js';
 import { initUpdate } from './ui-update.js';
 import { initToolUpdates } from './ui-tool-updates.js';
+import { initCrashNotice } from './ui-crash-notice.js';
 import { initSidepanelTrayPlaceholders } from './ui-sidepanel-tray.js';
 import { initDesktopTitleBar } from './desktop-titlebar.js';
 
@@ -30,28 +30,6 @@ const $ = (id) => document.getElementById(id);
 
 export function initNavbar() {
   initDetachedAgentSessions();
-  const variant = getVariant() || '3d';
-
-  // ── View toggle ──
-  const nav2d = $('nav-2d-link');
-  const nav3d = $('nav-3d-link');
-
-  const activeLink = variant === '3d' ? nav3d : nav2d;
-  const inactiveLink = variant === '3d' ? nav2d : nav3d;
-
-  if (activeLink) {
-    activeLink.addEventListener('click', (e) => e.preventDefault());
-  }
-  if (inactiveLink) {
-    inactiveLink.addEventListener('click', (e) => {
-      e.preventDefault();
-      if (state.selectedNodeId) {
-        sessionStorage.setItem(KEYS.SELECTED_SWITCH, state.selectedNodeId);
-      }
-      window.location.href = inactiveLink.getAttribute('href');
-    });
-  }
-
   // ── Claude panel toggle (topright workspace toolbar) ──
   const assistantPanelBtn = $('topright-assistant-panel-btn');
   const claudePanelBtn = $('topright-claude-panel-btn');
@@ -380,4 +358,6 @@ export function initNavbar() {
   // ── Update alert ──
   initUpdate();
   initToolUpdates();
+  // ── The notice after an automatic restart (the server crashed and its supervisor started it again) ──
+  initCrashNotice();
 }