synabun 2.0.7 → 2.0.10

package/neural-interface/public/shared/assistant/asst-model-chip.js

@@ -0,0 +1,135 @@
+// ═══════════════════════════════════════════
+// SynaBun Assistant — what the composer's model chip says
+// ═══════════════════════════════════════════
+// The model as a short human name from its catalog label ("Opus 5.5 (1M
+// context)" → "Opus 5.5", "Default (recommended) — Opus 5.5" → "Opus 5.5"),
+// a context tag for a "[1m]" / "[extended]" variant ("1M"), and the forms the
+// chip falls back to when the composer row has no room, longest first: the tag
+// goes first, then the account cue, then the API badge, then the name shortens
+// by whole words, to a form that still names this model alone when there is one
+// ("Opus 5.5" → "Opus", "GPT-6-Luna" → "Luna"). Never a cut word.
+// asst-brain-picker.js draws the first form that fits. DOM-free: node --test loads it.
+
+const VARIANT = /\[(1m|extended)\]$/i;
+const VERSION = /^v?\d+(?:\.\d+)*[a-z]?$/i;
+
+function str(v) {
+  return v == null ? '' : String(v).trim();
+}
+
+/** The id without its provider ("anthropic/…"), legacy ":<window>" and variant suffix. */
+function bareId(id) {
+  const tail = str(id).split('/').pop() || '';
+  return tail.replace(/:\d+$/, '').replace(VARIANT, '');
+}
+
+/**
+ * The model's short name: { name, raw }. The label's own words without what the
+ * chip says otherwise (parentheses: the context, "recommended"); after a dash, the
+ * model it runs as. No label (or the id itself): the bare id, `raw` (shown mono).
+ */
+export function modelChipName(label, id) {
+  let text = str(label);
+  if (text && text !== str(id)) {
+    const runsAs = text.split(/\s+[—–]\s+/).pop();
+    text = str(runsAs.replace(/\s*\([^)]*\)/g, '').replace(/\s+/g, ' '));
+    if (text) return { name: text, raw: false };
+  }
+  const name = bareId(id) || str(id);
+  return { name, raw: true };
+}
+
+/** "1M", "400K": a context window in tokens, never rounded up. */
+function compactTokens(n) {
+  const v = Number(n);
+  if (!Number.isFinite(v) || v <= 0) return '';
+  if (v >= 1e6) return `${Math.floor(v / 1e5) / 10}M`;
+  if (v >= 1e3) return `${Math.floor(v / 1e3)}K`;
+  return String(v);
+}
+
+/**
+ * What tells a context variant from its model ("opus[1m]" → "1M"): its window when
+ * the catalog knows it, else "1M" for "[1m]", else the label's own word ("extended").
+ * '' for a model that is not a variant.
+ */
+export function modelChipTag(id, { contextWindow = null, label = '' } = {}) {
+  const m = str(id).match(VARIANT);
+  if (!m) return '';
+  const tokens = compactTokens(contextWindow);
+  if (tokens) return tokens;
+  if (m[1].toLowerCase() === '1m') return '1M';
+  const note = str(label).match(/\(([^)]*)\)\s*$/);
+  return note ? str(note[1].replace(/\bcontext\b/i, '')) : '';
+}
+
+// "GPT-6.1-Sol" → ['GPT', '6.1', 'Sol'] with the separators kept: whole words in, whole words out.
+function parts(name) {
+  return str(name).match(/[^\s-]+|[\s-]+/g) || [];
+}
+const isSep = (p) => /^[\s-]+$/.test(p);
+const wordsOf = (name) => parts(name).filter(p => !isSep(p)).map(w => w.toLowerCase());
+
+/** Whether `words` run in that order, whole, somewhere in `other` ("opus" in "Opus 5.5"). */
+function within(words, other) {
+  for (let i = 0; i + words.length <= other.length; i += 1) {
+    if (words.every((w, j) => other[i + j] === w)) return true;
+  }
+  return false;
+}
+
+/**
+ * The name's shorter forms, whole words only, longest first: `unique` still names this
+ * model alone among `names` (the short names of every model the provider lists: "Opus"
+ * for "Opus 5.5", "GPT-6.1" for "GPT-6.1-Sol", "Luna" for "GPT-6-Luna" when every
+ * "GPT-6" is another model too), `other` drops trailing words whatever they lose
+ * ("Sonnet" for "Sonnet 5.5" beside "Sonnet 5"; "GPT-6"). A form never starts with a
+ * version ("5.5"), and a suffix is tried only when no shorter prefix is unique.
+ */
+export function modelChipShortNames(name, names = []) {
+  const all = parts(name);
+  const own = wordsOf(name);
+  const others = [...new Set((Array.isArray(names) ? names : []).map(str).filter(n => n && n.toLowerCase() !== str(name).toLowerCase()))].map(wordsOf);
+  const unique = (form) => { const w = wordsOf(form); return !others.some(o => within(w, o)); };
+  const prefixes = [];
+  const suffixes = [];
+  for (let n = own.length - 1; n >= 1; n -= 1) {
+    let seen = 0;
+    const cut = all.findIndex(p => !isSep(p) && ++seen > n);
+    prefixes.push(all.slice(0, cut).join('').replace(/[\s-]+$/, ''));
+    let skip = own.length - n;
+    const from = all.findIndex(p => !isSep(p) && skip-- === 0);
+    if (!VERSION.test(all[from])) suffixes.push(all.slice(from).join(''));
+  }
+  const lossless = prefixes.filter(unique);
+  const picked = lossless.length ? lossless : suffixes.filter(unique);
+  return { unique: picked, other: prefixes.filter(p => !picked.includes(p)) };
+}
+
+/**
+ * The chip's forms, longest first: [{ name, tag, cue, api }] (tag / cue / api: shown
+ * or not). `tag`, `cue` and `api` say whether the chip has one at all; `names` are the
+ * provider's models (modelChipShortNames). What goes, in order: the tag, the account
+ * cue, the API badge, then the name. A shorter name that still names this model alone
+ * loses nothing, so it is tried before the cue and before the badge go; one that
+ * loses something only after.
+ */
+export function modelChipForms({ name, names = [], tag = false, cue = false, api = false } = {}) {
+  const full = str(name);
+  const out = [];
+  const seen = new Set();
+  const add = (n, t, c, a) => {
+    const form = { name: n, tag: !!(t && tag), cue: !!(c && cue), api: !!(a && api) };
+    const key = JSON.stringify(form);
+    if (!seen.has(key)) { seen.add(key); out.push(form); }
+  };
+  const short = full ? modelChipShortNames(full, names) : { unique: [], other: [] };
+  add(full, true, true, true);
+  add(full, false, true, true);
+  for (const u of short.unique) add(u, false, true, true);
+  add(full, false, false, true);
+  for (const u of short.unique) add(u, false, false, true);
+  add(full, false, false, false);
+  for (const n of [...short.unique, ...short.other]) add(n, false, false, false);
+  return out;
+}

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

