synabun 2.0.0-beta → 2.0.5

package/neural-interface/public/shared/tunnel-view.js

@@ -0,0 +1,167 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — the public address: what the cards say
+// ═══════════════════════════════════════════
+//
+// What the two places that start the Cloudflare tunnel show for an answer of
+// GET /api/tunnel/status: the Share menu's Connection block (ui-invite.js) and
+// Settings → Automations → Online access (ui-settings.js). One reading for
+// both, so they never disagree: the state as a word, one sentence about it,
+// the progress of a download, the action that fits, and whether to ask again.
+//
+// No imports and no DOM: `node --test` loads this file as it is
+// (tests/tunnel-view.test.mjs). TUNNEL_COPY is the English of every sentence;
+// `tunnel.*` 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-tunnel.js.
+//
+// A server that was started before SynaBun brought its own tunnel program
+// answers without the `cloudflared` part: the cards then work as they did (a
+// tunnel starts when a cloudflared is installed), and where none is, they say
+// that a restart is what is missing. Nothing here ever tells the user to
+// install anything, except on a system Cloudflare publishes no file for.
+
+export const TUNNEL_COPY = Object.freeze({
+  stateOff: 'Off',
+  stateDownloading: 'Getting the tunnel program',
+  stateStarting: 'Starting',
+  stateRunning: 'On',
+  stateFailed: 'Did not start',
+  stateUnsupported: 'Not available',
+  stateRestart: 'Restart needed',
+  idle: 'A public address through Cloudflare, for invite links and remote MCP.',
+  idleDownload: 'A public address through Cloudflare, for invite links and remote MCP. The first start downloads the tunnel program ({size} MB).',
+  downloading: 'Downloading the tunnel program: {received} of {total} MB',
+  starting: 'Waiting for Cloudflare to give an address…',
+  restart: 'Restart SynaBun to use the public address: the server that is running was started before it could download the tunnel program.',
+  unsupported: 'Cloudflare publishes no tunnel program for this system. If you install cloudflared yourself, SynaBun uses it.',
+  errorOffline: 'The tunnel program could not be downloaded: the download server was not reached. Check the connection and try again.',
+  errorHttp: 'The tunnel program could not be downloaded: the download server answered with an error. Try again in a moment.',
+  errorInterrupted: 'The download stopped before it was complete. Nothing was kept. Try again.',
+  errorTimeout: 'The download stalled. Nothing was kept. Try again.',
+  errorChecksum: 'The download was not the file SynaBun expects, so it was removed and never run. Try again; if it happens again, something on the network is changing the file.',
+  errorUnpack: 'The downloaded file could not be unpacked, so it was removed. Try again.',
+  errorDisk: 'The tunnel program could not be saved in SynaBun\'s data folder. Check free space and permissions, then try again.',
+  errorLaunch: 'The tunnel program could not be started on this computer. Try again.',
+  errorExited: 'Cloudflare gave no address. The tunnel program said: {reason}',
+  errorExitedNoReason: 'The tunnel program stopped before Cloudflare gave an address. Try again.',
+  errorNoAddress: 'Cloudflare gave no address in time. Try again.',
+  errorEnded: 'The tunnel stopped. Start it again for a new address.',
+  errorRefused: 'SynaBun refused this request. Start the tunnel from SynaBun on this computer.',
+  errorUnknown: 'The tunnel did not start: {reason}',
+  errorUnknownNoReason: 'The tunnel did not start. Try again.',
+  start: 'Start tunnel',
+  stop: 'Stop',
+  cancel: 'Cancel',
+  retry: 'Try again',
+  copyBundled: 'cloudflared {version}, included with SynaBun',
+  copyDownloaded: 'cloudflared {version}, downloaded by SynaBun',
+  copySystem: 'cloudflared {version}, installed on this computer',
+  copySystemWhy: 'SynaBun could not download its own copy, so the one installed on this computer is used.',
+  mcpKeyNeeded: 'Remote MCP needs an access key. Create one below; the address to connect is then this one followed by /mcp/ and the key.',
+});
+
+const ERROR_COPY = Object.freeze({
+  offline: 'errorOffline', http: 'errorHttp', interrupted: 'errorInterrupted', timeout: 'errorTimeout', checksum: 'errorChecksum',
+  unpack: 'errorUnpack', disk: 'errorDisk', launch: 'errorLaunch', no_address: 'errorNoAddress', ended: 'errorEnded',
+  unsupported: 'unsupported', refused: 'errorRefused',
+});
+
+/** A TUNNEL_COPY sentence with its `{params}` filled in: the translator when the page gives none. */
+export function fillTunnelCopy(key, params = {}) {
+  return String(TUNNEL_COPY[key] ?? key).replace(/\{(\w+)\}/g, (whole, name) => (params[name] != null ? params[name] : whole));
+}
+
+const megabytes = (bytes) => Math.max(0, Number(bytes) || 0) / (1024 * 1024);
+
+/**
+ * What a card shows for a status.
+ *
+ * @param {object | null} status the answer of GET /api/tunnel/status (or of the start / stop that came last)
+ * @param {object} [o]
+ * @param {(key: string, params?: object) => string} [o.t] a key of TUNNEL_COPY → the sentence in the page's language
+ * @param {(value: number, digits: number) => string} [o.number] a number as the page's language writes it
+ * @returns {{
+ *   kind: 'restart' | 'unsupported' | 'idle' | 'downloading' | 'starting' | 'running' | 'failed',
+ *   tone: 'off' | 'busy' | 'ok' | 'warn' | 'err',
+ *   on: boolean,
+ *   label: string, detail: string,
+ *   progress: { percent: number, text: string } | null,
+ *   url: string | null,
+ *   action: 'start' | 'stop' | 'cancel' | 'retry' | null, actionLabel: string,
+ *   copy: string, copyNote: string,
+ *   poll: boolean,
+ * }}
+ *   `on`: the switch stands on (something runs or is on its way). `action`: what a press does ("cancel" and
+ *   "stop" are both POST /api/tunnel/stop; "start" and "retry" both POST /api/tunnel/start). `copy`: which
+ *   cloudflared runs, when one does. `poll`: the state will change by itself, ask again.
+ */
+export function tunnelView(status, { t = fillTunnelCopy, number = (value, digits) => value.toFixed(digits) } = {}) {
+  const s = status && typeof status === 'object' ? status : {};
+  const tool = s.cloudflared && typeof s.cloudflared === 'object' ? s.cloudflared : null;
+  const view = {
+    kind: 'idle', tone: 'off', on: false, label: t('stateOff'), detail: t('idle'), progress: null,
+    url: typeof s.url === 'string' && s.url ? s.url : null,
+    action: 'start', actionLabel: t('start'), copy: '', copyNote: '', poll: false,
+  };
+  const as = (kind, tone, labelKey, detail, action) => Object.assign(view, {
+    kind, tone, label: t(labelKey), detail, action, actionLabel: action ? t(action) : '',
+    on: kind === 'downloading' || kind === 'starting' || kind === 'running', poll: kind === 'downloading' || kind === 'starting',
+  });
+  const running = () => {
+    as('running', 'ok', 'stateRunning', view.url, 'stop');
+    const source = { bundled: 'copyBundled', downloaded: 'copyDownloaded', system: 'copySystem' }[tool?.source];
+    if (source && tool.version) {
+      view.copy = t(source, { version: tool.version });
+      if (tool.source === 'system' && tool.fallback && tool.fallback.code !== 'unsupported') view.copyNote = t('copySystemWhy');
+    }
+    return view;
+  };
+
+  // Nothing is known yet (the answer has not arrived): the card as it stands before a first start.
+  if (!status || typeof status !== 'object') return view;
+
+  // A server from before the tunnel program came with SynaBun: no `cloudflared` part in its answer.
+  if (!tool) {
+    if (view.url) return running();
+    if (s.starting || s.running) return as('starting', 'busy', 'stateStarting', t('starting'), 'cancel');
+    if (s.available) return as('idle', 'off', 'stateOff', t('idle'), 'start');
+    return as('restart', 'warn', 'stateRestart', t('restart'), null);
+  }
+
+  const state = typeof s.state === 'string' ? s.state : 'idle';
+  if (state === 'running' && view.url) return running();
+  if (state === 'downloading') {
+    const total = Number(tool.progress?.total) || Number(tool.download?.size) || 0;
+    const received = Math.min(Number(tool.progress?.received) || 0, total || Infinity);
+    const percent = total ? Math.max(0, Math.min(100, Math.floor((received / total) * 100))) : 0;
+    as('downloading', 'busy', 'stateDownloading', t('downloading', { received: number(megabytes(received), 1), total: number(megabytes(total), 1) }), 'cancel');
+    view.progress = { percent, text: `${percent}%` };
+    return view;
+  }
+  if (state === 'starting' || state === 'running') return as('starting', 'busy', 'stateStarting', t('starting'), 'cancel');
+  if (state === 'failed') {
+    const error = s.error && typeof s.error === 'object' ? s.error : {};
+    if (error.code === 'unsupported') return as('unsupported', 'off', 'stateUnsupported', t('unsupported'), null);
+    const reason = typeof error.reason === 'string' && error.reason.trim() ? error.reason.trim() : '';
+    let detail;
+    if (error.code === 'exited') detail = reason ? t('errorExited', { reason }) : t('errorExitedNoReason');
+    else if (ERROR_COPY[error.code]) detail = t(ERROR_COPY[error.code]);
+    else detail = typeof error.message === 'string' && error.message.trim() ? t('errorUnknown', { reason: error.message.trim() }) : t('errorUnknownNoReason');
+    return as('failed', 'err', 'stateFailed', detail, 'retry');
+  }
+  // idle
+  if (tool.state === 'unsupported') return as('unsupported', 'off', 'stateUnsupported', t('unsupported'), null);
+  if (tool.state === 'ready') return as('idle', 'off', 'stateOff', t('idle'), 'start');
+  const size = Number(tool.download?.size) || 0;
+  return as('idle', 'off', 'stateOff', size ? t('idleDownload', { size: number(megabytes(size), 0) }) : t('idle'), 'start');
+}
+
+/**
+ * The address an assistant outside connects to, or null while there is none to give: the public address
+ * followed by /mcp/ and the access key. Without a key there is no such address: the server refuses /mcp from
+ * outside (lib/request-gate.js mcpWithoutKey), so the cards offer nothing to copy and say what is missing.
+ */
+export function remoteMcpAddress(url, key) {
+  const base = typeof url === 'string' ? url.trim().replace(/\/+$/, '') : '';
+  const secret = typeof key === 'string' ? key.trim() : '';
+  return base && secret ? `${base}/mcp/${secret}` : null;
+}

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

