synabun 2.0.9 → 2.1.0

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

@@ -8,6 +8,7 @@ import { state, emit, on } from './state.js';
 import { KEYS } from './constants.js';
 import { storage } from './storage.js';
 import { catColor } from './colors.js';
+import { escapeHtml } from './utils.js';
 
 const $ = (id) => document.getElementById(id);
 
@@ -120,7 +121,7 @@ export function renderBookmarks() {
     item.innerHTML = `
       <div class="dropdown-item-dot" style="background:${color}"></div>
       <div class="dropdown-item-text">
-        <div class="dropdown-item-title">${b.title}</div>
+        <div class="dropdown-item-title">${escapeHtml(String(b.title ?? ''))}</div>
         <div class="dropdown-item-sub">${b.category}</div>
       </div>
       <button class="icon-btn icon-btn--danger" style="width:22px;height:22px;font-size:13px;border:none" data-tooltip="Remove">&times;</button>

package/neural-interface/public/shared/ui-claude-panel.js

@@ -23,7 +23,8 @@ import { createStickyScrollController } from './ui-scroll-follow.js';
 import { requestGeneratedSessionTitle } from './session-title.js';
 import { wireFileLinks } from './ui-file-links.js';
 import { WORKER_END_CLASS, backToAssistant, buildWorkerEndCard, endWorkerRunOnClose, forgetWorkerEnd, trackWorkerEnd, updateWorkerEndBusy } from './ui-worker-end.js';
-import { isDispatchedRun, isEndOfRunAbort } from './worker-end.js';
+import { isDispatchedRun, isEndOfRunAbort, workerEndView } from './worker-end.js';
+import { runAwaitsAnswer } from './sidepanel-session-status.js';
 // ── cp/ feature modules (SDK-engine CLI parity: diffs, agents, bash, perms, statusline) ──
 import { setCpCtx } from './cp/cp-ctx.js';
 import { buildDiffCard, buildDiffPreviewEl, finalizeDiffCard } from './cp/cp-diff.js';
@@ -46,7 +47,8 @@ import { historyHasResultSupport, historyResultsNotice, snapshotWantsResults, fu
 import { CP_STYLES } from './cp/cp-styles.js';
 import { TEMPORARY_CAPABILITY, keepsNothing, chooseTemporary, applyTemporary, temporaryRefusal, endTemporary, leaveTemporary, tabAfterTemporary, persistableTabs, temporaryBlocks, reattaches } from './cp/cp-temporary.js';
 import { paintTemporary } from './cp/cp-temporary-view.js';
-import { renderMarkdown, scrubStoredHtml } from './cp/cp-markdown.js';
+import { renderMarkdown } from './cp/cp-markdown.js';
+import { sanitizeStoredHtml } from './assistant/asst-sanitize.js';
 import { escapeHtml, classToken } from './cp/cp-markdown.js';
 import { rehydrateStoredTranscript } from './cp/cp-rehydrate.js';
 import { compactHolds, compactQueue, isCompactCommand, newConversation, nextQueued, ownsQueued, queuedRefusal, restoredQueue, QUEUED_REFUSAL_LINES } from './cp/cp-compose.js';
@@ -178,7 +180,7 @@ let _cliBanner = null;
 let _marked = null;
 (async () => {
   try {
-    const m = await import('https://cdn.jsdelivr.net/npm/marked@14/lib/marked.esm.js').catch(() => null);
+    const m = await import('/vendor/marked/marked-14.1.4.esm.js').catch(() => null);
     if (m) {
       _marked = m.marked || m.default;
       if (_marked?.setOptions) _marked.setOptions({ breaks: true, gfm: true });
@@ -2338,6 +2340,11 @@ function injectStyles() {
     .cp-session-pill.cp-pill-running .term-minimized-pill-icon { color: rgba(212, 162, 127, 1); }
     .cp-session-pill:hover .term-minimized-pill-icon { color: rgba(212, 162, 127, 0.85); }
     .cp-session-pill .term-minimized-pill-icon svg { width: 12px; height: 12px; }
+    /* A session that waits on you (a permission, a plan, an MCP server's request, a question): the
+       warn hairline and mark of the Assistant's and a detached window's pills, in place of the
+       working look (paintPillState). */
+    .cp-session-pill.cp-pill-attention { border-color: color-mix(in srgb, var(--accent-orange, #FFB74D) 42%, transparent); }
+    .cp-session-pill.cp-pill-attention .term-minimized-pill-icon { color: var(--accent-orange, #FFB74D); }
     .cp-session-pill.cp-pill-enter {
       animation: cp-pill-pop-in 0.25s cubic-bezier(0.34, 1.56, 0.64, 1) forwards;
     }
@@ -2593,7 +2600,7 @@ function injectStyles() {
       border: 0.5px solid rgba(255,255,255,0.05);
       border-radius: 6px;
       font-size: 11px; color: rgba(255,255,255,0.7);
-      cursor: grab;
+      cursor: move;
       transition: background 0.15s, border-color 0.15s;
     }
     .cp-queue-item:hover {
@@ -2607,7 +2614,7 @@ function injectStyles() {
       background: rgba(120,180,255,0.08);
     }
     .cp-queue-drag {
-      color: rgba(255,255,255,0.2); cursor: grab;
+      color: rgba(255,255,255,0.2); cursor: move;
       font-size: 10px; user-select: none; flex-shrink: 0;
     }
     .cp-queue-text {
@@ -2909,6 +2916,7 @@ function newTabState(sessionId = null, label = 'New chat', id = null) {
     mcpServers: [],           // from system/init + mcp_status events
     automationRunId: null,
     automationActive: false,
+    automationAwaits: false,  // the run's turn ended asking the user (runAwaitsAnswer): its pill needs you
     automationOwnerId: null,
     releasedRunId: null,      // the ended run this tab showed before the user continued it by hand
   };
@@ -3201,6 +3209,9 @@ function _createTrayPill(tab) {
     if (idx >= 0) closeTab(idx);
   });
   pill.style.display = 'none'; // Hidden by default; renderPills() controls visibility
+  // A pill made after the tab started working (a tray that was not there yet) starts out working too,
+  // or needing you.
+  paintPillState(pill, tab);
   tray.appendChild(pill);
   return pill;
 }
@@ -3220,8 +3231,10 @@ function _renderPillsNow() {
   const panelOpen = _visible;
   for (let i = 0; i < _tabs.length; i++) {
     const tab = _tabs[i];
-    if (!tab.pillEl) tab.pillEl = _createTrayPill(tab);
+    if (!tab.pillEl?.isConnected) tab.pillEl = _createTrayPill(tab);
     if (!tab.pillEl) continue;
+    // Every pass says it again: a re-render never leaves a working tab's pill idle.
+    paintPillState(tab.pillEl, tab);
     const isActive = i === activeIdx;
     const shouldShow = !isActive || !panelOpen;
     const wasHidden = tab.pillEl.style.display === 'none';
@@ -3247,15 +3260,52 @@ function updatePillLabel(tab) {
   if (lbl) lbl.textContent = tab.label;
 }
 
+/**
+ * A tab works while its turn runs, and also once the turn ended while background work it started
+ * still runs (agents, shells, workflows: the CLI's own live list, non-ambient, the statusline's count):
+ * the session reports back when they end, so its pill keeps moving, like their cards in the transcript.
+ */
+function tabWorking(tab) {
+  return !!tab?.running || (Array.isArray(tab?.backgroundWork) && tab.backgroundWork.length > 0);
+}
+
+/**
+ * A tab needs you while its session waits on your answer: a permission, a plan approval or an MCP
+ * server's request (the card on screen, and the ones queued behind it), or a question; and, for a
+ * dispatched worker, while its turn ended asking you something (the run's outcome: automationAwaits).
+ */
+function tabNeedsYou(tab) {
+  return !!(tab?._activePerm || tab?._permQueue?.length || tab?.pendingAskRequestId || tab?.automationAwaits);
+}
+
+/** What a tab's pill says: it needs you > it works > it rests (read for a detached window's pill too). */
+function paintPillState(pill, tab) {
+  const needsYou = tabNeedsYou(tab);
+  pill.classList.toggle('cp-pill-attention', needsYou);
+  pill.classList.toggle('cp-pill-running', !needsYou && tabWorking(tab));
+}
+
+// Whether each tab was saved needing you: a change is written at once, for the placeholder a reload
+// shows and the pill of a detached window that has not loaded yet (ui-sidepanel-tray.js).
+const _needsYouSaved = new WeakMap();
 function updatePillRunning(tab) {
-  if (tab.pillEl) tab.pillEl.classList.toggle('cp-pill-running', tab.running);
+  if (tab.pillEl) paintPillState(tab.pillEl, tab);
+  const needsYou = tabNeedsYou(tab);
+  if ((_needsYouSaved.get(tab) || false) === needsYou) return;
+  _needsYouSaved.set(tab, needsYou);
+  saveTabs();
 }
 
 function saveTabs() {
   try {
     // A temporary tab is never written: not the tab, its label, its queue or its session id.
+    // `backgroundWork`: how many background agents and shells it still ran (tabWorking). A tab whose turn
+    // ended while they run is working too: after a reload its placeholder says so and the panel loads to ask
+    // (ui-sidepanel-tray.js). Never restored: the reattach's live list says what still runs. `needsYou`:
+    // a permission or a question waited on the user (tabNeedsYou): its placeholder says so and the panel
+    // loads to ask, and the reattach brings the card back.
     const kept = persistableTabs(_tabs, _activeTabIdx);
-    const localTabs = kept.tabs.map(t => ({ id: t.id, sessionId: t.sessionId, label: t.label, titleState: t.titleState === 'generating' ? 'default' : (t.titleState || 'default'), sessionCost: t.sessionCost || 0, running: t.running || false, project: t.project || '', model: t.model || '', effort: t.effort || 'off', planMode: t.planMode || false, ...savedMode(t), toolPolicy: t.toolPolicy || 'full', accountId: t.accountId || '', session: normalizeSession(t.session), transcriptAt: t.transcriptAt || null, planFilePath: t.planFilePath || '', conversation: t.conversation || '', queue: t.queue || [], queuePaused: t.queuePaused || false, automationRunId: t.automationRunId || null, automationActive: !!t.automationActive, automationOwnerId: t.automationOwnerId || null, releasedRunId: t.releasedRunId || null }));
+    const localTabs = kept.tabs.map(t => ({ id: t.id, sessionId: t.sessionId, label: t.label, titleState: t.titleState === 'generating' ? 'default' : (t.titleState || 'default'), sessionCost: t.sessionCost || 0, running: t.running || false, backgroundWork: Array.isArray(t.backgroundWork) ? t.backgroundWork.length : 0, needsYou: tabNeedsYou(t), project: t.project || '', model: t.model || '', effort: t.effort || 'off', planMode: t.planMode || false, ...savedMode(t), toolPolicy: t.toolPolicy || 'full', accountId: t.accountId || '', session: normalizeSession(t.session), transcriptAt: t.transcriptAt || null, planFilePath: t.planFilePath || '', conversation: t.conversation || '', queue: t.queue || [], queuePaused: t.queuePaused || false, automationRunId: t.automationRunId || null, automationActive: !!t.automationActive, automationOwnerId: t.automationOwnerId || null, releasedRunId: t.releasedRunId || null }));
     const localRunIds = new Set(localTabs.map((tab) => tab.automationRunId).filter(Boolean));
     let foreignAutomationTabs = [];
     try {
@@ -4550,9 +4600,9 @@ function flushAllSessionSnapshots() {
 function renderStoredSession(snapshot, $msgs, tab) {
   const norm = _normalizeSnapshotEntry(snapshot);
   if (!norm || !$msgs) return false;
-  // A snapshot comes back from storage and may predate the sanitiser: nothing
-  // that can run or load code is put back (cp/cp-markdown.js).
-  $msgs.replaceChildren(scrubStoredHtml(norm.html));
+  // A snapshot comes back from storage and may predate the sanitiser: it is rebuilt
+  // from the stored-transcript allowlist every panel uses (asst-sanitize.js).
+  $msgs.replaceChildren(sanitizeStoredHtml(norm.html));
   // Restored DOM has no event handlers. Pending prompts (permission, plan, ask
   // cards) are stale and go, answered ones stay inert; the read-only actions
   // are wired again from what the markup saved: rewind (prompt uuid), the
@@ -5282,10 +5332,14 @@ function _setBackgroundWork(tab, tasks) {
   // reloaded while it ran) gets one, so /tasks can show and stop it.
   try { adoptLiveTasks(tab.tasks, tasks); } catch {}
   try { reconcileTasks(tab.tasks, tasks); } catch {}
+  const before = Array.isArray(tab.backgroundWork) ? tab.backgroundWork.length : 0;
   tab.backgroundWork = (Array.isArray(tasks) ? tasks : [])
     .filter(t => t && !t.ambient)
     .map(t => ({ id: t.task_id, type: t.task_type || '', description: t.description || '' }));
   if (tab === activeTab()) { try { renderStatusline(tab); } catch {} }
+  updatePillRunning(tab);
+  // Saved as it changes: a reload with only this left running loads the panel to ask (saveTabs).
+  if (tab.backgroundWork.length !== before) saveTabs();
 }
 
 function _processTabMsg(tab, msg) {
@@ -5343,6 +5397,7 @@ function _processTabMsg(tab, msg) {
       if (tab._pendingPlan?.requestId === msg.request_id) tab._pendingPlan = null;
       if (tab._activePerm) { tab._activePerm = false; _showNextPerm(tab); }
       else _flushMsgBuffer(tab);
+      updatePillRunning(tab);
       break;
     }
     case 'reattach_result': {
@@ -5387,7 +5442,8 @@ function _processTabMsg(tab, msg) {
         if (expectRunning && !(tab.sendStartedAt > tab._reattachSentAt)) {
           console.log('[claude-panel] No orphan to reattach — the turn ended while disconnected');
           finishTab(tab, true);
-          appendStatus(tab, 'Connection lost — this turn did not survive the disconnect.');
+          // A dispatched worker's session says what became of its run (resumed, or how it ended), not only this.
+          _lostTurnLine(tab).then((line) => { if (!tab.closed) appendStatus(tab, line); });
         }
         // Prompts queued behind a Compact when the socket closed: nothing says it finished.
         if (tab._queueWaits === 'session') _compactQueue.after(tab, 'lost');
@@ -6885,6 +6941,7 @@ function sendAskAnswer(tab, questions, answers, annotations = null) {
   tab.pendingAskRequestId = null;
   tab.pendingAskToolUseId = null;
   tab.pendingAskBufferedAnswer = null;
+  updatePillRunning(tab); // answered: the pill no longer needs you
   // Flush BEFORE clearing askRenderedViaControl — buffered assistant events
   // must see the flag so buildAskFromToolUse returns a hidden placeholder
   // instead of rendering a duplicate card.
@@ -7400,6 +7457,7 @@ function handleControlRequest(tab, msg) {
   if (toolName === 'AskUserQuestion') {
     // AskUserQuestion: save the request_id — answer is sent via control_response when user picks an option
     tab.pendingAskRequestId = requestId;
+    updatePillRunning(tab); // the pill needs you
     // If tool_use block hasn't rendered the ask card yet, render from control_request input
     // Also check askRenderedViaControl to prevent duplicate cards from denial control_requests
     if (!tab.pendingAskToolUseId && !tab.askRenderedViaControl) {
@@ -8501,6 +8559,7 @@ function finishTab(tab, skipNotif) {
   if (tab.sessionId && tab._snapshotDirty) flushSessionSnapshotSave(tab);
   hideThinking(tab); setRunning(tab, false); tab._wasRunning = false; tab.currentMsgEl = null; tab.currentMsgId = null; tab.pendingAskToolUseId = null; tab.pendingAskRequestId = null; tab.pendingAskBufferedAnswer = null; tab.askRenderedViaControl = false; tab.sendStartedAt = null; tab._planContentCaptured = false; if (tab._stream?.mdTimer) clearTimeout(tab._stream.mdTimer); tab._stream = null;
   tab.currentActivity = null;
+  updatePillRunning(tab); // (its question went with the turn)
   if (tab === activeTab()) { try { renderStatusline(tab); } catch {} }
   if (tab.compacting) { tab.compacting = false; if (tab === activeTab()) _setCompactingUI(false); }
   tab._compactSentAt = 0; // a Compact the user started ends here too (cp-compose.js)
@@ -10347,6 +10406,14 @@ function applyClaudeVisibility(visible) {
 
 export function isClaudePanelOpen() { return _visible; }
 
+/**
+ * Boot the panel without showing it (ui-sidepanel-tray.js, when a tab saved while it worked comes back
+ * after a reload): its tabs reconnect and reattach, so their pills say what the sessions do now.
+ */
+export async function bootClaudePanel() {
+  await _ensureClaudePanelReady();
+}
+
 export function endHostedClaudeSessions() {
   while (_tabs.length) closeTab(_tabs.length - 1);
 }
@@ -10386,8 +10453,11 @@ export async function attachClaudeAutomation(run, { focus = !!run?.focus, isCanc
   }
   if (!tab) return { ok: false, reason: 'tab_limit' };
   const running = run.status === 'starting' || run.status === 'running';
+  // A dispatched worker a server restart cut off: suspended until the next start resumes it as the same run
+  // (lib/assistant-dispatch.js). It still owns this tab; nothing of its cut-off turn runs any more.
+  const suspended = run.status === 'suspended';
   tab.automationRunId = run.runId;
-  tab.automationActive = running;
+  tab.automationActive = running || suspended;
   tab.automationOwnerId = nativeLoopWindowId;
   tab.releasedRunId = null;
   tab.sdkMode = true;
@@ -10396,9 +10466,17 @@ export async function attachClaudeAutomation(run, { focus = !!run?.focus, isCanc
   tab.project = run.cwd || tab.project;
   tab.model = run.model || tab.model;
   tab.effort = run.effort || tab.effort;
+  // A warm worker whose turn ended on a question needs you, like one with a card up (setRunning repaints).
+  tab.automationAwaits = runAwaitsAnswer(run);
   setRunning(tab, running);
   updatePillLabel(tab);
   tab._automationIteration = run.currentIteration;
+  // Resumed after a server restart: what the run did while this window was away (the continuation prompt, its first
+  // steps: events sent before the page reconnected) is in its transcript, not in this tab, which reads it again.
+  // That holds for a run that resumed and ended while this window was away too.
+  const resumes = Number(run.resumes) || 0;
+  const resumedSinceSeen = resumes > (tab._automationResumes || 0);
+  if (tab._automationHydrated && resumedSinceSeen) tab._automationHydrated = false;
   if (!tab._automationHydrated) {
     tab._automationHydrated = true;
     if (tab.messagesEl) tab.messagesEl.innerHTML = '';
@@ -10408,6 +10486,10 @@ export async function attachClaudeAutomation(run, { focus = !!run?.focus, isCanc
       return { ok: false, reason: 'dismissed' };
     }
   }
+  if (running && resumedSinceSeen && tab._automationResumes !== undefined) appendStatus(tab, 'Resumed after the server restart — the run continues here.');
+  tab._automationResumes = Math.max(tab._automationResumes || 0, resumes);
+  if (suspended) _showRunSuspended(tab, run);
+  else tab._automationSuspendedAt = null;
   // (A dispatched worker's failure, with its reason, is on its end card.)
   if (run.status === 'failed' && run.error && !isDispatchedRun(run) && tab._automationLifecycleError !== run.error) {
     tab._automationLifecycleError = run.error;
@@ -10459,6 +10541,64 @@ function hasLiveBackgroundWork(tab) {
   return false;
 }
 
+const LOST_TURN_LINE = 'Connection lost — this turn did not survive the disconnect.';
+// What a tab says when the turn it showed did not survive a lost connection. When its session is a dispatched worker's
+// (a tab opened on that session), the line says what became of the run: resumed after a server restart (in its own
+// tab), or how it ended, with its reason. A tab the user continued by hand after its run ended keeps the generic line:
+// the turn that was cut off was the user's own.
+async function _lostTurnLine(tab) {
+  if (!tab?.sessionId || tab.releasedRunId) return LOST_TURN_LINE;
+  try {
+    const res = await fetch('/api/sidepanel-runs');
+    const runs = res.ok ? ((await res.json())?.runs || []) : [];
+    const run = runs.find((item) => item?.providerSessionId === tab.sessionId && isDispatchedRun(item));
+    if (!run) return LOST_TURN_LINE;
+    if (run.status === 'suspended') return 'SynaBun restarted — this worker run is being resumed in its own tab.';
+    if (run.status === 'starting' || run.status === 'running') {
+      return Number(run.resumes) > 0 ? 'SynaBun restarted — this worker run was resumed and continues in its own tab.' : LOST_TURN_LINE;
+    }
+    let dispatch = null;
+    try {
+      const reply = await fetch(`/api/assistant/runs/${encodeURIComponent(run.runId)}`);
+      if (reply.ok) dispatch = (await reply.json())?.run || null;
+    } catch {}
+    const view = workerEndView(run, dispatch);
+    return view ? `This session's worker run ended: ${view.title}${view.detail ? ` — ${view.detail}` : ''}` : LOST_TURN_LINE;
+  } catch {
+    return LOST_TURN_LINE;
+  }
+}
+
+// A run tab whose run the server suspended as it restarted (status 'suspended'): its turn was cut off, so the tab
+// stops looking busy (spinner, a tool row and its timer, background shells: all went with the CLI) and says the run
+// resumes. Once per suspension.
+function _showRunSuspended(tab, run) {
+  const key = run?.suspendedAt || 'suspended';
+  if (tab._automationSuspendedAt === key) return;
+  tab._automationSuspendedAt = key;
+  finishTab(tab, true);
+  _closeCutOffTools(tab);
+  appendStatus(tab, 'SynaBun restarted — resuming this run…');
+}
+
+// Every tool call of the tab still waiting for its result is closed as cut off, through the path a result takes (the
+// card's state, its timer, an agent card), and the background work the tab showed is over.
+function _closeCutOffTools(tab) {
+  const $msgs = tab?.messagesEl;
+  if (!$msgs) return;
+  for (const card of $msgs.querySelectorAll('.tool-card[data-tool-id]')) {
+    if (card.classList.contains('tool-ok') || card.classList.contains('tool-error') || card.dataset.resolved === '1') continue;
+    if (!card.dataset.toolId) continue;
+    try { updateToolResult(tab, { type: 'tool_result', tool_use_id: card.dataset.toolId, is_error: true, content: 'Cut off by the server restart.' }); } catch {}
+  }
+  let shells = false;
+  for (const task of tab.bgTasks?.values?.() || []) {
+    if (task?.status === 'running') { task.status = 'stopped'; shells = true; }
+  }
+  if (shells) { try { renderBgTray(tab); } catch {} }
+  _setBackgroundWork(tab, []);
+}
+
 // The end of a worker the Assistant dispatched (ui-worker-end.js): one card,
 // the last row of its transcript. Its button closes this tab the way the X
 // does (a warm worker that finished its task is completed, one still at work