@@ -51,20 +51,21 @@ import { cachedProjects, createBrainPicker, testDensityLabel } from './asst-brai
 import { createRovingToolbar } from './asst-roving.js';
 import { openAccountsManager } from './asst-accounts.js';
 import { createAgentsDock } from './asst-agents-dock.js';
+import { activityOf } from './asst-scenes.js';
 import { createUsageGauge } from './asst-usage.js';
-import { closeMenu, isMenuOpen, openMenu } from './asst-menu.js';
+import { closeMenu, currentMenuAnchor, isMenuOpen, openMenu } from './asst-menu.js';
 import { createRouteModeControl, openModelsManager, openRoutesEditor, refreshModelsManager, renderRouteCard, routeModeLabel } from './asst-route.js';
 import { budgetChipText, budgetSpendText, budgetTone, closeBudgetEditor, createBudgetController, mountBudgetChip, openBudgetEditor } from './asst-budget.js';
 import { computerRemoteView, createComputerPanel, createComputerToggle, normalizeComputerRemote, openFrameLightbox, closeFrameLightbox, requestDesktopStop } from './asst-computer.js';
 import {
   applyLimit, applyLimitPacket, applyUsagePacket, brainLabel, createRenameWriter, createTabState, DEFAULT_ROUTE_MODE, deserializeTabState, fmtCost, fmtRunLine, limitExpiresIn, limitNoticeText, modelShortName,
   brainModePatch, normalizeBrain, normalizeComputerMode, permissionModeLabel, normalizeRouteMode, normalizeTestDensity, projectLabel, providerShortLabel, readStoredBrain, runFromPayload,
-  serializeTabState, tabStorageKey, userSessionTitle,
+  serializeTabState, sessionStatus, tabStorageKey, userSessionTitle,
 } from './asst-state.js';
 import {
   closeAssistantSession, dispatchAssistantRun, escalateAssistantRun, focusAssistantRun, getAssistantRun,
   fetchManageCatalog, getAssistantRunResult, getAssistantSession, getAssistantSessionUsage, getDesktopStatus, getRouting, killAllAssistantRuns, removeAssistantRun, clearFinishedAssistantRuns,
-  listAssistantSessions, patchAssistantSession, patchHiddenModels, stopAssistantRun, uploadAssistantAttachment,
+  listAssistantSessions, patchAssistantSession, patchHiddenModels, setAdminSandbox, stopAssistantRun, uploadAssistantAttachment,
 } from './asst-api.js';
 
 const ICON_SESSIONS = '<svg viewBox="0 0 24 24"><path d="M3 6h18M3 12h18M3 18h12"/></svg>';
