synabun 2.0.0-beta → 2.0.5

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

@@ -1,17 +1,52 @@
 // ═══════════════════════════════════════════
 // SynaBun Neural Interface — Loading Overlay
-// Health check, server start, server-offline retry, command copy
+// Health check, server start, server-offline retry, command copy,
+// and the restart the user asked for (the same screen, one more reason)
 // ═══════════════════════════════════════════
 
 import { fetchHealth, startHealth } from './api.js';
-import { emit } from './state.js';
+import { emit, on } from './state.js';
 import { t } from './i18n.js';
+import {
+  START_LIMITS, START_STORAGE, createStartBridge, fetchStartBeacon, isMacPlatform, isWindowsPlatform,
+  manualStartCommands, openStartLink, startBeaconTarget, startButtonUsable, startStatusView,
+} from './start-bridge.js';
+// Imported with the app, not when it is needed: once the server is down
+// nothing more can be fetched, and that is exactly when the overlay wants it.
+import { createMascot } from './synabun-mascot.js';
 
 const $ = (id) => document.getElementById(id);
 
 // ── Internal refs (resolved once on init) ──
 let _statusDot = null;
 let _initCallback = null;
+// The server-offline state: watches for the server and owns the Start button.
+let _offlineBridge = null;
+// The title the overlay was given for "offline" (a start replaces it while it runs).
+let _offlineTitle = '';
+// The mascot rig in the overlay, mounted the first time the server is offline.
+let _mascot = null;
+// The overlay was put over the running app for a restart. Everything the page
+// held (sockets, terminals, panel sessions) was the old server's, so once the
+// server is back the page loads again instead of carrying on.
+let _restartShown = false;
+// The tab's title from before the restart, for when it is refused.
+let _restartTitle = null;
+
+// What the mascot does for each thing the page knows about a start
+// (startStatusView's `mascot`), as poses of the shared rig.
+const MASCOT_POSE = {
+  asleep: 'sleep',
+  waking: 'wait',
+  working: 'think',
+  ready: 'success',
+  failed: 'error',
+  stalled: 'offline',
+};
+
+function stored(key) {
+  try { return localStorage.getItem(key); } catch { return null; }
+}
 
 // ═══════════════════════════════════════════
 // PUBLIC API
