synabun 2.0.9 → 2.1.0

package/neural-interface/public/shared/ocp-v2/ocp-v2-panel.js

@@ -1,3 +1,5 @@
+import { workerRestart } from '../worker-restart.js';
+import { t } from '../i18n.js';
 import { hostedSidepanelId, sidepanelHost } from '../ui-sidepanel-runtime.js';
 // ─────────────────────────────────────────────────────────────────────────────
 // OpenCode V2 — Panel container
@@ -10,19 +12,21 @@ import { hostedSidepanelId, sidepanelHost } from '../ui-sidepanel-runtime.js';
 
 import { state, emit, on } from '../state.js';
 import { storage } from '../storage.js';
+import { frameRect } from '../app-frame.js';
 import { fetchProjects } from '../api.js';
 import { injectStyles } from './ocp-v2-styles.js';
-import { connect, api, hasSessionStore, onSessionCompacted, onEvent, supports, isDescendantSession } from './ocp-v2-ws.js';
+import { connect, api, hasSessionStore, onSessionCompacted, onEvent, onReconnect, supports, isDescendantSession } from './ocp-v2-ws.js';
 import {
-  menuSessions, pickReusableEmptySession, shareView, SHARE_CONFIRM_TEXT, createPendingRenames, createStoppedShares,
+  menuSessions, pickReusableEmptySession, createPendingRenames,
+  sessionBusyFromEvent, sessionBusyFromStatus, tabPillState, automationTurnPhase,
 } from './ocp-v2-sessions-logic.js';
 import {
-  forkSession, shareSession, unshareSession, undoLastTurn, restoreReverted,
+  forkSession, undoLastTurn, restoreReverted,
   loadSelectedSession, applySessionSelections, restoreDraftAttachments,
   readTranscriptExport, stopForNavigation, createSessionForNavigation, renameSession,
   navigateAfter, adoptReusableSession, landWithoutTabs, shouldNameCreatedSession, renameBox,
 } from './ocp-v2-session-actions.js';
-import { captureBinding, latestOnly, latestFor, createNavigation } from './ocp-v2-binding.js';
+import { captureBinding, latestFor, createNavigation } from './ocp-v2-binding.js';
 import { createConfirmations } from './ocp-v2-confirm-logic.js';
 import { syncConfirmRow } from './ocp-v2-confirm.js';
 import { closeWithPromptsConfirm, prefilledDraft, samePrompts } from './ocp-v2-composer-logic.js';
@@ -41,7 +45,7 @@ import { createAutoAcceptControl } from './ocp-v2-autoaccept-button.js';
 import { mountTodoWidget } from './ocp-v2-session-widgets.js';
 import { mountChangesBar } from './ocp-v2-changes.js';
 import { mountEnvironmentPopover } from './ocp-v2-status.js';
-import { watchWorktree, newSessionPlan, checkoutOutcome } from './ocp-v2-changes-logic.js';
+import { newSessionPlan, checkoutOutcome } from './ocp-v2-changes-logic.js';
 import { mountRenderer } from './ocp-v2-render.js';
 import { offerGreeting } from './ocp-v2-greeting.js';
 import { mountCompose, focusCompose, appendPathToCompose } from './ocp-v2-send.js';