@@ -74,6 +75,7 @@ const ICON_COG = '<svg viewBox="0 0 24 24"><path d="M12.22 2h-.44a2 2 0 0 0-2 2v
 const ICON_ROUTE = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M4 7h13l-3-3M20 17H7l3 3"/></svg>';
 const ICON_COMPUTER = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="18" height="12" rx="2"/><path d="M8 20h8M12 16v4"/></svg>';
 const ICON_CLOSE = '<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>';
+const ICON_TRASH = '<svg viewBox="0 0 24 24"><path d="M3 6h18M8 6V4.5A1.5 1.5 0 0 1 9.5 3h5A1.5 1.5 0 0 1 16 4.5V6M18.5 6l-.8 13a2 2 0 0 1-2 1.9H8.3a2 2 0 0 1-2-1.9L5.5 6M10 11v6M14 11v6"/></svg>';
 const REPLAY_WAIT_MS = 1500; // a replay that stops short of its count is drawn after this long
 
 function el(tag, className, text) {
@@ -148,14 +150,17 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     usageView: saved?.usageView || null,
   });
   Object.assign(st, {
-    status: 'idle',
+    status: 'idle',                                // the brain's own: its turn, its cards (setStatus)
+    workers: { working: 0, waiting: 0 },           // its dispatched agents, from the agents tray (sessionStatus)
+    shownStatus: 'idle',                           // what the host shows: both together (pushStatus)
     dispatchUsd: 0,
     serverCost: false,
     engine: '',
     sdkVersion: '',
     routing: null,                                 // server view { mode, effectiveMode, defaultMode, askBelow }
-    features: { routing: null, computer: null, testDensity: null, rename: null },   // null = unknown yet
+    features: { routing: null, computer: null, testDensity: null, rename: null, adminSandbox: null },   // null = unknown yet
     testDensityEffective: null,                    // server view: the level in effect
+    adminSandbox: null,                            // server view: the global Admin sandbox setting (every agent)
     brainCapabilities: null,
     computerEffective: st.computerUse === true,
     desktopSupported: null,
@@ -164,6 +169,9 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     desktopProbe: false,
     routingProbe: false,
     sessionTitle: String(session?.title || ''),  // the server's name (the user's rename, else the first prompt): history + notifications
+    // Whether this session holds a chat (a prompt was sent): until then the server keeps it as a draft,
+    // New reuses it, and leaving it for another session closes it (nothing of it is stored).
+    chatStarted: !!session?.chatStartedAt || Number(session?.turns) > 0,
   });
   let recordName = userSessionTitle(session); // the name the session record holds as the user's ('' = never renamed)
   const controls = new Map(); // requestId → { card, origin, kind }
@@ -314,18 +322,33 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     notify(host.notifySource || 'cli', type, notifyLabel(), { sessionId, provider: 'assistant', panel: 'assistant' });
   }
 
-  /** root[data-status] and data-computer drive status styling (the live dot, the Computer switch). */
+  /** root[data-status] (the session's status, sessionStatus) and data-computer drive status styling (the live dot, the Computer switch). */
   function renderStatus() {
-    root.dataset.status = st.status || 'idle';
+    root.dataset.status = st.shownStatus || 'idle';
     if (st.desktopActive) root.dataset.computer = 'active';
     else delete root.dataset.computer;
   }
 