@@ -7,6 +7,7 @@ import { hostedSidepanelId, sidepanelHost } from './ui-sidepanel-runtime.js';
 import { storage } from './storage.js';
 import { fetchBlobNamespace, putBlob, deleteBlob, flushBlobs } from './blob-store.js';
 import { state, emit, on } from './state.js';
+import { forgetGreeting, mountGreeting } from './greeting/greeting-card.js';
 import { fetchClaudeSessions, fetchBrowserSessions, searchSessions } from './api.js';
 import { createFrameRenderer } from './utils.js';
 import { notify, NOTIF_TYPE } from './ui-notifications.js';
@@ -15,6 +16,9 @@ import { subscribeCliStatus, recheckCliStatus, getCliDocUrl, getCliInstallComman
 import { nativeLoopWindowId } from './ui-native-window-id.js';
 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';
 // ── 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';
@@ -24,7 +28,7 @@ import { buildAgentCard, ensureAgentScope, noteAgentActivity, updateAgentTodoBad
 import { renderPermissionCard, renderPlanApprovalCard, renderElicitationCard, decorateAskCard, askAnnotations, markAskAnswered, PERMISSION_MODES, MODE_LABELS } from './cp/cp-permissions.js';
 import { normalizeSession, changedStartSettings, sessionFlags, sessionRows, fastModeSupported, fastModeReason, mergeSessionModels, parseMcpServerLines, formatMcpServerLines } from './cp/cp-session-model.js';
 import { renderSessionSettingsCard } from './cp/cp-session-settings.js';
-import { describeOrigin, reconcileTasks, adoptLiveTasks, describeHistorySystemRow, workEndedByRestart } from './cp/cp-tasks-model.js';
+import { describeOrigin, reconcileTasks, adoptLiveTasks, describeHistorySystemRow, workEndedByRestart, isTaskRunning } from './cp/cp-tasks-model.js';
 import { renderTasksCard } from './cp/cp-tasks.js';
 import { sessionListLabel, collectTags, tagSession as tagClaudeSession, sessionActionsAvailable, sessionOpsSupported, labelledSessionIds, mergeSessionSearch, writeSessionTitle, forkSession as forkClaudeSession, deleteSession as deleteClaudeSession, fetchSubagentMessages, forkTitle, entryBefore, promptText, removeFrom, sessionRowParts, fillSelectOptions } from './cp/cp-sessions.js';
 import { contextCard, usageCard, mcpRows, rewindPreviewText, rewindResultText } from './cp/cp-usage-model.js';
@@ -2928,6 +2932,7 @@ function newTabState(sessionId = null, label = 'New chat', id = null) {
     automationRunId: null,
     automationActive: false,
     automationOwnerId: null,
+    releasedRunId: null,      // the ended run this tab showed before the user continued it by hand
   };
 }
 
@@ -3130,15 +3135,18 @@ function closeTab(idx, { detachAutomation = false } = {}) {
   if (idx < 0 || idx >= _tabs.length) return;
   const tab = _tabs[idx];
   if (tab.automationRunId && !detachAutomation) {
+    const runId = tab.automationRunId;
     window.dispatchEvent(new CustomEvent('native-loop:dismissed', {
-      detail: { runId: tab.automationRunId },
+      detail: { runId },
     }));
-    fetch('/api/loop/stop', {
+    // A worker that finished its task is completed; any other run is stopped.
+    endWorkerRunOnClose(runId, () => fetch('/api/loop/stop', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ runId: tab.automationRunId }),
-    }).catch(() => {});
+      body: JSON.stringify({ runId }),
+    }).catch(() => {}), { busy: hasLiveBackgroundWork(tab) });
   }
