synabun 2.0.9 → 2.1.0

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';
@@ -1005,7 +1006,7 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
           if (s.running) { store.pushError({ message: 'Wait for the current turn to finish before compacting.' }); return; }
           const at = captureBinding(store);
           const res = await api.compact({
-            sessionId: at.sessionId, cwd: at.cwd || undefined, mcpProfile: at.mcpProfile || undefined, model: at.model || undefined,
+            sessionId: at.sessionId, cwd: at.cwd || undefined, tools: at.tools || undefined,
           });
           // A failure of the session the panel has left is not this one's banner.
           if (at.isCurrent() && (res?.error || res?.ok === false)) store.pushError({ message: res?.error || 'Compact failed' });
@@ -1091,7 +1092,7 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
       variant: turn.variant || undefined,
       parts: parts.length ? parts : undefined,
       cwd: turn.cwd || undefined,
-      mcpProfile: turn.mcpProfile || undefined,
+      tools: turn.tools || undefined,
     }), outcome);
   }
 
@@ -1129,7 +1130,7 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
       agent: turn.agent || undefined,
       model: turn.model || undefined,
       cwd: turn.cwd || undefined,
-      mcpProfile: turn.mcpProfile || undefined,
+      tools: turn.tools || undefined,
     }));
   }
 
@@ -1466,7 +1467,7 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
         mode,
         variant: turn.variant || undefined,
         cwd: options.cwd || turn.cwd || undefined,
-        mcpProfile: turn.mcpProfile || undefined,
+        tools: turn.tools || undefined,
         // A person's own message (the greeting engine keeps when they were last here), and the
         // greeting this session opened with, told to the model once.
         human: true,
@@ -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-session-actions.js

@@ -207,59 +207,6 @@ export async function forkSession(store, api, messageId) {
   return at.isCurrent() ? { ok: true, session: out.data } : { ok: true, session: out.data, moved: true };
 }
 
-export async function deleteMessage(store, api, messageId) {
-  const at = captureBinding(store);
-  if (!at.sessionId || !messageId) return { ok: false, error: 'No message.' };
-  if (store.getState().running) return { ok: false, error: 'Stop the running turn before you delete a message.' };
-  const out = await call(() => api.messageDelete({ ...targetOf(at), messageID: messageId }), 'Delete failed');
-  if (!at.isCurrent()) return MOVED;
-  if (!out.ok) return out;
-  // message.removed does this too; doing it here keeps the panel right if that event is lost.
-  store.removeMessage(messageId);
-  return { ok: true };
-}
-
-/**
- * Publish the transcript. `confirm()` must resolve true first, every time:
- * the caller asks in the panel (ocp-v2-confirm-logic.js), this function never
- * shares without it. `stopped` is the panel's createStoppedShares().
- */
-export async function shareSession(store, api, confirm, { stopped = null } = {}) {
-  // The session the question is about, captured before the question is asked:
-  // a confirm answered after the panel moved publishes nothing.
-  const at = captureBinding(store);
-  if (!at.sessionId) return { ok: false, error: 'No session.' };
-  let agreed = false;
-  try { agreed = (await confirm()) === true; } catch { agreed = false; }
-  if (!agreed) return { ok: false, cancelled: true };
-  if (!at.isCurrent()) return { ok: false, cancelled: true, moved: true };
-  const out = await call(() => api.sessionShare(targetOf(at)), 'Share failed');
-  // Shared again, for that session whatever is on screen by now: a link the
-  // panel had stopped before is a share once more.
-  if (out.ok) stopped?.resume(at.sessionId);
-  if (!at.isCurrent()) return MOVED;
-  if (!out.ok) return out;
-  applySession(store, at, out.data);
-  const url = out.data?.share?.url || '';
-  return url ? { ok: true, url } : { ok: false, error: 'OpenCode did not return a share link.' };
-}
-
-export async function unshareSession(store, api, { stopped = null } = {}) {
-  const at = captureBinding(store);
-  if (!at.sessionId) return { ok: false, error: 'No session.' };
-  const out = await call(() => api.sessionUnshare(targetOf(at)), 'Could not stop sharing');
-  // Sharing stopped, for that session whatever is on screen by now. OpenCode
-  // keeps the link in the session row and reports it again with every later
-  // read (createStoppedShares): the panel remembers which one it stopped.
-  if (out.ok) stopped?.stop(at.sessionId, at.sessionInfo?.share?.url || out.data?.share?.url || '');
-  if (!at.isCurrent()) return MOVED;
-  if (!out.ok) return out;
-  // The answer is read from that row too, so it can still carry the link.
-  if (out.data) applySession(store, at, { ...out.data, share: undefined });
-  else store.setSessionInfo({ share: undefined });
-  return { ok: true };
-}
-
 /**
  * The transcript of the session on screen as a download: `{ ok, filename,
  * json }`. Session id, metadata and file name are the ones captured before the
@@ -294,7 +241,7 @@ export async function loadSelectedSession(store, api, sessionId, info, apply) {
 }
 
 // ── Navigation ──────────────────────────────────────────────────────────────
-// "New session", a project change and a new worktree all end by binding the
+// "New session" and a project change both end by binding the
 // panel to a session they create. They own the panel only as long as nobody
 // navigated meanwhile: `nav` is the binding captured at the user's gesture.
 
@@ -353,27 +300,27 @@ export async function renameSession(store, api, title, { binding } = {}) {
 }
 
 /**
- * Switch the MCP profile of the session the panel is on. The answer belongs to
+ * Switch the tool list of the session the panel is on. The answer belongs to
  * the session it was asked for: `save(sessionId, profile)` records it under
  * that session's key whatever is on screen by then, and the store takes it
  * only while it is still on that binding (`applied`). Throws when the server
  * refuses (as before). Resolves `{ sessionId, profile, applied }`, or null
  * when there is no session.
  */
-export async function setSessionMcpProfile(store, api, profile, { save } = {}) {
+export async function setSessionTools(store, api, tools, { save } = {}) {
   const at = captureBinding(store);
   if (!at.sessionId) return null;
-  const result = await api.mcpProfileSet(at.sessionId, profile);
+  const result = await api.toolsSet(at.sessionId, tools);
   if (result?.error || result?.ok === false || Number(result?.status || 200) >= 400) {
-    const error = new Error(result?.error || result?.data?.error || `Could not switch MCP profile (${result?.status || 'unknown error'})`);
+    const error = new Error(result?.error || result?.data?.error || `Could not switch tools (${result?.status || 'unknown error'})`);
     error.stale = !at.isCurrent();
     throw error;
   }
-  const effective = result?.data?.profile || profile;
+  const effective = result?.data?.tools || tools;
   if (typeof save === 'function') save(at.sessionId, effective);
   const applied = at.isCurrent();
-  if (applied) store.setMcpProfile(effective);
-  return { sessionId: at.sessionId, profile: effective, applied };
+  if (applied) store.setTools(effective);
+  return { sessionId: at.sessionId, tools: effective, applied };
 }
 
 /**