+  /** The brain's own status: its turn ('working', 'done', 'idle') and its cards ('action'). */
   function setStatus(status) {
     st.status = status || 'idle';
-    renderStatus();
+    pushStatus(true);
     syncBlocked();
-    try { host.setStatus?.(st.status); } catch { /* ignore */ }
+  }
+
+  /**
+   * What the host shows (tray pill, header, terminal badge) is the session's status: the brain's own and
+   * its dispatched agents' together (asst-state.js sessionStatus), so the gold stays while a worker works
+   * after the turn that dispatched it ended, and a worker that waits on you makes the session need you.
+   * The brain's own changes always reach the host; a change of the agents' counts only when the status moved.
+   */
+  function pushStatus(always = false) {
+    if (destroyed) return;
+    const next = sessionStatus(st.status, st.workers);
+    if (!always && next === st.shownStatus) return;
+    st.shownStatus = next;
+    renderStatus();
+    try { host.setStatus?.(next); } catch { /* ignore */ }
   }
 
   /**
@@ -583,6 +606,9 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     // Test density sits right after the permission mode; hidden on a server that does not know it.
     getTestDensity: () => testDensityView(),
     onTestDensity: (level) => setTestDensity(level),
+    // The global Admin sandbox switch, in the permission menu; hidden on a server that does not serve it.
+    getAdminSandbox: () => adminSandboxView(),
+    onAdminSandbox: (enabled) => changeAdminSandbox(enabled),
     // The registered projects arrived: their labels name the project in the fields and the "Fix … in" suggestion.
     onProjects: () => { picker.render(); renderer.refreshEmpty(); },
   });
@@ -628,13 +654,24 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     onStopAll: () => stopAll(),
     onRemove: (runId) => removeRun(runId),
     onClearFinished: () => clearFinished(),
+    // A mini scene or a lane: that run's card in the transcript (drawn first when this window never got it).
+    onReveal: (runId) => {
+      if (renderer.revealRun(runId)) return;
+      const run = dock.getRun(runId);
+      if (run) { renderer.restoreRuns([run]); renderer.revealRun(runId); }
+    },
+    // Whatever told the tray (the sync bus, its fetch), the transcript's card and route line follow.
+    onRunChange: (run) => renderer.syncRun(run),
     onToggle: (open) => { st.dockOpen = open; agentsBtn.setAttribute('aria-pressed', open ? 'true' : 'false'); persist(); },
     onShowAllChange: (showAll) => { st.dockShowAll = showAll; persist(); },
-    onCountChange: ({ total, active, attention, visible: shown }) => {
+    onCountChange: ({ total, active, attention, working = 0, waiting = 0, visible: shown }) => {
       agentsCount.textContent = String(active || total);
       agentsCount.classList.toggle('attention', attention > 0);
       agentsBtn.hidden = !shown;
       agentsBtn.classList.toggle('attention', attention > 0);
+      // Whatever told the tray (this socket, the sync bus, its fetch after a reload): the session's status follows.
+      st.workers = { working, waiting };
+      pushStatus();
     },
   });
   agentsBtn.setAttribute('aria-pressed', st.dockOpen ? 'true' : 'false');
@@ -773,6 +810,8 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
         lockControl(packet.request_id, resolvedLabel(packet.origin, tt('assistant.control.state.answered', 'Answered')));
         return;
       case 'reattach_result':
+        // Whether a turn runs now: a route the journal left open is that turn's, or nobody's.
+        renderer.reattached(!!(packet.ok && packet.running));
         if (packet.ok) {
           if (packet.sessionId) st.providerSessionId = packet.sessionId;
           if (packet.resynced) rehydrate({ force: true });
@@ -801,6 +840,8 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
         finishTurn({ aborted: true });
         return;
       case 'error': {
+        // The server no longer has this session: no error row and no retry loop; the host closes the tab.
+        if (packet.code === 'SESSION_NOT_FOUND') { sessionGone(); return; }
         // A rejected route answer keeps its card open with the message.
         const routeCard = packet.request_id ? routeCardByRequest(packet.request_id) : null;
         if (routeCard) { routeCard.fail(packet.message); return; }
@@ -926,6 +967,7 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     if (meta.id && meta.id !== sessionId) return;
     // The server's title names the conversation (history, notifications); the tab's name is the host's.
     applyRecordName(meta);
+    if (meta.chatStartedAt || Number(meta.turns) > 0) st.chatStarted = true;
     if (meta.brain && typeof meta.brain === 'object') {
       const next = normalizeBrain({ ...st.brain, ...meta.brain, provider: meta.brain.provider || meta.brain.brain || st.brain.provider });
       if (JSON.stringify(next) !== JSON.stringify(st.brain)) { st.brain = next; picker.render(); host.setBrain?.(next); persist(); }
@@ -950,7 +992,9 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
       if (typeof meta.features.computer === 'boolean') st.features.computer = meta.features.computer;
       if (typeof meta.features.testDensity === 'boolean') st.features.testDensity = meta.features.testDensity;
       if (typeof meta.features.rename === 'boolean') st.features.rename = meta.features.rename;
+      if (typeof meta.features.adminSandbox === 'boolean') st.features.adminSandbox = meta.features.adminSandbox;
     }
+    if (typeof meta.adminSandbox === 'boolean') st.adminSandbox = meta.adminSandbox;
     if ('testDensityExplicit' in meta) st.testDensity = normalizeTestDensity(meta.testDensityExplicit, null);
     if (meta.testDensity) st.testDensityEffective = normalizeTestDensity(meta.testDensity);
     if (typeof meta.computerUse === 'boolean') st.computerEffective = meta.computerUse;
@@ -1066,6 +1110,31 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     if (!quiet) renderer.appendStatus(tt('assistant.status.testDensity', 'Test density: {level}', { level: testDensityLabel(next, t) }));
   }
 
+  /** The global Admin sandbox setting (true / false), or null while the server does not serve it. */
+  function adminSandboxView() {
+    if (st.features.adminSandbox !== true || typeof st.adminSandbox !== 'boolean') return null;
+    return st.adminSandbox;
+  }
+
+  /** Every agent SynaBun starts follows it; every window hears the change (sync:agents:admin-sandbox-changed). */
+  async function changeAdminSandbox(enabled) {
+    const before = st.adminSandbox;
+    st.adminSandbox = enabled === true;
+    picker.render();
+    try {
+      const view = await setAdminSandbox(st.adminSandbox);
+      if (typeof view?.adminSandbox === 'boolean') st.adminSandbox = view.adminSandbox;
+      picker.render();
+      renderer.appendStatus(st.adminSandbox
+        ? tt('assistant.adminSandbox.statusOn', 'Admin sandbox: on. On Windows, Codex may ask for administrator approval once per account to set up its sandbox.')
+        : tt('assistant.adminSandbox.statusOff', 'Admin sandbox: off. No agent SynaBun starts asks for administrator approval for a sandbox.'));
+    } catch (err) {
+      st.adminSandbox = before;
+      picker.render();
+      toast(err?.message || String(err));
+    }
+  }
+
   /** Fresh tabs inherit the last-used test density (like the route mode). */
   function applyLastUsedTestDensity() {
     if (saved || st.features.testDensity !== true || st.testDensity != null) return;
@@ -1312,6 +1381,7 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     st.turnStartedAt = Date.now();
     setRunning(true);
     sock.send(msg);
+    st.chatStarted = true; // the server stores the session with this prompt
     // Name the conversation like the server will (its first prompt) — not the tab.
     if (!st.userRenamed && (!st.sessionTitle || /^(?:SynaBun|Assistant(?: \d+)?)$/.test(st.sessionTitle))) {
       const guess = String(payload.text || '').split('\n')[0].trim().slice(0, 60);
@@ -1473,15 +1543,34 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     if (!st.running) setRunning(true, { label: tt('assistant.compacting', 'compacting…') });
   }
 
+  /** Nobody chatted in this session yet (and nothing runs in it): New reuses it, leaving it closes it. */
+  function unused() {
+    return !st.chatStarted && !st.running;
+  }
+
   function newSession(provider) {
     const b = provider ? normalizeBrain({ ...st.brain, provider, model: '', effort: null, agent: null, accountId: null }) : st.brain;
+    // This one is still empty: it is the new session (the server keeps one draft, not a pile of them).
+    // /new <provider> switches its brain as the picker does; what only this page showed (/help) is cleared.
+    if (unused() && !destroyed) {
+      if (provider && provider !== st.brain.provider) applyBrain(b, { requiresSwitch: true, field: 'provider' });
+      if (!renderer.isEmpty()) clearTranscript();
+      composer.focus();
+      return;
+    }
     emit('assistant:new', { brain: b, host: hostId });
   }
 
+  /** Open another assistant session; this one goes with it when nobody chatted in it (`replaces`). */
+  function openOther(id) {
+    emit('assistant:resume', { sessionId: id, host: hostId, replaces: unused() ? sessionId : null });
+  }
+
   function resume(id) {
     if (!id) return;
-    if (String(id).startsWith('assistant-')) { emit('assistant:resume', { sessionId: id, host: hostId }); return; }
+    if (String(id).startsWith('assistant-')) { if (id !== sessionId) openOther(id); return; }
     sock.send({ type: 'resume', providerSessionId: id });
+    st.chatStarted = true; // a provider conversation: the server stores the session with it
     renderer.appendDivider(tt('assistant.status.resuming', 'resuming {id}', { id: String(id).slice(0, 8) }));
   }
 
@@ -1603,35 +1692,109 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
   }
 
   // ── Menus ──