+  if (tab.automationRunId) forgetWorkerEnd(tab.automationRunId);
   flushSessionSnapshotSave(tab);
   recordHookEvent(tab, 'SessionEnd', tab.sessionId || '(new)');
   tab.closed = true;
@@ -3264,7 +3272,7 @@ function saveTabs() {
   try {
     // A temporary tab is never written: not the tab, its label, its queue or its session id.
     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 }));
+    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 localRunIds = new Set(localTabs.map((tab) => tab.automationRunId).filter(Boolean));
     let foreignAutomationTabs = [];
     try {
@@ -3406,6 +3414,7 @@ function restoreTabs() {
           if (t && saved.automationRunId) t.automationRunId = saved.automationRunId;
           if (t && saved.automationRunId) t.automationActive = !!saved.automationActive;
           if (t && saved.automationRunId) t.automationOwnerId = saved.automationOwnerId || null;
+          if (t && saved.releasedRunId && !saved.automationRunId) t.releasedRunId = saved.releasedRunId;
         }
         if (_tabs.length) {
           switchTab(Math.min(data.activeIdx || 0, _tabs.length - 1));
@@ -5653,9 +5662,9 @@ function handleTabEvent(tab, ev) {
     appendStatus(tab, ev.message || 'Retrying…');
     return;
   }
-  // Non-fatal runtime problems (e.g. the bundled Claude binary lost its execute
-  // bit and was repaired, or we fell back to the globally installed CLI). The
-  // session continues — this must not render as a fatal error.
+  // Non-fatal runtime notices (e.g. a session setting that could not be
+  // applied, or where this session's debug log is written). The session
+  // continues — this must not render as a fatal error.
   if (ev.type === 'system' && ev.subtype === 'runtime_notice') {
     if (ev.level === 'error') appendError(tab, ev.message || 'Runtime error');
     else if (ev.level === 'info') appendStatus(tab, ev.message || 'Runtime notice');
@@ -7445,7 +7454,57 @@ function handleControlRequest(tab, msg) {
 // What a query tells the bridge about this tab's session: the permission mode
 // (or that the user's own settings should pick it), the tool policy, and what
 // this panel can render. Keys a server that predates them ignores.
+// ── Greeting (shared/greeting/, lib/greeting/) ──
+// What SynaBun says when a person comes back and opens a new chat: one or two sentences in the
+// empty state, written by SynaBun ahead of time (this session's model never greets). Only for a
+// tab that holds no conversation yet: never a resumed session, a temporary chat or a tab showing
+// an automation run (hence the short wait: those are marked right after the tab is made). The
+// server decides whether this opening is a return worth greeting; an older server answers nothing.
+// Asked from _paintTemporary(), which runs wherever the conversation area is rebuilt. Nothing of it
+// is kept on the tab object (what a tab carries over, and what is saved of it, is listed elsewhere).
+const _greetingOf = new WeakMap(); // tab → { seq, host, greeting: { id, session } | null }
+function _greetingState(tab) {
+  let held = _greetingOf.get(tab);
+  if (!held) { held = { seq: 0, host: null, greeting: null }; _greetingOf.set(tab, held); }
+  return held;
+}
+function _offerGreetingSoon(tab) {
+  if (!tab) return;
+  setTimeout(() => { try { _offerGreeting(tab); } catch { /* a tab always opens */ } }, 300);
+}
+function _offerGreeting(tab) {
+  if (!_tabs.includes(tab) || tab.sessionId || tab.temporary || tab.automationRunId || tab.automationActive || tab.running) return;
+  const host = tab.messagesEl?.querySelector(':scope > .cp-empty');
+  if (!host || host.dataset.greetingAsked === '1') return;
+  host.dataset.greetingAsked = '1';
+  const held = _greetingState(tab);
+  // The conversation area was rebuilt: a new conversation in the same tab is a new opening.
+  if (held.host && held.host !== host) { held.seq += 1; held.greeting = null; }
+  held.host = host;
+  const session = `${tab.id}.${held.seq}`;
+  const cwd = tab.project || ddGetValue(_panel?.querySelector('#cp-project')) || '';
+  mountGreeting(host, {
+    surface: 'claude-panel', session, cwd,
+    onOpenMemory: (id) => { if (id) emit('memory:open', { id }); },
+    isCurrent: () => !tab.sessionId && !tab.temporary && !tab.automationRunId && held.host === host && tab.messagesEl?.contains(host),
+  }).then((greeting) => {
+    if (held.host === host) held.greeting = greeting ? { id: greeting.id, session } : null;
+  }).catch(() => {});
+}
+
+// The greeting a chat opened with goes back once, with its first prompt: the bridge tells the model
+// what was said (capability 'greeting'). A temporary chat names nothing, so it takes none.
+function _echoGreeting(tab, msg) {
+  const held = msg.type === 'query' ? _greetingOf.get(tab) : null;
+  if (!held?.greeting?.id) return;
+  if (hasCapability(tab, 'greeting') && !tab.temporary) msg.greetingId = held.greeting.id;
+  forgetGreeting('claude-panel', held.greeting.session);
+  held.greeting = null;
+}
+
 function _applySessionOptions(tab, msg) {
+  // The greeting this chat opened with goes back once, with its first prompt.
+  _echoGreeting(tab, msg);
   // The tab's own mode (statedMode() in cp/cp-permission-model.js: Bypass only
   // as the user's recorded pick). A tab that never picked one leaves it to the
   // user's Claude Code settings (permissions.defaultMode).
@@ -7471,6 +7530,8 @@ function _applySessionOptions(tab, msg) {
 function _paintTemporary(tab) {
   if (!tab) return;
   paintTemporary(tab, { capable: hasCapability(tab, TEMPORARY_CAPABILITY), onToggle: (on) => _chooseTemporary(tab, on) });
+  // The conversation area was (re)built: a new chat may open with SynaBun's greeting.
+  _offerGreetingSoon(tab);
 }
 
 // The user's choice on a new tab. A process kept ready for the other kind of
@@ -9228,6 +9289,9 @@ function send({ shift = false } = {}) {
   // A temporary chat that is over, or one the running server would save: nothing is sent.
   { const refusal = temporaryRefusal(tab, { capable: hasCapability(tab, TEMPORARY_CAPABILITY) }); if (refusal) { appendStatus(tab, refusal); return; } }
 
+  // A message of the user's own in the tab of a run that ended: the tab is theirs from here on.
+  releaseAutomationForManualUse(tab);
+
   // ── !bash shortcut — prefix a Bash-tool hint so Claude executes the command ──
   if (text.startsWith('!') && text.length > 1) {
     const cmd = text.slice(1).trim();
@@ -10162,15 +10226,7 @@ function _onMessagesClick(e) {
     });
     return;
   }
-  const link = e.target.closest('a.file-link');
-  if (link) {
-    e.preventDefault();
-    const path = (link.textContent || '').replace(/:\d+$/, '');
-    navigator.clipboard.writeText(path);
-    link.style.opacity = '0.5';
-    setTimeout(() => { link.style.opacity = ''; }, 300);
-    return;
-  }
+  // File links (a.file-link, and the links of a message's Markdown) are taken by _fileLinkOptions below.
   const hdr = e.target.closest('.tool-hdr');
   if (hdr && !e.target.closest('button, a, input, select, textarea')) {
     const card = hdr.closest('.tool-card');
@@ -10183,6 +10239,25 @@ function _onMessagesClick(e) {
   }
 }
 
+// ── File links ──
+// A link to a file the code editor can open opens it there (ui-file-links.js, shared with the other panels).
+// The same delegation as above: it covers streaming, finished and snapshot-restored messages of every tab.
+const _fileLinkOptions = {
+  // A relative path is a path in the folder of the tab the message belongs to.
+  cwd: (link) => {
+    const tab = _tabs.find((t) => t.messagesEl?.contains(link)) || activeTab();
+    return tab?.init?.cwd || tab?.project || '';
+  },
+  textLinks: 'a.file-link',
+  // A path the editor does not open keeps what a click on it did: it is copied.
+  copyPath: (link) => {
+    const path = (link.textContent || '').replace(/:\d+$/, '');
+    link.style.opacity = '0.5';
+    setTimeout(() => { link.style.opacity = ''; }, 300);
+    return navigator.clipboard.writeText(path);
+  },
+};
+
 // ── Public API ──
 async function _ensureClaudePanelReady() {
   if (!_panel) {
@@ -10197,6 +10272,7 @@ async function _ensureClaudePanelReady() {
     });
     wireEvents();
     _panel.querySelector('#cp-messages-container')?.addEventListener('click', _onMessagesClick);
+    wireFileLinks(_panel.querySelector('#cp-messages-container'), _fileLinkOptions);
     await loadConfig();   // must complete before restoreTabs — checks server boot ID
     loadSkills();
     restoreTabs();
@@ -10248,6 +10324,18 @@ export async function attachClaudeAutomation(run, { focus = !!run?.focus, isCanc
   if (!run?.runId || !run?.providerSessionId) return { ok: false, reason: 'identity_pending' };
   await _ensureClaudePanelReady();
   if (isCancelled()) return { ok: false, reason: 'dismissed' };
+  // The user continued this run's tab by hand after the run ended: it stays theirs. The dock's
+  // Focus raises it; the run is let go again, and nothing in the tab changes.
+  const own = _tabs.find((entry) => !entry.automationRunId && entry.releasedRunId === run.runId && entry.sessionId === run.providerSessionId);
+  if (own && !(run.status === 'starting' || run.status === 'running')) {
+    window.dispatchEvent(new CustomEvent('native-loop:dismissed', { detail: { runId: run.runId } }));
+    if (focus) {
+      if (!_visible) await toggleClaudePanel();
+      const ownIdx = _tabs.indexOf(own);
+      if (ownIdx >= 0) switchTab(ownIdx);
+    }
+    return { ok: true, tabId: own.id, released: true };
+  }
   let tab = _tabs.find((entry) => entry.automationRunId === run.runId)
     || _tabs.find((entry) => entry.sessionId === run.providerSessionId);
   if (!tab) {
@@ -10270,6 +10358,7 @@ export async function attachClaudeAutomation(run, { focus = !!run?.focus, isCanc
   tab.automationRunId = run.runId;
   tab.automationActive = running;
   tab.automationOwnerId = nativeLoopWindowId;
+  tab.releasedRunId = null;
   tab.sdkMode = true;
   tab.sessionId = run.providerSessionId;
   tab.label = run.title || tab.label || 'Automation';
@@ -10288,10 +10377,12 @@ export async function attachClaudeAutomation(run, { focus = !!run?.focus, isCanc
       return { ok: false, reason: 'dismissed' };
     }
   }
-  if (run.status === 'failed' && run.error && tab._automationLifecycleError !== run.error) {
+  // (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;
     appendError(tab, run.error);
   }
+  trackWorkerEnd(run, { apply: (view) => showWorkerEnd(tab, view), busy: hasLiveBackgroundWork(tab) });
   // The mode control is hidden while the run is active and back when it ended.
   if (tab === activeTab()) populateModeDropdown(_panel?.querySelector('#cp-mode'), tab);
   const idx = _tabs.indexOf(tab);
@@ -10319,10 +10410,60 @@ export function handleClaudeAutomationEvent(runId, payload) {
     return true;
   }
   if (event.type === 'synabun.error') {
+    // Every run's end disposes its SDK query, and the SDK says so in these words: not a failure.
+    if (isEndOfRunAbort(event.message)) return true;
     appendError(tab, event.message || 'Claude Code automation failed');
     return true;
   }
   handleTabMsg(tab, { type: 'event', event, fromRun: true });
+  // Background agents still running keep a warm worker's "Task complete" away.
+  if (event.type === 'system' || event.type === 'result') updateWorkerEndBusy(runId, hasLiveBackgroundWork(tab));
+  return true;
+}
+
+function hasLiveBackgroundWork(tab) {
+  for (const task of tab?.tasks?.values?.() || []) {
+    if (task && !task.ambient && isTaskRunning(task)) return true;
+  }
+  return false;
+}
+
+// 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
+// is stopped; its record stays for the Assistant) and shows the Assistant
+// session that dispatched it.
+function showWorkerEnd(tab, view) {
+  tab._workerEnd = view || null;
+  const $msgs = tab.messagesEl;
+  if (!$msgs || tab.closed) return;
+  $msgs.querySelectorAll(`.${WORKER_END_CLASS}`).forEach((el) => el.remove());
+  if (!view) return;
+  $msgs.appendChild(buildWorkerEndCard(view, {
+    classes: { card: 'cp-worker-end', title: 'post-plan-header', actions: 'post-plan-actions', button: 'post-plan-action pp-primary' },
+    onBack: () => {
+      const idx = _tabs.indexOf(tab);
+      if (idx >= 0) closeTab(idx);
+      backToAssistant(view.assistantSessionId);
+    },
+  }));
+  if (tab === activeTab()) scrollEnd(true);
+}
+
+// The user sends a message of their own in the tab of a run that ended (Codex's
+// releaseAutomationForManualUse): the run's end card goes, the tab stops following
+// the run, and the router leaves the run alone, so nothing of it comes back here.
+// A run that is still going keeps its tab (the composer refuses a manual turn then).
+function releaseAutomationForManualUse(tab) {
+  if (!tab?.automationRunId || tab.automationActive) return false;
+  const runId = tab.automationRunId;
+  forgetWorkerEnd(runId);
+  showWorkerEnd(tab, null);
+  tab.automationRunId = null;
+  tab.automationOwnerId = null;
+  tab.releasedRunId = runId;
+  window.dispatchEvent(new CustomEvent('native-loop:dismissed', { detail: { runId } }));
+  saveTabs();
   return true;
 }