package/neural-interface/public/shared/ui-codex-panel.js

@@ -6,6 +6,7 @@
 export {
   toggleCodexPanel,
   isCodexPanelOpen,
+  bootCodexPanel,
   attachCodexAutomation,
   detachCodexAutomation,
   handleCodexAutomationEvent,

package/neural-interface/public/shared/ui-command-runner.js

@@ -2,6 +2,7 @@
 import { emit, on } from './state.js';
 import { KEYS, COLOR_PALETTE } from './constants.js';
 import { storage } from './storage.js';
+import { frameRect, clampBox } from './app-frame.js';
 import { commandLaunchPayload, selectCommandGroups, isCommandLaunchAvailable } from './command-runner-model.js';
 
 const $ = id => document.getElementById(id);
@@ -35,9 +36,11 @@ export function initCommandRunner() { return on('command-runner:open', openPanel
 function clampPanel() {
   if (!_panel) return;
   const width = _panel.offsetWidth, height = _panel.offsetHeight;
-  const top = parseFloat(getComputedStyle(document.documentElement).getPropertyValue('--navbar-height')) || 48;
-  _panel.style.left = Math.max(8, Math.min(parseFloat(_panel.style.left) || 8, window.innerWidth - width - 8)) + 'px';
-  _panel.style.top = Math.max(top + 8, Math.min(parseFloat(_panel.style.top) || top + 8, window.innerHeight - height - 8)) + 'px';
+  // Inside the app frame (8px from the window and the bar, as before, and clear of an open explorer)
+  const f = frameRect();
+  const at = clampBox(parseFloat(_panel.style.left) || f.left, parseFloat(_panel.style.top) || f.top, width, height, f);
+  _panel.style.left = at.x + 'px';
+  _panel.style.top = at.y + 'px';
 }
 function openPanel() {
   if (_panel) { $('cr-search')?.focus(); return; }