+  /**
+   * The Sessions menu: New, then every session that holds a chat (the server lists no other). Each row
+   * opens its session; its Remove (hover / focus, → from the row, Delete) asks in the row itself, then
+   * removes the session for good: its running turn and agents stop (the question says so), every host
+   * drops its tab, and the session showing here is replaced by a fresh one, as New does.
+   */
   function showSessionsMenu(list) {
-    const sessions = (Array.isArray(list) ? list : []).filter(s => s?.id);
-    const items = [
-      { id: 'new', label: tt('assistant.topbar.new', 'New assistant session'), desc: brainLabel(st.brain), icon: ICON_NEW, onSelect: () => newSession(null) },
-      { kind: 'separator' },
-    ];
-    if (!sessions.length) items.push({ kind: 'info', label: tt('assistant.sessions.empty', 'No other sessions') });
-    else items.push({ kind: 'header', label: tt('assistant.sessions.recent', 'Recent') });
-    for (const s of sessions.slice(0, 30)) {
-      const isCurrent = s.id === sessionId;
-      const b = s.brain && typeof s.brain === 'object' ? s.brain : { provider: s.brain, model: s.model, effort: s.effort };
-      items.push({
-        kind: 'radio',
-        id: s.id,
-        label: s.title || s.label || s.id,
-        desc: [brainLabel(b), relativeTime(s.updatedAt || s.createdAt), s.status].filter(Boolean).join(' · '),
-        selected: isCurrent,
-        onSelect: () => { if (!isCurrent) emit('assistant:resume', { sessionId: s.id, host: hostId }); },
-      });
-    }
-    openMenu(sessionsBtn, {
+    let sessions = (Array.isArray(list) ? list : []).filter(s => s?.id);
+    let asking = null; // the id of the row that asks "Remove …?"
+    const nameOf = (s) => s.title || s.label || s.id;
+    const build = () => {
+      const items = [
+        { id: 'new', label: tt('assistant.topbar.new', 'New assistant session'), desc: brainLabel(st.brain), icon: ICON_NEW, onSelect: () => newSession(null) },
+        { kind: 'separator' },
+      ];
+      if (!sessions.length) items.push({ kind: 'info', label: tt('assistant.sessions.empty', 'No other sessions') });
+      else items.push({ kind: 'header', label: tt('assistant.sessions.recent', 'Recent') });
+      for (const s of sessions.slice(0, 30)) {
+        const isCurrent = s.id === sessionId;
+        const name = nameOf(s);
+        if (s.id === asking) { items.push(removeQuestion(s, name, isCurrent)); continue; }
+        const b = s.brain && typeof s.brain === 'object' ? s.brain : { provider: s.brain, model: s.model, effort: s.effort };
+        items.push({
+          kind: 'radio',
+          id: s.id,
+          label: name,
+          desc: [brainLabel(b), relativeTime(s.updatedAt || s.createdAt), s.status].filter(Boolean).join(' · '),
+          selected: isCurrent,
+          onSelect: () => { if (!isCurrent) openOther(s.id); },
+          action: {
+            id: `remove:${s.id}`,
+            icon: ICON_TRASH,
+            label: tt('assistant.sessions.removeNamed', 'Remove “{title}”', { title: name }),
+            tooltip: tt('assistant.sessions.remove', 'Remove session'),
+            onSelect: () => ask(s.id),
+          },
+        });
+      }
+      return items;
+    };
+    /** "Remove “name”? …" with Remove and Cancel, in place of the row (it still matches the filter by name). */
+    const removeQuestion = (s, name, isCurrent) => {
+      const runs = Math.max(0, Number(s.activeRuns) || 0);
+      const running = isCurrent ? st.running : s.running === true;
+      const question = [
+        tt('assistant.sessions.removeAsk', 'Remove “{title}” for good?', { title: name }),
+        running ? tt('assistant.sessions.removeStopsTurn', 'Its running turn stops.') : '',
+        runs ? tt('assistant.sessions.removeStopsAgents', 'Its running agents stop ({count}).', { count: runs }) : '',
+      ].filter(Boolean).join(' ');
+      return {
+        kind: 'buttons',
+        id: `ask:${s.id}`,
+        className: 'asst-dd-confirm',
+        label: question,
+        buttons: [
+          { id: `remove-yes:${s.id}`, label: tt('assistant.sessions.removeConfirm', 'Remove'), danger: true, keywords: name, keepOpen: true, onSelect: () => confirmRemove(s, isCurrent) },
+          { id: `remove-no:${s.id}`, label: tt('common.cancel', 'Cancel'), keywords: name, keepOpen: true, onSelect: () => cancel() },
+        ],
+      };
+    };
+    const handle = openMenu(sessionsBtn, {
       title: tt('assistant.topbar.sessions', 'Sessions'),
-      items,
+      items: build(),
       role: 'menu',
       placement: 'below',
       width: 300,
       filter: sessions.length > 8,
       filterPlaceholder: tt('assistant.sessions.filter', 'Filter sessions…'),
+      // Esc while a row asks: back to the row, the menu stays open.
+      onEscape: () => { if (!asking) return false; cancel(); return true; },
     });
+    function ask(id) {
+      asking = id;
+      handle?.update({ items: build(), focus: `remove-no:${id}` });
+    }
+    function cancel() {
+      const id = asking;
+      asking = null;
+      handle?.update({ items: build(), focus: id });
+    }
+    function confirmRemove(s, isCurrent) {
+      asking = null;
+      const name = nameOf(s);
+      const done = (result) => {
+        if (result?.ok) return;
+        const text = tt('assistant.sessions.removeFailed', 'Could not remove “{title}”: {error}', { title: name, error: result?.error || tt('assistant.errorGeneric', 'Something went wrong') });
+        if (destroyed) return;
+        renderer.appendError(text);
+        announce(text);
+      };
+      if (isCurrent) {
+        // This panel's own session: a fresh one takes its place (as New), then this one goes.
+        closeMenu();
+        emit('assistant:remove', { sessionId: s.id, fresh: true, brain: st.brain, done });
+        return;
+      }
+      // Another session (open elsewhere or not): its row goes now, and focus stays in the list.
+      const at = sessions.findIndex((row) => row.id === s.id);
+      sessions = sessions.filter((row) => row.id !== s.id);
+      const next = sessions[Math.min(at, sessions.length - 1)];
+      handle?.update({ items: build(), focus: next ? next.id : 'new' });
+      emit('assistant:remove', { sessionId: s.id, fresh: false, done });
+    }
   }
 
   function engineText() {
@@ -1867,6 +2030,18 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     const requestId = msg?.request_id || msg?.requestId;
     if (requestId) lockControl(requestId, resolvedLabel(msg.resolvedBy));
   }));
