synabun 2.0.0-beta → 2.0.5

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/worker-end.js

@@ -0,0 +1,251 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — how a dispatched worker's tab ends
+// ═══════════════════════════════════════════
+//
+// A worker the Assistant dispatched (agent_dispatch) runs as an automation tab
+// in the Claude Code, Codex or OpenCode sidepanel. When its work is over, the
+// tab ends on one card that says how it ended: the task is complete, it is
+// blocked or waits for input, it failed (with the reason) or it was stopped
+// (with who or what stopped it), and a button back to the Assistant session
+// that dispatched it. This module decides what that card says, from two
+// readings of the run:
+//   - `run`: the runtime descriptor the sidepanel router attaches with
+//     (lib/native-loop-runtime.js cleanDescriptor: status, turnState,
+//     stoppedReason, error, runMode, assistantSessionId), and
+//   - `dispatch`: the dispatcher's view of the same run (GET
+//     /api/assistant/runs/:runId, or an `assistant:dispatch` event: state,
+//     outcome, lastResult, completionReason, error, costUsd, turns).
+// The runtime status alone cannot tell a finished task from a stopped one: a
+// warm worker that reported done is released by an idle timeout, by the
+// Assistant's agent_stop or by its tab closing, and each of those ends the
+// runtime run as "stopped". The worker's own `## Result` (the dispatcher's
+// `outcome`) says whether the task was done.
+//
+// No imports and no DOM: `node --test` loads this file as it is
+// (tests/worker-end.test.mjs). WORKER_END_COPY is the English of every
+// sentence; `workerEnd.*` in i18n/en.json must equal it and i18n/pt-BR.json
+// must have the same keys (the test checks both). The page side is
+// ui-worker-end.js.
+
+export const WORKER_END_COPY = Object.freeze({
+  complete: 'Task complete',
+  blocked: 'Blocked',
+  needsInput: 'Needs input',
+  failed: 'Task failed',
+  stopped: 'Stopped',
+  interrupted: 'Interrupted',
+  back: 'Back to Assistant',
+  backHint: 'Close this tab and open the Assistant session that dispatched it',
+  warmNote: 'The worker is still open for follow-ups. Going back closes it.',
+  failedNoReason: 'The run ended with an error.',
+  reasonUser: 'Stopped by you.',
+  reasonAssistant: 'Stopped by the Assistant.',
+  reasonAssistantSaid: 'Stopped by the Assistant: {reason}',
+  reasonTimeCap: 'The run reached its time limit.',
+  reasonBudget: 'The run reached its budget limit.',
+  reasonMaxTurns: 'The run reached its turn limit.',
+  reasonIdle: 'The worker waited for a follow-up that did not come, and closed.',
+  reasonRestart: 'The server restarted while the run was open.',
+  reasonKillAll: 'Stopped together with every other run.',
+  reasonCleared: 'The run\'s state was removed.',
+  reasonOther: 'Stopped ({reason}).',
+  durationSeconds: '{s}s',
+  durationMinutes: '{m}m {s}s',
+  durationHours: '{h}h {m}m',
+});
+
+/** Marks the card in a transcript: snapshot writers and restorers leave it out (it is drawn again from the run). */
+export const WORKER_END_CLASS = 'worker-end-card';
+
+/** The run states (runtime and dispatcher alike) after which nothing more happens. */
+export const TERMINAL_STATES = new Set(['completed', 'failed', 'stopped', 'interrupted']);
+const TERMINAL = TERMINAL_STATES;
+// Dispatcher states in which a turn is in progress (or about to be): the card waits.
+const WORKING = new Set(['queued', 'awaiting_route', 'starting', 'running', 'awaiting_permission']);
+const SUMMARY_CHARS = 320;
+
+/** A WORKER_END_COPY sentence with its `{params}` filled in: the translator when the page gives none. */
+export function fillWorkerEndCopy(key, params = {}) {
+  return String(WORKER_END_COPY[key] ?? key).replace(/\{(\w+)\}/g, (whole, name) => (params[name] != null ? params[name] : whole));
+}
+
+/** A run the Assistant dispatched (task mode), as opposed to a loop or a schedule the user started. */
+export function isDispatchedRun(run, dispatch = null) {
+  return !!(dispatch?.runId || run?.assistantSessionId || run?.runMode === 'task');
+}
+
+/**
+ * A turn of the run is in progress (or the run has not started one yet). The
+ * dispatcher's state wins over the runtime's: it is the one that knows a warm
+ * worker between turns is idle.
+ */
+export function isRunWorking(run, dispatch = null) {
+  const state = String(dispatch?.state || '');
+  if (TERMINAL.has(state) || TERMINAL.has(String(run?.status || ''))) return false;
+  if (state) return WORKING.has(state);
+  const status = String(run?.status || '');
+  if (status !== 'starting' && status !== 'running') return false;
+  return run?.turnState !== 'idle' && run?.turnState !== 'terminal';
+}
+
+/** The runtime descriptor says the run may have something to show: it ended, or it waits between turns. */
+export function mayHaveEnded(run) {
+  return TERMINAL.has(String(run?.status || '')) || run?.turnState === 'idle';
+}
+
+/**
+ * The Claude Agent SDK's own words for a query SynaBun aborted: what its
+ * stream throws when the runtime disposes a worker, which happens to every run
+ * that ends, however it ended. Never a failure the user has to read.
+ */
+export function isEndOfRunAbort(message) {
+  const text = String(message || '').trim();
+  return /^(Claude Code process aborted by user|Connection aborted by user|Operation aborted|disposed)\.?$/i.test(text);
+}
+
+/** "4m 12s": how long a run took. */
+export function formatDuration(ms, t = fillWorkerEndCopy) {
+  const total = Math.max(0, Math.round((Number(ms) || 0) / 1000));
+  const h = Math.floor(total / 3600);
+  const m = Math.floor((total % 3600) / 60);
+  const s = total % 60;
+  if (h) return t('durationHours', { h, m });
+  if (m) return t('durationMinutes', { m, s });
+  return t('durationSeconds', { s });
+}
+
+/** "$0.42"; under a cent is "<$0.01"; nothing for a run that cost nothing or was not priced. */
+export function formatCost(usd) {
+  const value = Number(usd);
+  if (!Number.isFinite(value) || value <= 0) return '';
+  if (value < 0.01) return '<$0.01';
+  return `$${value.toFixed(2)}`;
+}
+
+/** A worker's summary as one plain paragraph: no Markdown emphasis or heading marks, clipped. */
+function plain(text, max = SUMMARY_CHARS) {
+  const flat = String(text || '')
+    .replace(/^#{1,6}\s+/gm, '')
+    .replace(/\*\*|__|`/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return flat.length > max ? `${flat.slice(0, max - 1).trimEnd()}…` : flat;
+}
+
+function time(value) {
+  const at = Date.parse(value || '');
+  return Number.isFinite(at) ? at : null;
+}
+
+/** How long the work took: to the end of its last turn when the task got that far, else to the end of the run. */
+function elapsedOf(run, dispatch, untilLastTurn) {
+  const startedAt = time(dispatch?.startedAt) ?? time(dispatch?.createdAt) ?? time(run?.startedAt);
+  const turns = Array.isArray(dispatch?.turns) ? dispatch.turns : [];
+  const lastTurnEnd = untilLastTurn ? time(turns.at(-1)?.endedAt) : null;
+  const end = lastTurnEnd ?? time(dispatch?.completedAt) ?? time(dispatch?.finishedAt) ?? time(run?.completedAt);
+  if (startedAt != null && end != null && end >= startedAt) return end - startedAt;
+  const ms = Number(dispatch?.elapsedMs);
+  return Number.isFinite(ms) && ms > 0 ? ms : null;
+}
+
+function stopReason(reason, t) {
+  const code = String(reason || '').trim();
+  switch (code) {
+    case 'user': return t('reasonUser');
+    case 'assistant': case 'complete': return t('reasonAssistant');
+    case 'time_cap': return t('reasonTimeCap');
+    case 'budget_cap': case 'session_budget_cap': case 'budget_unpriced': return t('reasonBudget');
+    case 'max_turns': return t('reasonMaxTurns');
+    case 'idle_timeout': return t('reasonIdle');
+    case 'server_restart': case 'server_shutdown': return t('reasonRestart');
+    case 'kill_all': return t('reasonKillAll');
+    case 'state_removed': case 'state_inactive': return t('reasonCleared');
+    case '': return '';
+    default:
+      // The Assistant's agent_stop reason is its own sentence; anything else is a code.
+      return /\s/.test(code) || code.length > 40
+        ? t('reasonAssistantSaid', { reason: plain(code, 200) })
+        : t('reasonOther', { reason: code });
+  }
+}
+
+/**
+ * What the end card of a dispatched worker's tab shows, or null when there is
+ * no card (not a dispatched run, a turn still in progress, background work
+ * still running, or a warm worker that has not reported its task done).
+ *
+ * @param {object | null} run the runtime descriptor (sidepanel router)
+ * @param {object | null} dispatch the dispatcher's view of the run, when known
+ * @param {object} [o]
+ * @param {(key: string, params?: object) => string} [o.t] a key of WORKER_END_COPY → the sentence in the page's language
+ * @param {boolean} [o.busy] background work of the run is still going (a warm worker only: an ended run has none)
+ * @param {boolean} [o.stoppedMidTurn] the run was seen working right before it was stopped: a done
+ *   report from an earlier turn does not make it complete
+ * @returns {null | {
+ *   kind: 'complete' | 'blocked' | 'needs_input' | 'failed' | 'stopped' | 'interrupted',
+ *   tone: 'ok' | 'warn' | 'err' | 'off',
+ *   title: string, detail: string, meta: string, note: string,
+ *   warm: boolean,
+ *   assistantSessionId: string | null, backLabel: string, backHint: string,
+ *   sig: string,
+ * }}
+ */
+export function workerEndView(run, dispatch = null, { t = fillWorkerEndCopy, busy = false, stoppedMidTurn = false } = {}) {
+  if (!run && !dispatch) return null;
+  if (!isDispatchedRun(run, dispatch)) return null;
+  if (isRunWorking(run, dispatch)) return null;
+
+  const state = String(dispatch?.state || '');
+  const status = String(run?.status || '');
+  const endState = TERMINAL.has(state) ? state : (TERMINAL.has(status) ? status : '');
+  const result = dispatch?.lastResult && typeof dispatch.lastResult === 'object' ? dispatch.lastResult : null;
+  const outcome = String(dispatch?.outcome || result?.status || '');
+  const assistantSessionId = dispatch?.assistantSessionId || run?.assistantSessionId || null;
+
+  let kind = null;
+  let detail = '';
+  let warm = false;
+  if (!endState) {
+    // A warm worker between turns: only a task it reported done ends on a card.
+    // Background work it started may still be running (and report again).
+    if (outcome !== 'done' || busy) return null;
+    kind = 'complete';
+    warm = true;
+  } else if (endState === 'failed') {
+    kind = 'failed';
+    detail = plain(dispatch?.error || run?.error || '', 400) || t('failedNoReason');
+  } else if (outcome === 'done' && !(stoppedMidTurn && endState !== 'completed')) {
+    kind = 'complete';
+  } else if ((outcome === 'blocked' || outcome === 'needs_input') && !stoppedMidTurn) {
+    kind = outcome;
+  } else if (endState === 'completed') {
+    // Completed without a done report: the Assistant completed it (agent_complete).
+    kind = 'complete';
+  } else {
+    kind = endState === 'interrupted' ? 'interrupted' : 'stopped';
+    detail = stopReason(dispatch?.completionReason || run?.stoppedReason || '', t);
+  }
+
+  if (kind === 'complete' || kind === 'blocked') detail = plain(result?.summary || '');
+  if (kind === 'needs_input') detail = plain(result?.question || result?.summary || '');
+
+  const titles = { complete: 'complete', blocked: 'blocked', needs_input: 'needsInput', failed: 'failed', stopped: 'stopped', interrupted: 'interrupted' };
+  const tones = { complete: 'ok', blocked: 'warn', needs_input: 'warn', failed: 'err', stopped: 'off', interrupted: 'off' };
+  const elapsed = elapsedOf(run, dispatch, kind === 'complete' || kind === 'blocked' || kind === 'needs_input');
+  const meta = [elapsed != null ? formatDuration(elapsed, t) : '', formatCost(dispatch?.costUsd)].filter(Boolean).join(' · ');
+  const view = {
+    kind,
+    tone: tones[kind],
+    title: t(titles[kind]),
+    detail,
+    meta,
+    note: warm && assistantSessionId ? t('warmNote') : '',
+    warm,
+    assistantSessionId,
+    backLabel: assistantSessionId ? t('back') : '',
+    backHint: assistantSessionId ? t('backHint') : '',
+    sig: '',
+  };
+  view.sig = JSON.stringify([view.kind, view.title, view.detail, view.meta, view.note, view.assistantSessionId, view.backLabel]);
+  return view;
+}

package/neural-interface/public/sw.js

@@ -1,4 +1,6 @@
-const CACHE_NAME = 'synabun-offline-v9';
+// Bump when offline.html changes shape: the new worker drops the old cache and
+// stores the page again (v13: a restart read from the supervisor's report).
+const CACHE_NAME = 'synabun-offline-v13';
 const OFFLINE_URL = '/offline.html';
 
 self.addEventListener('install', (event) => {

package/neural-interface/public/variant/2d/main.js

@@ -21,7 +21,7 @@ import { initI18n, t } from '../../shared/i18n.js';
 // ── Shared UI modules (side-effect: each registers its own event listeners) ──
 import { initTooltip } from '../../shared/ui-tooltip.js';
 import { initPanelSystem, initPinToggle, clampPanelsToViewport } from '../../shared/ui-panels.js';
-import { initLoading, showLoadingError, hideLoading } from '../../shared/ui-loading.js';
+import { initLoading, showLoadingError, hideLoading, rememberHealth } from '../../shared/ui-loading.js';
 import { initNavbar } from '../../shared/ui-navbar.js';
 import { initMenubar } from '../../shared/ui-menubar.js';
 import { initSearch } from '../../shared/ui-search.js';
@@ -304,6 +304,7 @@ async function boot() {
     try {
       const healthRes = await fetch('/api/health');
       const health = await healthRes.json();
+      rememberHealth(health);
       if (!health.ok) {
         const messages = {
           db_missing:         [t('loading.health.databaseUnreachable.title'), health.detail || t('loading.health.databaseUnreachable.sub')],