@@ -82,6 +86,9 @@ let OCP_WINDOW_ID = (() => {
 let STOR_TABS = `opencode-v2-tabs-${OCP_WINDOW_ID}`;
 let STOR_AUTOMATIONS = `opencode-v2-automations-${OCP_WINDOW_ID}`;
 let STOR_TITLE_STATES = `opencode-v2-title-states-${OCP_WINDOW_ID}`;
+// The tabs whose session was working when last seen: after a reload their placeholder pills say so and
+// the panel boots to ask OpenCode (ui-sidepanel-tray.js). Never read as the truth: OpenCode's answer is.
+let STOR_BUSY = `opencode-v2-busy-${OCP_WINDOW_ID}`;
 const STOR_WINDOW_REGISTRY = 'opencode-v2-windows';
 const HEAL_DEBOUNCE_MS = 800;
 const HEAL_RETRY_MAX_MS = 30000;
@@ -94,9 +101,17 @@ let _tabPills = new Map();      // sessionId -> pill element
 let _tabInfoCache = new Map();  // sessionId -> last-known session info (title, etc.)
 const _automationRunIds = new Map(); // sessionId -> native loop runId
 const _automationRunning = new Set();
+// sessionId → what a live automation run's turn does ('working', 'waiting' on the user, 'idle' between turns:
+// automationTurnPhase of the run's descriptor): its pill follows the turn, not the run.
+const _automationTurn = new Map();
+// sessionId → working (true) or idle (false), for the tabs that are not on screen: OpenCode's run events
+// and session:status answers say it (noteSessionBusy); the session on screen leaves its own run state
+// here when the user moves on (renderPill), so its pill keeps moving while its turn goes on.
+const _sessionBusy = new Map();
 const _automationContinuedManually = new Set();
 const _automationManualSendInFlight = new Set();
 const _foreignActiveAutomationSessions = new Set();
+const _workerRestarts = new Map();
 const _workerEnds = new Map(); // sessionId -> end card of the dispatched worker it belongs to (ui-worker-end.js)
 let _renderer = null;
 let _visible = false;
@@ -125,30 +140,20 @@ let _composer = null;           // the primary panel's composer (mountCompose)
 let _cliBanner = null;          // the CLI banner and send-block (ui-cli-banner.js)
 let _cliWasBlocked = false;    // the banner held sends back last time it said (a change to usable heals the serve)
 // Where the panel goes. Every choice of the user (a tab, a session in the
-// menu, New session, a project, a worktree) begins an intent, and a navigation
+// menu, New session, a project) begins an intent, and a navigation
 // binds the panel only while its intent is the latest one: a later choice wins
 // over an older one that is still in flight (ocp-v2-binding.js). What the
 // panel starts by itself (boot, the recovery, an automation asking for focus)
 // only observes: it never overtakes a choice of the user.
 const _nav = createNavigation(getDefaultStore());
-// What publishes or destroys is asked in the panel, in two steps, never with a
-// native dialog (ocp-v2-confirm-logic.js). `surface` says where the question
-// is drawn: 'menu' under its row of the session menu, 'panel' above the
-// compose box, 'dialog' in the naming dialog.
+// What destroys is asked in the panel, in two steps, never with a native
+// dialog (ocp-v2-confirm-logic.js). `surface` says where the question is
+// drawn: 'menu' under its row of the session menu, 'panel' above the compose
+// box.
 const _confirms = createConfirmations({ store: getDefaultStore() });
 let _confirmSlotEl = null;
 const _menuConfirmAnchors = new Map();   // question key -> the menu row it is asked under
 _confirms.onChange(() => { syncSessionMenuConfirm(); syncPanelConfirm(); });
-// Share links whose sharing this panel stopped. OpenCode goes on reporting
-// them (createStoppedShares in ocp-v2-sessions-logic.js), so the store takes
-// such a link out of any session info it is handed, and so do the session
-// menu and the tab cache. One list for every window, kept across reloads.
-const STOR_STOPPED_SHARES = 'opencode-v2-stopped-shares';
-const _stoppedShares = createStoppedShares({
-  load: () => JSON.parse(storage.getItem(STOR_STOPPED_SHARES) || '{}'),
-  save: (entries) => storage.setItem(STOR_STOPPED_SHARES, JSON.stringify(entries)),
-});
-getDefaultStore().setSessionInfoFilter?.((info) => _stoppedShares.clean(info));
 
 function forkClonedOpenCodePersistence() {
   try {
@@ -173,6 +178,7 @@ function forkClonedOpenCodePersistence() {
     STOR_TABS = `opencode-v2-tabs-${OCP_WINDOW_ID}`;
     STOR_AUTOMATIONS = `opencode-v2-automations-${OCP_WINDOW_ID}`;
     STOR_TITLE_STATES = `opencode-v2-title-states-${OCP_WINDOW_ID}`;
+    STOR_BUSY = `opencode-v2-busy-${OCP_WINDOW_ID}`;
     if (transferableTabs.length) storage.setItem(STOR_TABS, JSON.stringify(transferableTabs));
     if (transferableRows.length) storage.setItem(STOR_AUTOMATIONS, JSON.stringify(transferableRows));
     if (Object.keys(transferableTitleStates).length) storage.setItem(STOR_TITLE_STATES, JSON.stringify(transferableTitleStates));
@@ -188,6 +194,7 @@ function cleanStaleOpenCodeWindows() {
       storage.removeItem(`opencode-v2-tabs-${windowId}`);
       storage.removeItem(`opencode-v2-automations-${windowId}`);
       storage.removeItem(`opencode-v2-title-states-${windowId}`);
+      storage.removeItem(`opencode-v2-busy-${windowId}`);
       delete registry[windowId];
     }
     registry[OCP_WINDOW_ID] = now;
@@ -243,6 +250,8 @@ function saveAutomationTabs() {
       sessionId,
       runId,
       running: _automationRunning.has(sessionId),
+      // What its turn did when this was written (automationTurnPhase): a reload's placeholder pill follows it.
+      turn: _automationTurn.get(sessionId) || null,
       ownerId: nativeLoopWindowId,
       continuedManually: _automationContinuedManually.has(sessionId),
     }));
@@ -264,6 +273,44 @@ function saveAutomationTabs() {
   } catch {}
 }
 
+// ── What the tabs that are not on screen are doing (_sessionBusy) ──
+
+function saveBusySessions() {
+  try {
+    const busy = _tabSessionIds.filter((sid) => _sessionBusy.get(sid) === true);
+    if (busy.length) storage.setItem(STOR_BUSY, JSON.stringify(busy));
+    else storage.removeItem(STOR_BUSY);
+  } catch {}
+}
+
+/** Record what a session is doing; true when that changed. */
+function rememberBusy(sessionId, busy) {
+  if (!sessionId || _sessionBusy.get(sessionId) === !!busy) return false;
+  _sessionBusy.set(sessionId, !!busy);
+  saveBusySessions();
+  return true;
+}
+
+/** A tab's session started or ended a turn while another one is on screen: its pill follows. */
+function noteSessionBusy(sessionId, busy) {
+  if (rememberBusy(sessionId, busy) && _tabSessionIds.includes(sessionId)) renderPill();
+}
+
+/**
+ * Ask OpenCode what every tab that is not on screen is doing: after a boot (only the session on screen
+ * is read back by its rehydrate) and after the socket came back (their events of the outage reached no
+ * one). A server that does not answer session:status leaves what is known.
+ */
+async function probeTabStatuses() {
+  const activeSid = getState().sessionId;
+  await Promise.all(_tabSessionIds.filter((sid) => sid && sid !== activeSid).map(async (sid) => {
+    let res = null;
+    try { res = await api.sessionStatus({ sessionId: sid, cwd: _tabInfoCache.get(sid)?.directory || undefined }); } catch { res = null; }
+    const busy = sessionBusyFromStatus(res);
+    if (busy !== null && sid !== getState().sessionId && _tabSessionIds.includes(sid)) noteSessionBusy(sid, busy);
+  }));
+}
+
 try {
   const rows = JSON.parse(storage.getItem(STOR_AUTOMATIONS) || '[]');
   for (const row of Array.isArray(rows) ? rows : []) {
@@ -416,6 +463,7 @@ function buildPanel() {
     onAttachPath: (path) => appendPathToCompose(path),
   });
   _contextMenu = mountContextMenu(actions, panel, getDefaultStore(), {
+    bounds: frameRect,   // the popover stays in the app frame
     compact: createCompactControl(getDefaultStore()),
     autoAccept: createAutoAcceptControl(getDefaultStore()),
     onManage: () => environment.open(),
@@ -532,10 +580,6 @@ function buildPanel() {
       const result = failIfRefused(await forkSession(getDefaultStore(), api), 'Fork failed');
       if (result?.ok) await openCreatedSession(result.session, { activate: !result.moved, nav });
     },
-    // Asked every time, in the session menu: /share only opens the question
-    // there, and its button publishes the transcript at a public URL.
-    share: () => shareActiveSession(),
-    unshare: () => stopSharingActiveSession(),
   };
   composer = _composer = mountCompose(compose, getDefaultStore(), {
     slashActions,
@@ -608,10 +652,12 @@ function buildPanel() {
   // Sessions change outside this panel too (another window, the CLI, a title
   // OpenCode generated): keep the open menu and the tab list in step.
   onEvent((eventType, ev) => {
+    // A tab that is not on screen goes on running its turn: its pill says what OpenCode says it does.
+    const run = sessionBusyFromEvent(eventType, ev);
+    if (run && run.sessionId !== getState().sessionId && _tabSessionIds.includes(run.sessionId)) noteSessionBusy(run.sessionId, run.busy);
     if (eventType !== 'session.updated' && eventType !== 'session.deleted' && eventType !== 'session.created') return;
     if (eventType === 'session.deleted') {
       const sid = ev?.info?.id || ev?.sessionID || ev?.sessionId;
-      if (sid) _stoppedShares.resume(sid);
       if (sid && _tabSessionIds.includes(sid)) {
         handlePillClose(sid).catch((err) => console.warn('[ocp-v2-panel] close of a deleted session failed', err));
       }
@@ -626,6 +672,11 @@ function buildPanel() {
     const sid = getState().sessionId;
     if (sid) refreshSessionMessages(sid).catch((err) => console.warn('[ocp-v2-panel] post-compaction refresh failed', err));
   });
+
+  // Back after an outage: what the other tabs did meanwhile reached no one (the session on screen heals itself).
+  onReconnect(() => {
+    if (_booted) probeTabStatuses().catch((err) => console.warn('[ocp-v2-panel] tab status probe failed', err));
+  });
 }
 
 // A reverted prompt goes back into the composer with what it carried, each
@@ -833,7 +884,7 @@ function updateOpenCodeTitleLocally(sessionId, title) {
     ? active.sessionInfo
     : _tabInfoCache.get(sessionId);
   const updated = { ...(current || {}), id: sessionId, title };
-  _tabInfoCache.set(sessionId, _stoppedShares.clean(updated));
+  _tabInfoCache.set(sessionId, updated);
   if (sessionId === active.sessionId) setSession(sessionId, updated);
   ensureTab(sessionId, updated);
   renderPill();
@@ -1027,8 +1078,6 @@ let _sessionMenuSearch = '';
 let _sessionMenuArchived = false;
 let _sessionMenuBodyEl = null;
 let _sessionMenuRefreshTimer = null;
-let _sharePolicy = null;            // OpenCode's `share` setting, read once per menu open
-const _sharePolicyReads = latestOnly();
 // The list under the search box: the newest read wins, and only for the
 // filters (search text, archived or not) the menu still shows.
 const _sessionMenuReads = latestFor();
@@ -1098,20 +1147,6 @@ async function renderSessionMenu() {
   _sessionMenuEl.appendChild(_sessionMenuBodyEl);
   _menuConfirmAnchors.clear();
 
-  // Whether sharing is allowed at all (D2: hidden when the config disables it).
-  // The policy is the project's: an answer for an earlier opening of the menu,
-  // or for the session the panel has left, is not this menu's.
-  _sharePolicy = null;
-  const policyIsFresh = _sharePolicyReads.begin();
-  const policyAt = captureBinding(getDefaultStore());
-  api.sessionSharePolicy({ cwd: policyAt.cwd || undefined }).then((res) => {
-    if (!policyIsFresh() || !policyAt.isCurrent()) return;
-    if (!replyFailed(res)) {
-      _sharePolicy = res.data?.share || 'manual';
-      scheduleSessionMenuRefresh(0);
-    }
-  }).catch(() => {});
-
   await refreshSessionMenuBody();
   setTimeout(() => input.focus(), 0);
 }
@@ -1149,8 +1184,7 @@ async function refreshSessionMenuBody() {
   const cwd = s.cwd || storage.getItem(STOR_PROJECT) || '';
   // Sessions of every project are listed, so one from another registered
   // project can be resumed; sub-agent sessions open from their parent instead.
-  // (A link whose sharing the panel stopped is not a share: the row says so.)
-  const all = menuSessions(sessions, { search }).slice(0, SESSION_MENU_LIMIT).map((row) => _stoppedShares.clean(row));
+  const all = menuSessions(sessions, { search }).slice(0, SESSION_MENU_LIMIT);
 
   body.innerHTML = '';
   _menuConfirmAnchors.clear();
@@ -1195,82 +1229,14 @@ async function refreshSessionMenuBody() {
   syncSessionMenuConfirm();
 }
 
-// Publishing is two steps, both in the panel. "Share session…" (or /share)
-// only asks: the question under it says what becomes public, and its button
-// shares. Nothing is published by one click, and never by a native dialog.
-async function shareActiveSession() {
-  const sid = getState().sessionId;
-  if (!sid) return null;
-  if (!_sessionMenuEl?.classList.contains('open')) openSessionMenu();
-  const result = await shareSession(getDefaultStore(), api, () => _confirms.ask({
-    key: `share:${sid}`, surface: 'menu', text: SHARE_CONFIRM_TEXT, confirmLabel: 'Share publicly',
-  }), { stopped: _stoppedShares });
-  if (result && result.ok === false && !result.cancelled && !result.moved) pushError({ message: result.error || 'Share failed' });
-  if (result?.ok && result.url) {
-    try { await navigator.clipboard.writeText(result.url); } catch {}
-    if (_sessionMenuEl?.classList.contains('open')) scheduleSessionMenuRefresh(0);
-    else openSessionMenu();
-  }
-  return result;
-}
-
-// Stop sharing: the link goes from everything the panel holds of that
-// session (the store, the tab cache, the menu), also when the panel was on
-// another session by the time OpenCode answered.
-async function stopSharingActiveSession() {
-  const sid = getState().sessionId;
-  const result = await unshareSession(getDefaultStore(), api, { stopped: _stoppedShares });
-  if (result && result.ok === false && !result.moved) pushError({ message: result.error || 'Could not stop sharing' });
-  if (sid) forgetStoppedShare(sid);
-  return result;
-}
-
-function forgetStoppedShare(sessionId) {
-  const cached = _tabInfoCache.get(sessionId);
-  if (cached) _tabInfoCache.set(sessionId, _stoppedShares.clean(cached));
-  const known = getState().knownSessions;
-  if (known?.has?.(sessionId)) known.set(sessionId, _stoppedShares.clean(known.get(sessionId)));
-  scheduleSessionMenuRefresh(0);
-}
-
-// Share / export / fork for the session that is open.
+// Export / fork for the session that is open.
 function appendActiveSessionActions(body, s) {
   if (!s.sessionId) return;
-  const share = shareView(s.sessionInfo, _sharePolicy, supports);
   const report = (result, fallback) => {
     if (result && result.ok === false && !result.cancelled && !result.moved) pushError({ message: result.error || fallback });
     return result;
   };
 
-  // Asked every time, under this item: the click only opens the question.
-  // (The item is there while its question is armed, whatever the policy read
-  // says by then: /share asks before that read is back.)
-  const shareKey = `share:${s.sessionId}`;
-  if ((share.canShare && _sharePolicy) || _confirms.isArmed(shareKey)) {
-    const shareItem = menuItem('Share session…', () => {
-      shareActiveSession().catch((err) => pushError({ message: err?.message || 'Share failed' }));
-    }, { muted: true });
-    _menuConfirmAnchors.set(shareKey, shareItem);
-    body.appendChild(shareItem);
-  }
-  if (share.showLink) {
-    body.appendChild(menuItem('Copy share link', async () => {
-      // A failed copy is reported in the session whose link it was.
-      const at = captureBinding(getDefaultStore());
-      try { await navigator.clipboard.writeText(share.url); } catch (err) {
-        if (at.isCurrent()) pushError({ message: err?.message || 'Copy failed' });
-      }
-    }, { muted: true, meta: 'public' }));
-    const url = document.createElement('div');
-    url.className = 'ocpv2-session-share-url';
-    url.textContent = share.url;
-    body.appendChild(url);
-  }
-  if (share.canUnshare) {
-    body.appendChild(menuItem('Stop sharing', () => {
-      stopSharingActiveSession().catch((err) => pushError({ message: err?.message || 'Could not stop sharing' }));
-    }, { muted: true }));
-  }
   if (s.messageOrder.length) {
     body.appendChild(menuItem('Export transcript', () => {
       closeSessionMenu();
@@ -1310,7 +1276,7 @@ function buildSessionMenuItem(sess, s, cwd, { archived, filters }) {
   labelEl.textContent = title;
   item.appendChild(labelEl);
 
-  const meta = [projectName, sess.share?.url ? 'shared' : ''].filter(Boolean).join(' · ');
+  const meta = projectName || '';
   if (meta) {
     const metaEl = document.createElement('span');
     metaEl.className = 'ocpv2-session-item-meta';
@@ -1506,7 +1472,7 @@ async function restoreSessionSelections(sid, info) {
     applySessionSelections(getDefaultStore(), full);
     // Fresh metadata too: keeps the title right after a switch.
     getDefaultStore().setSessionInfo(full);
-    _tabInfoCache.set(sid, _stoppedShares.clean({ ...(_tabInfoCache.get(sid) || {}), ...full }));
+    _tabInfoCache.set(sid, { ...(_tabInfoCache.get(sid) || {}), ...full });
     if (!info) ensureTab(sid, full);
   });
 }
@@ -1628,7 +1594,7 @@ async function boot() {
           const info = byId.get(sid);
           if (info) {
             liveTabs.push(sid);
-            _tabInfoCache.set(sid, _stoppedShares.clean(info));
+            _tabInfoCache.set(sid, info);
             ensureOpenCodeTitleState(sid, info, { manual: true });
           }
         }
@@ -1638,7 +1604,7 @@ async function boot() {
       if (!liveTabs.length && _pendingAutomationAttach?.sessionId) {
         const { sessionId, info } = _pendingAutomationAttach;
         liveTabs.push(sessionId);
-        _tabInfoCache.set(sessionId, _stoppedShares.clean(info || { id: sessionId }));
+        _tabInfoCache.set(sessionId, info || { id: sessionId });
         ensureOpenCodeTitleState(sessionId, info, { manual: true });
         _tabSessionIds = [...liveTabs];
         saveTabSessions();
@@ -1672,6 +1638,10 @@ async function boot() {
           create: (nav) => startFreshSession({ cwd: lastProject || undefined, nav }),
         });
       }
+      // The other tabs: their turns may have outlived the page too. Asked before the placeholders go
+      // (a short wait at most), so a working tab's pill does not blink idle in between.
+      const probed = probeTabStatuses().catch((err) => console.warn('[ocp-v2-panel] tab status probe failed', err));
+      await Promise.race([probed, new Promise((resolveWait) => setTimeout(resolveWait, 600))]);
       _booted = true;
       // Tell ui-sidepanel-tray we own opencode pills now — it drops any
       // placeholder pills it was rendering from storage.
@@ -1894,14 +1864,6 @@ function promptNameNewSession(targetSessionId = null) {
         <label class="ocpv2-name-modal-label">Branch</label>
         <select class="ocpv2-name-modal-select" data-role="branch" disabled></select>
       </div>
-      <div class="ocpv2-name-modal-row ocpv2-name-modal-worktree" hidden>
-        <label class="ocpv2-name-modal-label">Worktree</label>
-        <label class="ocpv2-name-modal-check">
-          <input type="checkbox" data-role="worktree" />
-          <span>Run in a new git worktree</span>
-        </label>
-      </div>
-      <div class="ocpv2-name-modal-worktrees" hidden></div>
       <input type="text" class="ocpv2-name-modal-input" placeholder="Session name..." maxlength="120" />
       <div class="ocpv2-name-modal-actions">
         <button type="button" class="ocpv2-name-modal-btn skip">Skip</button>
@@ -1926,14 +1888,6 @@ function promptNameNewSession(targetSessionId = null) {
 
   let branchOriginal = null;
   let branchesKnown = false;
-  // A session in a new worktree starts from what the project has checked out
-  // now; the project's own checkout is never switched for it.
-  const syncBranchLock = () => {
-    const locked = !!worktreeCheck?.checked;
-    if (locked && branchOriginal) branchSel.value = branchOriginal;
-    branchSel.disabled = locked || !branchesKnown;
-    branchSel.title = locked ? 'A new worktree starts from the branch the project has checked out.' : '';
-  };
   let branchRequest = 0;
   async function refreshBranches(path) {
     const request = ++branchRequest;
@@ -1956,75 +1910,13 @@ function promptNameNewSession(targetSessionId = null) {
       if (branchOriginal) branchSel.value = branchOriginal;
       branchesKnown = true;
     }
-    syncBranchLock();
+    branchSel.disabled = !branchesKnown;
   }
 
-  // Worktrees: an isolated checkout OpenCode creates for the session, so its
-  // edits stay out of the main working tree. Offered only when the server can.
-  const worktreeRow = overlay.querySelector('.ocpv2-name-modal-worktree');
-  const worktreeCheck = overlay.querySelector('input[data-role="worktree"]');
-  const worktreeList = overlay.querySelector('.ocpv2-name-modal-worktrees');
-  worktreeCheck?.addEventListener('change', syncBranchLock);
   refreshBranches(projectSel?.value || initialProject);
-  const worktreeReads = latestOnly();
-  // Removing a worktree is asked in the dialog, under its row.
-  const worktreeConfirmAnchors = new Map();
-  const dialogQuestion = (view) => view.surface === 'dialog';
-  const offWorktreeConfirm = _confirms.onChange(() => {
-    syncConfirmRow(_confirms, worktreeList, 'dialog', (key) => worktreeConfirmAnchors.get(key));
-  });
-  async function refreshWorktrees(path) {
-    // The rows are read again: a question about one of them is off.
-    _confirms.cancel(dialogQuestion);
-    worktreeConfirmAnchors.clear();
-    const canCreate = supports('worktree:create') && !!path;
-    worktreeRow.hidden = !canCreate;
-    if (!canCreate) worktreeCheck.checked = false;
-    syncBranchLock();
-    worktreeList.hidden = true;
-    worktreeList.textContent = '';
-    if (!path || !supports('worktree:list', 'worktree:remove')) return;
-    const latest = worktreeReads.begin();
-    const res = await api.worktreeList({ cwd: path }).catch(() => null);
-    // A newer read (another project picked, a worktree removed) owns the list.
-    if (!latest() || replyFailed(res) || !Array.isArray(res.data) || !res.data.length || projectSel?.value !== path) return;
-    worktreeList.hidden = false;
-    for (const tree of res.data) {
-      const row = document.createElement('div');
-      row.className = 'ocpv2-permission-more';
-      const name = document.createElement('code');
-      name.textContent = tree.branch ? `${tree.name} (${tree.branch})` : tree.name;
-      name.title = tree.directory;
-      const remove = document.createElement('button');
-      remove.type = 'button';
-      remove.className = 'ocpv2-permission-link';
-      remove.textContent = 'Remove';
-      remove.addEventListener('click', async () => {
-        // This click only asks; the button of the question removes it.
-        const key = `worktree-remove:${tree.directory}`;
-        worktreeConfirmAnchors.set(key, row);
-        const agreed = await _confirms.ask({
-          key, surface: 'dialog', confirmLabel: 'Remove worktree',
-          text: `Remove the worktree "${tree.name}"? Its directory and uncommitted changes are deleted.`,
-        });
-        if (!agreed) return;
-        const removed = await api.worktreeRemove({ cwd: path, directory: tree.directory }).catch((err) => ({ ok: false, error: err?.message }));
-        // The failure is about the worktree, not about a session: it is shown
-        // wherever the panel is. The list is this dialog's: it is read again
-        // only while the dialog is open and still on that project.
-        if (replyFailed(removed)) { pushError({ message: replyError(removed, 'Could not remove the worktree') }); return; }
-        if (done || projectSel?.value !== path) return;
-        refreshWorktrees(path);
-      });
-      row.append(name, remove);
-      worktreeList.appendChild(row);
-    }
-  }
-  refreshWorktrees(projectSel?.value || initialProject);
 
   projectSel?.addEventListener('change', () => {
     refreshBranches(projectSel.value);
-    refreshWorktrees(projectSel.value);
   });
 
   setTimeout(() => { input.focus(); input.select(); }, 10);
@@ -2033,8 +1925,6 @@ function promptNameNewSession(targetSessionId = null) {
   const close = () => {
     if (done) return;
     done = true;
-    offWorktreeConfirm();
-    _confirms.cancel(dialogQuestion);
     overlay.remove();
   };
 
@@ -2043,29 +1933,20 @@ function promptNameNewSession(targetSessionId = null) {
     const nextTitle = input.value.trim();
     const chosenProject = projectSel?.value || '';
     const chosenBranch = branchSel?.value || '';
-    const wantsWorktree = !!worktreeCheck?.checked && !!chosenProject;
     close();
     // Skip leaves the freshly-created session in place — same as Claude/Codex
     // where dismissing the rename modal keeps the empty new tab.
     if (cancel) return;
 
     const plan = newSessionPlan({
-      project: chosenProject, branch: chosenBranch, currentBranch: branchOriginal || '',
-      wantsWorktree, cwd: getState().cwd || '',
+      project: chosenProject, branch: chosenBranch, currentBranch: branchOriginal || '', cwd: getState().cwd || '',
     });
     const projectChanged = plan.projectChanged;
     // What Save starts is a navigation of its own when it creates a session
-    // (in a worktree, in another project): it owns the panel from this click
-    // on, unless the user chooses something else while it waits. A Save that
-    // only names the session navigates nowhere and begins no intent.
-    const nav = (plan.worktree || projectChanged) ? _nav.begin() : null;
-
-    // The worktree first: an isolated session never switches the branch of the
-    // project's own checkout.
-    if (plan.worktree) {
-      await startSessionInNewWorktree(chosenProject, nextTitle, nav);
-      return;
-    }
+    // (in another project): it owns the panel from this click on, unless the
+    // user chooses something else while it waits. A Save that only names the
+    // session navigates nowhere and begins no intent.
+    const nav = projectChanged ? _nav.begin() : null;
 
     if (plan.checkout) {
       // A session started after a failed switch would run on the wrong base.
@@ -2133,40 +2014,6 @@ function promptNameNewSession(targetSessionId = null) {
   });
 }
 
-// "Run in a new git worktree": OpenCode creates the worktree (and runs the
-// project's start command in it), then the session is created inside it. The
-// project stays the remembered default; only this session lives in the worktree.
-async function startSessionInNewWorktree(projectPath, title, nav = _nav.begin()) {
-  // Subscribe before creating: the ready event can beat the reply. Events are
-  // held until the reply names this worktree, so another creation finishing
-  // (or failing) first is not mistaken for this one.
-  const watch = watchWorktree(onEvent, { timeoutMs: 60_000 });
-  const created = await api.worktreeCreate({ cwd: projectPath }).catch((err) => ({ ok: false, error: err?.message }));
-  if (replyFailed(created) || !created.data?.directory) {
-    watch.cancel();
-    pushError({ message: replyError(created, 'Could not create the worktree') });
-    return;
-  }
-  watch.identify(created.data.name);
-  const state = await watch.result;
-  if (!state.ok) {
-    pushError({ message: state.error });
-    return;
-  }
-  // Up to a minute has passed. The session is created in the worktree either
-  // way; it takes the panel only when the user did not navigate meanwhile
-  // (`nav`), and is a tab otherwise.
-  if (nav.isCurrent()) {
-    const prevSid = getState().sessionId;
-    if (prevSid) ensureTab(prevSid, getState().sessionInfo);
-  }
-  try {
-    await startFreshSession({ title: title || undefined, cwd: created.data.directory, nav });
-  } catch (err) {
-    pushError({ message: err?.message || 'New session failed' });
-  }
-}
-
 async function closeCurrentSession() {
   // Update the UI first; server cleanup is best-effort and must not block the
   // only visible tab from closing.
@@ -2291,7 +2138,7 @@ function saveTabSessions() {
 
 function ensureTab(sessionId, info = null) {
   if (!sessionId) return;
-  if (info) _tabInfoCache.set(sessionId, _stoppedShares.clean(info));
+  if (info) _tabInfoCache.set(sessionId, info);
   if (!_tabSessionIds.includes(sessionId)) {
     _tabSessionIds.push(sessionId);
     saveTabSessions();
@@ -2388,9 +2235,11 @@ function removeTab(sessionId, { byUser = false } = {}) {
   _automationRunIds.delete(sessionId);
   unregisterAutomationSession(sessionId);
   _automationRunning.delete(sessionId);
+  _automationTurn.delete(sessionId);
   _automationContinuedManually.delete(sessionId);
   _automationManualSendInFlight.delete(sessionId);
   saveAutomationTabs();
+  if (_sessionBusy.delete(sessionId)) saveBusySessions();
   const pill = _tabPills.get(sessionId);
   if (pill?.isConnected) pill.remove();
   _tabPills.delete(sessionId);
@@ -2449,7 +2298,17 @@ async function closeTabByUser(sessionId, context) {
 // Assistant session that dispatched it.
 function workerEndCard(sessionId) {
   const view = sessionId ? _workerEnds.get(sessionId) : null;
-  if (!view) return null;
+  if (!view) {
+    const restart = _workerRestarts.get(sessionId);
+    if (!restart?.key) return null;
+    return { sig: restart.stamp, build: () => {
+      const el = document.createElement('div');
+      el.className = 'ocpv2-post-plan-card ocpv2-post-plan-body';
+      el.setAttribute('role', 'status');
+      el.textContent = t(restart.key);
+      return el;
+    } };
+  }
   return {
     sig: view.sig,
     build: () => buildWorkerEndCard(view, {
@@ -2481,6 +2340,8 @@ function renderPill() {
   if (!tray) return;
   const activeSid = getState().sessionId;
   if (activeSid) ensureTab(activeSid, getState().sessionInfo);
+  // What the session on screen is doing stays known for its tab once the user moves on.
+  if (activeSid) rememberBusy(activeSid, !!getState().running);
 
   // Drop pills for sessions no longer in the tab list
   for (const [sid, pill] of Array.from(_tabPills.entries())) {
@@ -2501,7 +2362,14 @@ function renderPill() {
     if (labelEl) labelEl.textContent = tabLabelFor(sid);
     const isActive = sid === activeSid;
     pill.classList.toggle('ocpv2-pill-active', isActive);
-    pill.classList.toggle('ocpv2-pill-running', _automationRunning.has(sid) || (isActive && !!getState().running));
+    // One pill per session, each with its own state: a tab the user left goes on showing its turn, an
+    // automation its turn (not its run), and a session that waits on the user says so.
+    const state = tabPillState({
+      sessionId: sid, activeSessionId: activeSid, running: !!getState().running,
+      busy: _sessionBusy.get(sid) === true, automation: _automationTurn.get(sid) || null,
+    });
+    pill.classList.toggle('ocpv2-pill-running', state === 'working');
+    pill.classList.toggle('ocpv2-pill-waiting', state === 'waiting');
     pill.style.display = (isActive && _visible) ? 'none' : '';
   }
   // The sub-agent pills of the session on screen sit under its pill.
@@ -2624,6 +2492,16 @@ export async function endHostedOpenCodeSessions() {
 
 export function isOpencodePanelOpen() { return _visible || isChildPanelOpen(); }
 
+/**
+ * Boot the panel without showing it (ui-sidepanel-tray.js, when a tab saved while it worked comes back
+ * after a reload): its tabs come back and OpenCode is asked what each session does, so their pills say it.
+ */
+export async function bootOpencodePanel() {
+  if (!_panelEl) buildPanel();
+  await connect();
+  await boot();
+}
+
 export async function toggleOpencodePanel() {
   if (_visible || isChildPanelOpen()) {
     requestOpencodeView({ hideAll: true });
@@ -2641,7 +2519,9 @@ export async function attachOpenCodeAutomation(run, { focus = !!run?.focus, isCa
   // Establish ownership before connect()/boot(): native provider events use a
   // separate socket and may report a Task child while this attach is awaiting.
   const previousRunId = _automationRunIds.get(sessionId);
-  const running = run.status === 'starting' || run.status === 'running';
+  const restart = workerRestart(run);
+  const running = restart.active;
+  _workerRestarts.set(sessionId, restart);
   // The user continued this run's session by hand after the run ended: the tab stays theirs.
   const released = !running && previousRunId === run.runId
     && (_automationContinuedManually.has(sessionId) || _automationManualSendInFlight.has(sessionId));
@@ -2653,12 +2533,16 @@ export async function attachOpenCodeAutomation(run, { focus = !!run?.focus, isCa
   }
   if (running) _automationRunning.add(sessionId);
   else _automationRunning.delete(sessionId);
+  // Every update of the run (its turn starts, waits on you, ends) comes through here: the pill follows it.
+  const phase = automationTurnPhase(run);
+  if (phase) _automationTurn.set(sessionId, phase);
+  else _automationTurn.delete(sessionId);
   saveAutomationTabs();
   const info = {
     id: sessionId,
     title: run.title || 'Automation',
     directory: run.cwd || '',
-    mcpProfile: run.mcpProfile || null,
+    tools: run.tools || null,
     time: { updated: Date.now() },
   };
   if (!_booted) _pendingAutomationAttach = { sessionId, info };
@@ -2688,16 +2572,17 @@ export async function attachOpenCodeAutomation(run, { focus = !!run?.focus, isCa
     if (!_visible) await showPrimaryOpencodePanel();
     await switchToSession(sessionId, info, { nav });
   } else if (getState().sessionId === sessionId) {
-    setRunning(running);
+    setRunning(running && !restart.suspended);
     await rehydrateActiveSession().catch(() => {});
   }
-  if (getState().sessionId === sessionId) setRunning(running);
+  if (getState().sessionId === sessionId) setRunning(running && !restart.suspended);
+  _renderer?.render();
   // (A dispatched worker's failure, with its reason, is on its end card.)
   if (run.status === 'failed' && run.error && !isDispatchedRun(run) && getState().sessionId === sessionId
     && _tabInfoCache.get(sessionId)?._automationLifecycleError !== run.error) {
     const cachedInfo = _tabInfoCache.get(sessionId) || info;
     cachedInfo._automationLifecycleError = run.error;
-    _tabInfoCache.set(sessionId, _stoppedShares.clean(cachedInfo));
+    _tabInfoCache.set(sessionId, cachedInfo);
     pushError({ message: run.error });
   }
   trackWorkerEnd(run, { apply: (view) => showWorkerEnd(sessionId, view) });
@@ -2711,6 +2596,7 @@ export async function detachOpenCodeAutomation(runId) {
   const [sessionId] = entry;
   _automationRunIds.delete(sessionId);
   _automationRunning.delete(sessionId);
+  _automationTurn.delete(sessionId);
   _automationContinuedManually.delete(sessionId);
   _automationManualSendInFlight.delete(sessionId);
   saveAutomationTabs();