+  // What this session's workers do right now (Claude and Codex workers stream their events to the page,
+  // OpenCode workers a compact copy of their tool calls: lib/opencode-worker-activity.js):
+  // their stages and the tray's scenes follow the current call.
+  unsubs.push(on('sync:sidepanel:provider-event', (msg) => {
+    const runId = msg?.run?.runId;
+    if (!runId || !dock.getRun(runId)) return;
+    const activity = activityOf(msg.event);
+    if (!activity) return;
+    const stamped = { ...activity, at: Date.now() };
+    renderer.setRunActivity(runId, stamped);
+    dock.setRunActivity(runId, stamped);
+  }));
   unsubs.push(on('sync:assistant:desktop', (msg) => computerPanel.applyDesktop(msg)));
   unsubs.push(on('sync:assistant:desktop-setup', (msg) => computerPanel.applySetup(msg)));
   // Models switched on/off elsewhere: the open Models manager reloads (the menus drop their cache on their own).
@@ -1879,6 +2054,12 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     st.routing = { ...(st.routing || {}), defaultMode: def, effectiveMode: st.routeMode || def };
     routeChip.render();
   }));
+  // The global Admin sandbox setting changed in some window (this one included): every panel shows it.
+  unsubs.push(on('sync:agents:admin-sandbox-changed', (msg) => {
+    if (typeof msg?.adminSandbox !== 'boolean' || msg.adminSandbox === st.adminSandbox) return;
+    st.adminSandbox = msg.adminSandbox;
+    picker.render();
+  }));
   unsubs.push(on('session:info', () => updateGuest()));
   unsubs.push(on('permissions:changed', () => updateGuest()));
 