@@ -38,18 +73,32 @@ export function showLoadingError(title, sub, canStart, serverOffline) {
   const $sub = $('loading-sub');
   if ($text) $text.textContent = title;
   if ($sub) $sub.textContent = sub;
+  if (serverOffline) _offlineTitle = title;
 
+  // Offline, the button asks the OS to start the server (synabun://start); it
+  // is left out only when that launcher is known not to be registered.
+  const offlineStart = !!serverOffline && startButtonUsable(stored(START_STORAGE.launcher));
   const $action = $('loading-action');
-  if (canStart) {
+  const $btn = $('loading-action-btn');
+  if (canStart || offlineStart) {
     if ($action) $action.style.display = 'block';
+    if ($btn) $btn.disabled = false;
     const $label = $('loading-action-label');
-    if ($label) $label.textContent = t('common.start');
+    if ($label) $label.textContent = serverOffline ? t('loading.startServer') : t('common.start');
   } else {
     if ($action) $action.style.display = 'none';
   }
 
-  const $status = $('loading-action-status');
-  if ($status) $status.textContent = '';
+  clearStartStatus();
+  clearRestartLook();
+
+  if (serverOffline) {
+    const $hint = $('loading-server-cmd-hint');
+    if ($hint) $hint.textContent = offlineStart ? t('loading.runCommandOr') : t('loading.runCommandSetup');
+    watchForServer();
+  } else {
+    stopWatchingForServer();
+  }
 }
 
 /**
@@ -78,6 +127,7 @@ function resetLoadingToConnecting() {
   if (!$overlay) return;
 
   $overlay.classList.remove('error', 'server-offline');
+  stopWatchingForServer();
 
   const $text = $('loading-text');
   const $sub = $('loading-sub');
@@ -88,6 +138,8 @@ function resetLoadingToConnecting() {
   if ($sub) $sub.textContent = t('loading.initializingNeural');
   if ($action) $action.style.display = 'none';
   if ($actionStatus) $actionStatus.textContent = '';
+  clearStartStatus();
+  clearRestartLook();
   if (_statusDot) _statusDot.classList.remove('error');
 }
 
@@ -95,6 +147,24 @@ function resetLoadingToConnecting() {
 // HEALTH CHECK (called during init)
 // ═══════════════════════════════════════════
 
+/**
+ * Keep what a health answer says about this install for the moment the server
+ * is down and cannot be asked: where it lives, how it was installed, and
+ * whether the Start Server launcher is registered.
+ */
+export function rememberHealth(health) {
+  if (!health) return;
+  try {
+    if (health.projectDir) {
+      localStorage.setItem('synabun-project-dir', health.projectDir);
+    }
+    if (health.install) localStorage.setItem(START_STORAGE.install, health.install);
+    if (health.startLauncher) localStorage.setItem(START_STORAGE.launcher, health.startLauncher);
+    if (health.entry) localStorage.setItem(START_STORAGE.entry, health.entry);
+  } catch {}
+  if (health.projectDir) updateCmdText(health.projectDir);
+}
+
 /**
  * Run the health check pre-flight. If the database is unhealthy,
  * show the appropriate loading error. Returns true if healthy (or
@@ -104,9 +174,7 @@ function resetLoadingToConnecting() {
 export async function checkHealth() {
   try {
     const health = await fetchHealth();
-    if (health.projectDir) {
-      localStorage.setItem('synabun-project-dir', health.projectDir);
-    }
+    rememberHealth(health);
     if (!health.ok) {
       const messages = {
         db_missing:         [t('loading.health.databaseUnreachable.title'), health.detail || t('loading.health.databaseUnreachable.sub')],
@@ -132,7 +200,286 @@ export async function checkHealth() {
  */
 function updateCmdText(projectDir) {
   const cmdEl = $('loading-cmd-text');
-  if (cmdEl) cmdEl.textContent = `cd "${projectDir}" ; npm start`;
+  if (!cmdEl) return;
+  const commands = manualStartCommands({
+    projectDir,
+    install: stored(START_STORAGE.install),
+    entry: stored(START_STORAGE.entry),
+    windows: isWindowsPlatform(navigator),
+  });
+  // One box: the command for this install (the checkout's when it is not known).
+  cmdEl.textContent = commands[commands.length - 1].command;
+}
+
+// ═══════════════════════════════════════════
+// INTERNAL — Server offline: Start Server + reconnect
+// ═══════════════════════════════════════════
+
+function stopWatchingForServer() {
+  if (_offlineBridge) _offlineBridge.stop();
+  _offlineBridge = null;
+  poseMascot('asleep');
+}
+
+/** The lines a start writes under the button, emptied. */
+function clearStartStatus() {
+  for (const id of ['loading-action-status', 'loading-action-elapsed', 'loading-action-hint', 'loading-action-log']) {
+    const el = $(id);
+    if (el) el.textContent = '';
+  }
+  const $trail = $('loading-action-trail');
+  if ($trail) $trail.replaceChildren();
+}
+
+/** What a restart changed about the overlay's look, undone. */
+function clearRestartLook() {
+  const $overlay = $('loading-overlay');
+  if ($overlay) $overlay.classList.remove('over-app', 'restart-busy', 'restart-refused');
+  const btn = $('loading-action-btn');
+  if (btn) btn.style.display = '';
+}
+
+/**
+ * The overlay's mascot as the shared rig, so a start can be acted out. The
+ * markup's own still drawing stays as the fallback when the rig cannot mount.
+ */
+function mountMascot() {
+  if (_mascot) return;
+  const host = $('loading-mascot');
+  if (!host) return;
+  try {
+    const still = host.querySelector('svg');
+    _mascot = createMascot(host, { width: 160, height: 80, pose: 'sleep', active: false });
+    if (still && still !== _mascot.el) still.style.display = 'none';
+  } catch {
+    _mascot = null;
+  }
+}
+
+/** 'asleep' is the still sleeping face (the overlay's own bob and z carry it); every other state plays its pose. */
+function poseMascot(state) {
+  const host = $('loading-mascot');
+  if (host) host.setAttribute('data-state', state);
+  if (!_mascot) return;
+  try {
+    _mascot.setPose(MASCOT_POSE[state] || 'sleep');
+    _mascot.setActive(state !== 'asleep');
+  } catch {}
+}
+
+/**
+ * Draw one snapshot of the start: the sentence (a live region, written only
+ * when it changes), the page's own clock, and the steps the launcher reported
+ * with the time each one happened. Nothing here is estimated.
+ */
+function renderStart(snap) {
+  const platform = isWindowsPlatform(navigator) ? 'windows' : isMacPlatform(navigator) ? 'mac' : 'linux';
+  const view = startStatusView(snap, { platform });
+  const say = (line) => (line ? t(`loading.start.${line.key}`, line.params) : '');
+  // A restart this page asked for or was told of, while it runs.
+  const restarting = !!snap.restart && (view.busy || view.state === 'online');
+
+  poseMascot(view.mascot);
+
+  const $overlay = $('loading-overlay');
+  if ($overlay) {
+    // While a restart runs there is nothing to press and no command to type;
+    // refused, the server is still there and only the way back is offered.
+    $overlay.classList.toggle('restart-busy', restarting);
+    $overlay.classList.toggle('restart-refused', view.state === 'refused');
+  }
+
+  const $text = $('loading-text');
+  if ($text) {
+    const title = view.heading ? t(`loading.start.${view.heading}`)
+      : view.mascot === 'waking' || view.mascot === 'working' ? t('loading.start.headingStarting')
+        : view.mascot === 'ready' ? t('loading.start.headingReady')
+          : view.mascot === 'failed' ? t('loading.start.headingFailed')
+            : _offlineTitle || t('loading.serverOffline');
+    if ($text.textContent !== title) $text.textContent = title;
+  }
+
+  // Under the title: whose restart this is, for as long as it is one.
+  const $sub = $('loading-sub');
+  if ($sub && _restartShown) {
+    const sub = view.state === 'refused' ? t('loading.restartSubRefused')
+      : restarting ? (snap.restart.asked ? t('loading.restartSubAsked') : t('loading.restartSubTold'))
+        : t('loading.serverNotRunning');
+    if ($sub.textContent !== sub) $sub.textContent = sub;
+  }
+
+  const btn = $('loading-action-btn');
+  const $label = $('loading-action-label');
+  if (btn) {
+    btn.disabled = view.busy || view.state === 'online';
+    // No dead button: when a restart did not bring the server back, Start is
+    // offered only if its launcher is there (the command below always is).
+    const startOffered = view.button === 'start' || view.button === 'retry';
+    btn.style.display = _restartShown && startOffered && !startButtonUsable(stored(START_STORAGE.launcher)) ? 'none' : '';
+  }
+  if ($label) {
+    $label.textContent = view.button === 'starting' ? t('loading.starting')
+      : view.button === 'retry' ? t('common.retry')
+        : view.button === 'back' ? t('loading.restartBack') : t('loading.startServer');
+  }
+
+  const $status = $('loading-action-status');
+  const line = say(view.headline);
+  if ($status && $status.textContent !== line) $status.textContent = line;
+
+  const $elapsed = $('loading-action-elapsed');
+  if ($elapsed) {
+    $elapsed.textContent = view.elapsed;
+    $elapsed.setAttribute('aria-label', view.elapsed ? `${t(`loading.start.${view.elapsedLabel}`)}: ${view.elapsed}` : '');
+  }
+
+  const $hint = $('loading-action-hint');
+  if ($hint) $hint.textContent = say(view.hint);
+
+  const $trail = $('loading-action-trail');
+  if ($trail) {
+    $trail.replaceChildren(...view.trail.map((row) => {
+      const item = document.createElement('li');
+      const what = document.createElement('span');
+      what.textContent = t(`loading.start.${row.key}`);
+      const when = document.createElement('span');
+      when.className = 'at';
+      when.textContent = row.time;
+      item.append(what, when);
+      return item;
+    }));
+  }
+
+  const $log = $('loading-action-log');
+  if ($log) $log.textContent = view.error?.log ? t('loading.start.failedLog', { path: view.error.log }) : '';
+}
+
+/**
+ * While the overlay says the server is offline: keep asking for it, and let
+ * the Start button hand the OS a synabun://start link. Reconnects by itself
+ * the moment the server answers, however it was started. While a start is
+ * under way it shows what the launcher itself reports (its beacon), never a
+ * guess: see start-bridge.js.
+ */
+function watchForServer() {
+  if (_offlineBridge) return;
+  openBridge().watch();
+}
+
+/**
+ * Is the server answering, which server is it (`bootId`), and does it say it
+ * is on its way out for a restart. One that predates those two says neither.
+ */
+async function probeServer() {
+  const health = await fetchHealth();
+  return {
+    up: !!health && health.ok !== false,
+    boot: typeof health?.bootId === 'string' ? health.bootId : '',
+    stopping: health?.restarting === true,
+  };
+}
+
+/** The bridge behind the overlay, for either reason it is up: the server is offline, or it is being restarted. */
+function openBridge() {
+  mountMascot();
+  const beaconAt = startBeaconTarget(window.location);
+  const bridge = createStartBridge({
+    probe: probeServer,
+    launch: () => openStartLink({ document, location: window.location, userAgent: navigator.userAgent }),
+    beacon: beaconAt ? () => fetchStartBeacon(beaconAt) : null,
+    port: beaconAt ? beaconAt.port : 0,
+    onUpdate(snap) {
+      if (_offlineBridge !== bridge) return;
+      renderStart(snap);
+    },
+    onState(state) {
+      if (_offlineBridge !== bridge) return;
+      if (state !== 'online') return;
+      // Back from a restart: the page loads again, after the frame that says so.
+      if (_restartShown) {
+        setTimeout(() => window.location.reload(), START_LIMITS.reloadDelayMs);
+        return;
+      }
+      resetLoadingToConnecting();
+      emit('loading:retried');
+      if (_initCallback) _initCallback();
+    },
+  });
+  _offlineBridge = bridge;
+  return bridge;
+}
+
+// ═══════════════════════════════════════════
+// Restart Server
+// ═══════════════════════════════════════════
+
+/**
+ * The user chose Restart Server. The screen changes here, in the click: the
+ * overlay is up and says a restart was asked for before the request has even
+ * left, and nothing on the way to that first frame waits for the network.
+ * From there it shows what is really known (start-bridge.js `restart()`): the
+ * server's answer, its own word that it is shutting down, the probe that finds
+ * it gone, the supervisor's report of bringing it back. The page loads again
+ * by itself when another server than the one that was asked answers.
+ */
+export function requestServerRestart() {
+  return beginRestart({ request: postRestart });
+}
+
+/** Ask for the restart: { ok, boot } when the server says it will, { ok: false, status, message } when it will not. */
+async function postRestart() {
+  const res = await fetch('/api/server/restart', { method: 'POST', signal: AbortSignal.timeout(10000) });
+  let body = null;
+  try { body = await res.json(); } catch {}
+  if (!res.ok || !body || body.ok === false) {
+    return { ok: false, status: res.status, message: String(body?.error || body?.message || '') };
+  }
+  return { ok: true, boot: typeof body.bootId === 'string' ? body.bootId : '' };
+}
+
+/**
+ * Show the restart: this window asked for it (`request`), or the server told
+ * every window that it is restarting (`announced`, over the sync socket).
+ */
+function beginRestart({ request = null, announced = false, boot = '' } = {}) {
+  // Already on screen (this window asked, and here is the server saying so too).
+  if (_restartShown && _offlineBridge) {
+    _offlineBridge.restart({ announced, boot });
+    return false;
+  }
+  // The overlay is up because the server is offline: there is nothing to restart.
+  if (_offlineBridge) return false;
+  const $overlay = $('loading-overlay');
+  if (!$overlay) return false;
+
+  _restartShown = true;
+  _restartTitle = document.title;
+  document.title = t('loading.start.headingRestarting');
+  _offlineTitle = t('loading.serverOffline');
+  // `over-app`: no fade-in and above whatever is open. The screen is there in the frame of the click.
+  $overlay.classList.add('over-app', 'error', 'server-offline');
+  $overlay.classList.remove('hidden');
+  // Nothing behind the screen keeps the keyboard (a terminal, an editor).
+  try { document.activeElement?.blur?.(); } catch {}
+  if (_statusDot) _statusDot.classList.add('error');
+  const $action = $('loading-action');
+  if ($action) $action.style.display = 'block';
+  const $hint = $('loading-server-cmd-hint');
+  if ($hint) $hint.textContent = startButtonUsable(stored(START_STORAGE.launcher)) ? t('loading.runCommandOr') : t('loading.runCommandSetup');
+  const $retry = $('loading-retry-status');
+  if ($retry) $retry.textContent = '';
+  clearStartStatus();
+  return openBridge().restart({ request, announced, boot });
+}
+
+/** The restart did not happen and the server is still there: give the app back. */
+function dismissRestart() {
+  resetLoadingToConnecting();
+  _restartShown = false;
+  if (_restartTitle !== null) document.title = _restartTitle;
+  _restartTitle = null;
+  const $overlay = $('loading-overlay');
+  if ($overlay) $overlay.classList.add('hidden');
 }
 
 // ═══════════════════════════════════════════
@@ -144,6 +491,11 @@ function updateCmdText(projectDir) {
  * Calls /api/health/start and re-triggers init on success.
  */
 async function handleStartAction() {
+  // A restart the server refused: the button is the way back to the app.
+  if (_offlineBridge && _offlineBridge.state === 'refused') { dismissRestart(); return; }
+  // Server offline: nothing to call, the OS starts it.
+  if (_offlineBridge) { _offlineBridge.start(); return; }
+
   const btn = $('loading-action-btn');
   const $status = $('loading-action-status');
   const $label = $('loading-action-label');
@@ -165,8 +517,6 @@ async function handleStartAction() {
       if ($label) $label.textContent = t('common.retry');
     }
   } catch (err) {
-    // Server is unreachable — try protocol handler as fallback
-    window.location.href = 'synabun://start';
     if ($status) $status.textContent = t('loading.somethingWrong');
     if (btn) btn.disabled = false;
     if ($label) $label.textContent = t('common.retry');
@@ -205,6 +555,8 @@ async function handleRetryConnection() {
     // fetchHealth uses AbortSignal.timeout(3000) internally
     if (health && health.ok !== false) {
       if ($status) $status.textContent = t('loading.connectedLoading');
+      // After a restart the page loads again (see openBridge).
+      if (_restartShown) { window.location.reload(); return; }
       resetLoadingToConnecting();
       emit('loading:retried');
       if (_initCallback) _initCallback();
@@ -252,4 +604,7 @@ export function initLoading({ onInit } = {}) {
   // ── Retry connection ──
   const retryBtn = $('loading-retry-btn');
   if (retryBtn) retryBtn.addEventListener('click', handleRetryConnection);
+
+  // ── The server says it is restarting (ui-sync.js): every window shows it ──
+  on('server:restarting', (msg) => beginRestart({ announced: true, boot: typeof msg?.bootId === 'string' ? msg.bootId : '' }));
 }

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

@@ -9,11 +9,13 @@ import { storage } from './storage.js';
 import { KEYS } from './constants.js';
 import { getMenuItems } from './registry.js';
 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 } from './ui-update.js';
+import { requestServerRestart } from './ui-loading.js';
 
 const $ = (id) => document.getElementById(id);
 
@@ -83,7 +85,7 @@ export function initMenubar() {
     const dropdown = document.querySelector('.menubar-item.open .menubar-dropdown');
     if (!dropdown) return;
 
-    const allItems = [...dropdown.querySelectorAll('.menu-item:not(.disabled)')];
+    const allItems = [...dropdown.querySelectorAll('.menu-item:not(.disabled):not([hidden])')];
     if (allItems.length === 0) return;
 
     const focused = dropdown.querySelector('.menu-item.focused');
@@ -368,6 +370,7 @@ function wireAutomationsMenu() {
 // ── Apps Menu (formerly Terminal) ──
 
 function wireTerminalMenu() {
+  let disarmInstallHandoff = () => {};
   const items = {
     'menu-terminal-assistant': () => emit('assistant:open'),
     'menu-terminal-claude':  () => emit('terminal:open', { profile: 'claude-code' }),
@@ -413,45 +416,15 @@ function wireTerminalMenu() {
     'menu-command-runner':   () => emit('command-runner:open'),
     'menu-terminal-link':    () => emit('link:toggle'),
     'menu-terminal-toggle':  () => emit('terminal:toggle'),
-    'menu-install-app':      async () => {
-      if (window._pwaInstallPrompt) {
-        window._pwaInstallPrompt.prompt();
-        const { outcome } = await window._pwaInstallPrompt.userChoice;
-        if (outcome === 'accepted') {
-          window._pwaInstallPrompt = null;
-          const el = $('menu-install-app');
-          if (el) el.style.display = 'none';
-        }
-      }
-    },
-    'menu-restart-server':   async () => {
-      try {
-        // Cache project path before server goes down
-        try {
-          const h = await fetch('/api/health');
-          const hd = await h.json();
-          if (hd.projectDir) localStorage.setItem('synabun-project-dir', hd.projectDir);
-        } catch {}
-        document.title = 'Restarting...';
-        await fetch('/api/server/restart', { method: 'POST' });
-
-        // Poll /api/health until the server has gone down AND come back up.
-        // The everDown flag prevents premature reload during the brief window
-        // where the old process is still serving requests during shutdown grace.
-        const deadline = Date.now() + 15000;
-        let everDown = false;
-        while (Date.now() < deadline) {
-          await new Promise(r => setTimeout(r, 250));
-          try {
-            const r = await fetch('/api/health', { cache: 'no-store' });
-            if (!r.ok) { everDown = true; continue; }
-            if (everDown) { location.reload(); return; }
-          } catch { everDown = true; }
-        }
-        // Timeout safety net — reload anyway so the user isn't stranded.
-        location.reload();
-      } catch {}
+    'menu-install-app': async () => {
+      disarmInstallHandoff(); // asked for here: this click opens the dialog, no later one does
+      const result = await requestPwaInstall();
+      if (result === 'instructions') location.assign(installGuideUrl());
     },
+    // The restart screen is drawn in this click, before anything is asked of
+    // the network; from there it follows the restart and loads the page again
+    // when the server is back (ui-loading.js requestServerRestart).
+    'menu-restart-server':   () => { requestServerRestart(); },
     'menu-stop-server':      async () => {
       const previousTitle = document.title;
       try {
@@ -478,23 +451,16 @@ function wireTerminalMenu() {
   registerAction('toggle-terminal', () => emit('terminal:toggle'));
   registerAction('toggle-terminal-alt', () => emit('terminal:toggle'));
 
-  // PWA install prompt — show "Install as App" when the browser supports it
-  window.addEventListener('beforeinstallprompt', (e) => {
-    e.preventDefault();
-    window._pwaInstallPrompt = e;
+  initPwaInstall({ changed: value => {
     const el = $('menu-install-app');
-    if (el) el.style.display = '';
-  });
-  window.addEventListener('appinstalled', () => {
-    window._pwaInstallPrompt = null;
-    const el = $('menu-install-app');
-    if (el) el.style.display = 'none';
-  });
-  // Hide if already running as installed PWA
-  if (window.matchMedia('(display-mode: standalone)').matches || navigator.standalone) {
-    const el = $('menu-install-app');
-    if (el) el.style.display = 'none';
-  }
+    if (el) el.style.display = value === 'installed' ? 'none' : '';
+  } });
+  const installItem = $('menu-install-app');
+  if (installItem && !isStandalone()) installItem.style.display = '';
+  // Sent on by the launcher's guide page: the browser's install dialog opens from the first click or key press,
+  // for this one page load. The event it uses is spent, so the menu item goes to the guide page after that.
+  disarmInstallHandoff = armPwaInstallHandoff({ leave: event => !!installItem?.contains(event.target) });
+
 }
 
 // ── Variant menu items injection ──

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

@@ -92,3 +92,14 @@ export class LocalReleaseTracker {
     }
   }
 }
+
+/**
+ * The saved list of dismissed runs (localStorage, `[{ runId, at }]`) without
+ * one run: what the agents dock's Focus leaves when it reopens a closed tab.
+ * Anything unreadable becomes an empty list.
+ */
+export function withoutDismissed(raw, runId) {
+  let stored;
+  try { stored = JSON.parse(raw || '[]'); } catch { stored = []; }
+  return JSON.stringify((Array.isArray(stored) ? stored : []).filter((entry) => entry?.runId && entry.runId !== runId));
+}

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

@@ -7,6 +7,7 @@ import {
   isNewerRunDescriptor,
   LocalReleaseTracker,
   resolveRouteClaim,
+  withoutDismissed,
 } from './ui-native-loop-router-state.js';
 
 const DISMISSED_KEY = 'synabun-native-loop-dismissed';
@@ -48,6 +49,15 @@ function mergeDismissed(raw) {
 
 try { mergeDismissed(localStorage.getItem(DISMISSED_KEY)); } catch {}
 
+// A closed tab's run is dismissed: nothing routes it back here by itself (a
+// reconcile, a late event, another window's claim). Only the user asks for it
+// again, with the agents dock's Focus (focusNativeLoopRun with `reopen`).
+function undismiss(runId) {
+  if (!_dismissed.delete(runId)) return false;
+  try { localStorage.setItem(DISMISSED_KEY, withoutDismissed(localStorage.getItem(DISMISSED_KEY), runId)); } catch {}
+  return true;
+}
+
 function persistDismissed() {
   try {
     const existing = JSON.parse(localStorage.getItem(DISMISSED_KEY) || '[]');
@@ -279,10 +289,13 @@ export function getNativeLoopRun(runId) {
  * Bring a dispatched run's sidepanel tab to the front. Attaches with
  * focus:true even when this window already owns the claim (the normal route
  * path only focuses on first attach). Falls back to a fetch when the run has
- * not been broadcast to this window yet.
+ * not been broadcast to this window yet. With `reopen` (the user's own Focus,
+ * in the agents dock) a run whose tab was closed opens again: a live run
+ * attaches as it would have, an ended one with its transcript and end card.
  */
-export async function focusNativeLoopRun(runId) {
+export async function focusNativeLoopRun(runId, { reopen = false } = {}) {
   if (!runId || _suspended) return false;
+  if (reopen) undismiss(runId);
   let run = getNativeLoopRun(runId);
   if (!run) {
     try {