synabun 2.0.7 → 2.0.10

package/neural-interface/public/shared/ocp-v2/ocp-v2-send-logic.js

@@ -3,6 +3,7 @@
 // ─────────────────────────────────────────────────────────────────────────────
 
 import { isBindingToken } from './ocp-v2-binding.js';
+import { knownDescendant, requestOwner } from './ocp-v2-rehydrate.js';
 
 /**
  * The compose box shows the outgoing prompt at once as a local message. The
@@ -115,3 +116,403 @@ export function settleFailedSend(turn, parked, { item, error = '' } = {}) {
   const kept = !!(turn.sessionId && item && parked?.park(turn.sessionId, { item, error }));
   return { here: false, parked: kept };
 }
+
+// ── How long a turn may take ────────────────────────────────────────────────
+// A turn can wait on the user for as long as they take (a permission, a
+// question): the clock that gives up on a turn nobody hears from again counts
+// only the time it works.
+
+/** The working time a turn's send waits for its answer (message:send, command:run, an async turn's idle). */
+export const TURN_LIMIT_MS = 30 * 60 * 1000;
+
+/**
+ * Runs `onExpire` once `ms` of unpaused time went by. `paused()` says whether
+ * the turn waits on the user now; `subscribe(fn)` calls `fn` whenever that may
+ * have changed and returns an unsubscribe. `cancel()` stops it for good.
+ */
+export function createTurnClock({
+  ms, paused = () => false, subscribe = () => () => {}, onExpire = () => {},
+  now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout,
+} = {}) {
+  let left = Math.max(0, Number(ms) || 0);
+  let since = 0;
+  let timer = null;
+  let done = false;
+  let unsubscribe = () => {};
+  const finish = () => {
+    done = true;
+    timer = null;
+    try { unsubscribe(); } catch { /* gone */ }
+  };
+  const run = () => {
+    if (done || timer) return;
+    since = now();
+    timer = setTimer(() => { finish(); onExpire(); }, left);
+  };
+  const hold = () => {
+    if (!timer) return;
+    clearTimer(timer);
+    timer = null;
+    left = Math.max(0, left - (now() - since));
+  };
+  const sync = () => {
+    if (done) return;
+    if (paused()) hold(); else run();
+  };
+  unsubscribe = subscribe(sync) || (() => {});
+  sync();
+  return {
+    cancel() {
+      if (done) return;
+      if (timer) clearTimer(timer);
+      finish();
+    },
+    /** The working time left (ms). */
+    left: () => (timer ? Math.max(0, left - (now() - since)) : left),
+  };
+}
+
+const ASKED = new Set(['permission.asked', 'question.asked']);
+const ANSWERED = new Set(['permission.replied', 'question.replied', 'question.rejected']);
+const askIdOf = (ev) => String(ev?.requestID || ev?.id || ev?.permissionID || '');
+const askKindOf = (eventType) => (String(eventType).startsWith('permission.') ? 'permission' : 'question');
+
+/** The two lists a session's open requests are read from (permission:list, question:list). */
+export const ASK_KINDS = Object.freeze(['permission', 'question']);
+/** How often a list is read before the panel gives up on it, the first read included. */
+export const ASK_READ_ATTEMPTS = 3;
+/** The waits before the second and the third read of a list. */
+export const ASK_RETRY_MS = Object.freeze([1000, 4000]);
+const LIST_STATES = new Set(['ok', 'failed', 'unsupported', 'unresolved']);
+
+// One event applied to the open requests (request id → { owner, kind, stale }); true when what waits changed.
+function applyAskEvent(open, eventType, ev) {
+  if (ASKED.has(eventType)) {
+    const id = askIdOf(ev);
+    const owner = requestOwner(ev);
+    if (!id || !owner) return false;
+    const known = open.get(id);
+    open.set(id, { owner, kind: askKindOf(eventType), stale: false });
+    return known?.owner !== owner;
+  }
+  if (ANSWERED.has(eventType)) return open.delete(askIdOf(ev));
+  if (eventType === 'session.idle' || eventType === 'session.error') {
+    const sid = String(ev?.sessionID || ev?.sessionId || '');
+    let gone = false;
+    for (const [id, entry] of open) if (entry.owner === sid) { open.delete(id); gone = true; }
+    return gone;
+  }
+  return false;
+}
+
+/**
+ * The requests that wait on the user, by the session that raised them, from
+ * the panel's event stream (every session's events reach it): asked by
+ * permission.asked / question.asked, gone with their answer, and gone with the
+ * turn (session.idle, session.error). `waits(sessionId)` is true while that
+ * session, or a sub-agent below it (`parentOf`: child → parent), has one.
+ *
+ * What the stream cannot tell (what was asked before the page loaded, or while
+ * the socket was down) is read from the server, list by list: each session's
+ * permissions and its questions (readOpenAsks). `read(want, { attempt, partial })`
+ * resolves `{ lists }`, each `{ sessionId, kind, state, requests }`; `want` is
+ * null for every session a panel is bound to, else `[{ sessionId, kinds }]`.
+ *   • A list that was read (state ok, or unresolved: read, but a request in it
+ *     is of a session whose place could not be established) replaces what was
+ *     known of its kind for its session and the sub-agents known below it, also
+ *     when it came back empty. Events that arrived while it was read are applied
+ *     again on top.
+ *   • A session whose list failed or is unresolved keeps waiting (no clock of it
+ *     counts) and has that list read again, ASK_READ_ATTEMPTS times in all. Then,
+ *     or at once for a list the server cannot give (unsupported), the panel gives
+ *     up on it: what was known of it from before the outage goes, its clocks
+ *     count again, and the rebuild resolves `{ gaveUp: [{ sessionId, kinds }] }`
+ *     so that the panel says so. Nothing could be read at all: `{ unread: true }`.
+ * `hold()` (the socket closed): every session counts as waiting until the first
+ * read of the `rebuild(read)` that follows, and what was known turns into
+ * unconfirmed, to be confirmed or dropped by the lists. A newer `hold()` makes
+ * an older rebuild void (it resolves null).
+ * `expect(sessionIds)` + `rebuild(read, { sessions })` read only those sessions
+ * (a page load, a panel bound to another session): they wait from `expect` until
+ * their lists are in, and no other session is held.
+ */
+export function createAskTracker({ parentOf = new Map(), attempts = ASK_READ_ATTEMPTS, retryMs = ASK_RETRY_MS, setTimer = setTimeout } = {}) {
+  let open = new Map();        // request id → { owner, kind, stale }
+  let held = false;            // the socket is down, or the first read after it is out: everything waits
+  const pending = new Map();   // session → the kinds whose list is still to be read (it waits meanwhile)
+  let generation = 0;
+  let replay = null;           // the events noted while a read is out
+  const listeners = new Set();
+  const changed = () => {
+    for (const fn of [...listeners]) {
+      try { fn(); } catch (e) { console.warn('[ocp-v2-send] ask listener failed', e); }
+    }
+  };
+  const under = (owner, root) => owner === root || knownDescendant(owner, root, parentOf);
+  const expect = (sessionId, kinds) => {
+    let set = pending.get(sessionId);
+    if (!set) pending.set(sessionId, (set = new Set()));
+    for (const kind of kinds) set.add(kind);
+  };
+  const settle = (sessionId, kind) => {
+    const set = pending.get(sessionId);
+    if (!set) return;
+    set.delete(kind);
+    if (!set.size) pending.delete(sessionId);
+  };
+  // An entry still to be confirmed by a list that will be read again.
+  const awaited = (entry) => {
+    for (const [root, kinds] of pending) if (kinds.has(entry.kind) && under(entry.owner, root)) return true;
+    return false;
+  };
+  const sleep = (ms) => new Promise((done) => { setTimer(done, Math.max(0, Number(ms) || 0)); });
+  const delayAfter = (attempt) => (Array.isArray(retryMs) ? retryMs[Math.min(attempt, retryMs.length) - 1] : retryMs) || 0;
+  const wantedOf = (sessions) => (Array.isArray(sessions)
+    ? [...new Set(sessions.map((id) => String(id || '')).filter(Boolean))].map((sessionId) => ({ sessionId, kinds: [...ASK_KINDS] }))
+    : null);
+
+  return {
+    note(eventType, ev) {
+      replay?.push([eventType, ev]);
+      if (applyAskEvent(open, eventType, ev) && !held) changed();
+    },
+    waits(sessionId) {
+      const sid = String(sessionId || '');
+      if (!sid) return false;
+      if (held) return true;
+      for (const [root, kinds] of pending) if (kinds.size && under(sid, root)) return true;
+      for (const { owner } of open.values()) if (owner === sid || knownDescendant(owner, sid, parentOf)) return true;
+      return false;
+    },
+    hold() {
+      generation += 1;
+      replay = null;
+      pending.clear();
+      for (const entry of open.values()) entry.stale = true;
+      if (held) return;
+      held = true;
+      changed();
+    },
+    /** These sessions wait from now until their lists are read (rebuild with `sessions`). */
+    expect(sessionIds) {
+      const wanted = wantedOf(sessionIds) || [];
+      for (const { sessionId, kinds } of wanted) expect(sessionId, kinds);
+      if (wanted.length && !held) changed();
+    },
+    /** These sessions wait for no read of their own (their parent's lists hold their requests). */
+    release(sessionIds) {
+      let gone = false;
+      for (const { sessionId } of wantedOf(sessionIds) || []) gone = pending.delete(sessionId) || gone;
+      if (gone && !held) changed();
+    },
+    async rebuild(read, { sessions = null } = {}) {
+      const mine = generation;
+      const partial = Array.isArray(sessions);
+      let want = wantedOf(sessions);
+      if (partial) {
+        if (!want.length) return { gaveUp: [] };
+        for (const { sessionId, kinds } of want) expect(sessionId, kinds);
+      }
+      const gaveUp = new Map(); // session → kinds given up on
+      for (let attempt = 1; ; attempt += 1) {
+        replay = [];
+        let snapshot = null;
+        try { snapshot = await read(want, { attempt, partial }); } catch { snapshot = null; }
+        if (mine !== generation) return null;
+        const events = replay || [];
+        replay = null;
+        const last = attempt >= attempts;
+        const lists = Array.isArray(snapshot?.lists) ? snapshot.lists : null;
+        if (!lists && !want) {
+          // Nothing came back, and nothing says which sessions were read.
+          if (!last) {
+            await sleep(delayAfter(attempt));
+            if (mine !== generation) return null;
+            continue;
+          }
+          for (const [id, entry] of open) if (entry.stale) open.delete(id);
+          held = false;
+          changed();
+          return { gaveUp: [], unread: true };
+        }
+        const results = [];
+        for (const list of lists || []) {
+          const sessionId = String(list?.sessionId || '');
+          if (!sessionId || !ASK_KINDS.includes(list?.kind)) continue;
+          results.push({
+            sessionId,
+            kind: list.kind,
+            state: LIST_STATES.has(list.state) ? list.state : 'failed',
+            requests: Array.isArray(list.requests) ? list.requests : [],
+          });
+        }
+        for (const { sessionId, kinds } of want || []) {
+          for (const kind of kinds) {
+            if (results.some((list) => list.sessionId === sessionId && list.kind === kind)) continue;
+            // Not in the answer: nothing came back (failed), or no panel is bound to it any more (not asked).
+            if (lists) settle(sessionId, kind);
+            else results.push({ sessionId, kind, state: 'failed', requests: [] });
+          }
+        }
+        const next = new Map(open);
+        for (const list of results) {
+          if (list.state !== 'ok' && list.state !== 'unresolved') continue;
+          const listed = new Map();
+          for (const req of list.requests) {
+            const id = askIdOf(req);
+            const owner = requestOwner(req);
+            if (id && owner) listed.set(id, owner);
+          }
+          // What the list does not hold is no longer open, for its session and the sub-agents known below it.
+          for (const [id, entry] of next) {
+            if (entry.kind === list.kind && under(entry.owner, list.sessionId) && !listed.has(id)) next.delete(id);
+          }
+          for (const [id, owner] of listed) next.set(id, { owner, kind: list.kind, stale: false });
+        }
+        const again = new Map(); // session → kinds to read again
+        for (const list of results) {
+          if (list.state === 'ok') { settle(list.sessionId, list.kind); continue; }
+          if (list.state === 'unsupported' || last) {
+            settle(list.sessionId, list.kind);
+            if (!gaveUp.has(list.sessionId)) gaveUp.set(list.sessionId, new Set());
+            gaveUp.get(list.sessionId).add(list.kind);
+            continue;
+          }
+          expect(list.sessionId, [list.kind]);
+          if (!again.has(list.sessionId)) again.set(list.sessionId, new Set());
+          again.get(list.sessionId).add(list.kind);
+        }
+        for (const [eventType, ev] of events) applyAskEvent(next, eventType, ev);
+        // Known from before the outage and confirmed by no list that is still to come: it goes.
+        for (const [id, entry] of next) if (entry.stale && !awaited(entry)) next.delete(id);
+        open = next;
+        if (!partial) held = false;
+        changed();
+        if (!again.size) {
+          return { gaveUp: [...gaveUp].map(([sessionId, kinds]) => ({ sessionId, kinds: ASK_KINDS.filter((kind) => kinds.has(kind)) })) };
+        }
+        await sleep(delayAfter(attempt));
+        if (mine !== generation) return null;
+        want = [...again].map(([sessionId, kinds]) => ({ sessionId, kinds: ASK_KINDS.filter((kind) => kinds.has(kind)) }));
+      }
+    },
+    clear() {
+      if (!open.size) return;
+      open.clear();
+      changed();
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+  };
+}
+
+/**
+ * The sentence a panel shows when the open requests of its session could not
+ * be read (the tracker gave up on `kinds`): its turn's clock counts again.
+ */
+export function unreadAsksNotice(kinds = ASK_KINDS) {
+  const set = new Set(Array.isArray(kinds) && kinds.length ? kinds : ASK_KINDS);
+  const what = set.has('permission') && set.has('question') ? 'permissions and questions'
+    : set.has('permission') ? 'permissions' : 'questions';
+  return `Could not read this session's open ${what} from OpenCode: its 30-minute turn limit runs as if none were waiting.`;
+}
+
+/**
+ * What waits on the user in the sessions panels are bound to, read from the
+ * server: for each `{ sessionId, cwd, kinds }` (both kinds unless it says), the
+ * open permissions (`api.permissionList`) and questions (`api.questionList`) of
+ * the serve that runs that session, with its sub-agents' (they run on the same
+ * serve). Each list comes back with its `state`: ok; failed; unsupported (the
+ * server has no such request type); or unresolved: read, but it holds a request
+ * of a session whose place under this one could not be established.
+ * A request of a session that is neither one of these nor known below one has
+ * its place read (`ancestry(owner, sessionId)`: true, false, or null when that
+ * could not be read; it remembers what it learns), so that a sub-agent spawned
+ * while nobody watched holds its parent's clock too: at most `maxLookups`
+ * lookups within `lookupMs`, each given only the time that is left (a lookup
+ * still waiting on the server then counts as not read). `isDescendant`, a
+ * yes / no answer, is accepted in its place.
+ * Resolves `{ lists, requests, complete }`: `complete` when every list is ok.
+ */
+export async function readOpenAsks(api, sessions, {
+  ancestry = null, isDescendant = null, known = () => false,
+  maxLookups = 20, lookupMs = 5000, now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout,
+} = {}) {
+  const listOf = (res) => {
+    const data = res?.data;
+    if (Array.isArray(data)) return data;
+    if (Array.isArray(data?.questions)) return data.questions;
+    if (Array.isArray(data?.data)) return data.data;
+    return null;
+  };
+  const failed = (res) => !res || res.ok === false || res.error != null || (typeof res.status === 'number' && res.status >= 400);
+  const readList = async (call) => {
+    let res;
+    try { res = await call(); } catch { res = null; }
+    if (res?.unsupported) return { state: 'unsupported', requests: [] };
+    const list = failed(res) ? null : listOf(res);
+    if (!list) return { state: 'failed', requests: [] };
+    return { state: 'ok', requests: list.filter((req) => askIdOf(req) && requestOwner(req)) };
+  };
+  const lists = [];
+  for (const { sessionId, cwd, kinds } of Array.isArray(sessions) ? sessions : []) {
+    if (!sessionId) continue;
+    const root = String(sessionId);
+    const wanted = ASK_KINDS.filter((kind) => !Array.isArray(kinds) || kinds.includes(kind));
+    const read = await Promise.all(wanted.map((kind) => readList(() => (kind === 'permission'
+      ? api.permissionList({ sessionId, cwd })
+      : api.questionList({ sessionId, cwd })))));
+    wanted.forEach((kind, i) => lists.push({ sessionId: root, kind, ...read[i] }));
+  }
+
+  // Sub-agents spawned while nobody watched: their place under a session that was read, a few at most and for
+  // a few seconds at most (the clocks stay held meanwhile).
+  const lookup = typeof ancestry === 'function' ? ancestry
+    : typeof isDescendant === 'function' ? async (owner, root) => (await isDescendant(owner, root)) === true
+      : null;
+  const roots = [...new Set(lists.map((list) => list.sessionId))];
+  const until = now() + lookupMs;
+  let lookups = 0;
+  const place = async (owner, root) => {
+    if (!lookup) return false;
+    const left = until - now();
+    if (lookups >= maxLookups || left <= 0) return null;
+    lookups += 1;
+    let timer = null;
+    const late = new Promise((done) => { timer = setTimer(() => done(null), left); });
+    try {
+      const answer = await Promise.race([Promise.resolve().then(() => lookup(owner, root)).catch(() => null), late]);
+      return answer === true ? true : answer === false ? false : null;
+    } finally {
+      clearTimer(timer);
+    }
+  };
+  const unplaced = new Map(); // owner → the sessions whose lists hold a request of it
+  for (const list of lists) {
+    if (list.state !== 'ok') continue;
+    for (const req of list.requests) {
+      const owner = requestOwner(req);
+      if (roots.includes(owner) || roots.some((root) => known(owner, root))) continue;
+      if (!unplaced.has(owner)) unplaced.set(owner, new Set());
+      unplaced.get(owner).add(list.sessionId);
+    }
+  }
+  for (const [owner, under] of unplaced) {
+    const unknown = [];
+    let placed = false;
+    for (const root of under) {
+      const answer = await place(owner, root);
+      if (answer === true) { placed = true; break; }
+      if (answer === null) unknown.push(root);
+    }
+    if (placed) continue;
+    for (const list of lists) {
+      if (list.state === 'ok' && unknown.includes(list.sessionId) && list.requests.some((req) => requestOwner(req) === owner)) list.state = 'unresolved';
+    }
+  }
+  const requests = new Map();
+  for (const list of lists) for (const req of list.requests) requests.set(askIdOf(req), req);
+  return { lists, requests: [...requests.values()], complete: lists.every((list) => list.state === 'ok') };
+}

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

@@ -6,7 +6,7 @@
 // instance for back-compat with shared bindings.
 // ─────────────────────────────────────────────────────────────────────────────
 
-import { api, supports, capabilities, onEvent } from './ocp-v2-ws.js';
+import { api, supports, capabilities, onEvent, sessionWaitsOnUser, onAsksChanged } from './ocp-v2-ws.js';
 import { getDefaultStore, agentForMode } from './ocp-v2-state.js';
 import { mountModelPicker } from './ocp-v2-modelpicker.js';
 import { mountVariantPicker } from './ocp-v2-variantpicker.js';
@@ -30,6 +30,7 @@ import {
 } from './ocp-v2-plan.js';
 import {
   trackOptimisticMessage, beginTurn, currentTurn, endTurn, settleFailedSend, TRANSCRIPT_SAFETY_POLL_MS,
+  createTurnClock, TURN_LIMIT_MS,
 } from './ocp-v2-send-logic.js';
 import { hydrateTranscript } from './ocp-v2-rehydrate.js';
 import { captureBinding, trackBinding, isBindingToken, searchOnBinding } from './ocp-v2-binding.js';
@@ -1512,7 +1513,7 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
   async function waitForAsyncTurn({ stopPolling, drainOnce, isPlanTurn, planTurn, turn, run }) {
     let done = false;
     let cleanup = null;
-    let timer = null;
+    let clock = null;
 
     await new Promise((resolve) => {
       // The composer was unmounted: nobody waits for the end of this turn any
@@ -1521,7 +1522,7 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
         if (done) return;
         done = true;
         _turnWatches.delete(abandon);
-        if (timer) clearTimeout(timer);
+        clock?.cancel();
         stopPolling();
         if (unsubInner) unsubInner();
         resolve();
@@ -1530,7 +1531,7 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
         if (done) return;
         done = true;
         _turnWatches.delete(abandon);
-        if (timer) clearTimeout(timer);
+        clock?.cancel();
         stopPolling();
         if (unsubInner) unsubInner();
         await drainOnce(true);
@@ -1544,11 +1545,17 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
       const unsubInner = store.subscribe((event, state) => {
         if ((event?.type === 'running:set' && !state.running) || !turn.isCurrent()) cleanup();
       });
-      timer = setTimeout(() => {
-        if (run.isCurrent()) store.pushError({ message: 'OpenCode turn timed out waiting for session.idle.' });
-        endTurn(store, run);
-        cleanup();
-      }, 30 * 60 * 1000);
+      // Working time only: the clock stops while the session waits on the user (a permission, a question).
+      clock = createTurnClock({
+        ms: TURN_LIMIT_MS,
+        paused: () => sessionWaitsOnUser(turn.sessionId),
+        subscribe: onAsksChanged,
+        onExpire: () => {
+          if (run.isCurrent()) store.pushError({ message: 'OpenCode turn timed out waiting for session.idle.' });
+          endTurn(store, run);
+          cleanup();
+        },
+      });
       _turnWatches.add(abandon);
       if (!store.getState().running) cleanup();
     });

package/neural-interface/public/shared/ocp-v2/ocp-v2-sessions-logic.js

@@ -287,6 +287,66 @@ export function createStoppedShares({ load = () => null, save = () => {}, max =
   };
 }
 
+// ── Tabs that are not on screen ─────────────────────────────────────────────
+// The panel shows one session; its other tabs go on running their turns in
+// OpenCode. What each of them does comes from OpenCode's own run events (every
+// session's reach every window) and from asking it (session:status) after a
+// reload or a reconnect. Their tray pills read it; the session on screen reads
+// its store.
+
+/** `{ sessionId, busy }` for an event about a session's run, else null. */
+export function sessionBusyFromEvent(eventType, ev) {
+  const sessionId = String(ev?.sessionID || ev?.sessionId || '');
+  if (!sessionId) return null;
+  if (eventType === 'session.status') {
+    const type = ev?.status?.type;
+    return { sessionId, busy: type === 'busy' || type === 'retry' };
+  }
+  if (eventType === 'session.idle' || eventType === 'session.error') return { sessionId, busy: false };
+  return null;
+}
+
+/** busy (true) / idle (false) from a session:status reply; null when it did not say. */
+export function sessionBusyFromStatus(res) {
+  const type = res?.data?.status?.type;
+  return typeof type === 'string' && type ? (type === 'busy' || type === 'retry') : null;
+}
+
+/**
+ * What an automation run's tab shows of its turn: 'working' while a turn runs,
+ * 'waiting' while the run waits on the user (a permission, a question: the
+ * dispatcher's awaiting_permission; or a turn that ended asking: an idle warm
+ * worker whose outcome, the result its turn reported, is needs_input), 'idle'
+ * between turns (a warm worker done with its task waits for a follow-up) and
+ * null once the run ended (its tab reads the session like any other). A run
+ * that reports no turn phase (a classic loop) works for as long as it runs:
+ * each iteration starts the next.
+ */
+export function automationTurnPhase(run) {
+  if (run?.status !== 'starting' && run?.status !== 'running') return null;
+  switch (run.turnState) {
+    case 'awaiting_permission': case 'needs_input': return 'waiting';
+    case 'idle': return (run.outcome || run.lastResult?.status) === 'needs_input' ? 'waiting' : 'idle';
+    case 'terminal': return 'idle';
+    default: return 'working';
+  }
+}
+
+/**
+ * A tab's tray pill: 'waiting' while its session waits on the user, 'working'
+ * while a turn of it runs, else 'idle'. A live automation run's own phase
+ * (`automation`, automationTurnPhase) decides: an idle warm worker rests,
+ * whatever its run (and the store of the session on screen, which follows the
+ * run) says; nobody else can start a turn in it meanwhile (canSend). Otherwise
+ * the session on screen reads its store (`running`) and another tab what
+ * OpenCode said of it (`busy`).
+ */
+export function tabPillState({ sessionId, activeSessionId, running = false, busy = false, automation = null } = {}) {
+  if (automation === 'working' || automation === 'waiting' || automation === 'idle') return automation;
+  const turn = sessionId && sessionId === activeSessionId ? !!running : !!busy;
+  return turn ? 'working' : 'idle';
+}
+
 // ── Deleting a message ──────────────────────────────────────────────────────
 
 /** The question before a message is deleted: which one, and that it is final. */