@@ -1887,6 +2068,19 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
   }
 
   // ── Rehydration ──
+  /**
+   * The server no longer has this session: a draft it dropped (a restart before its first prompt, a
+   * page away too long) or one removed while this page missed the broadcast. The tab closes; one that
+   * was showing with no chat in it is replaced by a fresh session (asst-hosts.js gone), never left dead.
+   */
+  let gone = false;
+  function sessionGone() {
+    if (gone || destroyed) return;
+    gone = true;
+    sock.close();
+    emit('assistant:gone', { sessionId, fresh: visible() && unused(), brain: st.brain });
+  }
+
   async function rehydrate({ force = false } = {}) {
     try {
       const data = await getAssistantSession(sessionId);
@@ -1899,7 +2093,11 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
       // A conversation with nothing in it yet may be greeted; a restored one never is.
       if (Array.isArray(transcript) && !transcript.length && !(Number(meta?.turns) > 0)) renderer.offerGreeting();
       for (const run of (Array.isArray(data?.runs) ? data.runs : [])) dock.upsertRun(run);
+      // Run cards are not journaled: the runs the tray fetched come back into the transcript, next to the
+      // calls that dispatched them, and a worker that still works is live at once (its stage, its route line).
+      dock.ready.then(() => { if (!destroyed) renderer.restoreRuns(dock.getRuns()); });
     } catch (err) {
+      if (err?.status === 404) { sessionGone(); return; }
       console.warn('[assistant] could not restore the conversation', err);
       renderer.showEmpty();
     }
@@ -1914,7 +2112,7 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
   if (session && typeof session === 'object') applySessionMeta(session);
   else applyFeatures();
   rehydrate().finally(() => {
-    if (destroyed) return;
+    if (destroyed || gone) return;
     probeFeatures();
     applyLastUsedRouteMode();
     applyLastUsedTestDensity();
@@ -1954,7 +2152,8 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
     attachPath: (path) => { if (path) { composer.insertText(`\`${path}\` `); composer.focus(); } },
     /** The server's name for the conversation (the user's rename, else the first prompt): tooltips. */
     getConversationTitle: () => st.sessionTitle || '',
-    getStatus: () => st.status || 'idle',
+    /** The session's status as its host shows it: the brain's own with its dispatched agents' (sessionStatus). */
+    getStatus: () => st.shownStatus || 'idle',
     focus: () => composer.focus(),
     onShown: () => { syncTabLabel(); renderer.scrollEnd(true); if (visible()) composer.focus(); director.touch(); },
     onHidden: () => { closeMenu(); picker.close(); director.stopTyping(); },
@@ -1975,7 +2174,9 @@ export function mountAssistant(viewport, { sessionId, brain, host = {}, session
       unsubs.forEach(off => { try { off(); } catch { /* ignore */ } });
       document.removeEventListener('keydown', onEscCapture, true);
       surfaces.forEach((node) => { node.removeEventListener('keydown', onRootKey); node.removeEventListener('focusin', onFocusIn); });
-      closeMenu();
+      // Its own menu closes; another panel's stays open (its Sessions menu may be what removed this session).
+      const menuAnchor = currentMenuAnchor();
+      if (!menuAnchor || !menuAnchor.isConnected || root.contains(menuAnchor) || barEl.contains(menuAnchor)) closeMenu();
       closeFrameLightbox();
       if (helpModal) { helpModal.remove(); helpModal = null; }
       for (const card of routeCards.values()) card.destroy();