synabun 1.3.0 → 2.0.0

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

@@ -0,0 +1,357 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// OpenCode V2 — re-read what events alone cannot restore (no DOM)
+// After a page load, a tab switch or a socket reconnect the panel has missed
+// every event since it last looked. This asks OpenCode for what the transcript
+// does not hold: is the session running, which permission requests and
+// questions are still waiting for an answer, and the todo list.
+//
+// Three rules keep a recovery from doing harm:
+//   • A recovered request is shown only when it belongs to this panel's session
+//     tree: the session itself, or a descendant whose ancestry was verified
+//     (verifyDescendant) and that has no panel of its own. A serve can host
+//     other root sessions; "nobody else has it open" proves nothing.
+//   • A snapshot never replaces something newer. Each slice of the store has a
+//     revision (store.getRevisions()); a read that a live event overtook is
+//     thrown away and asked again.
+//   • An answer is for the binding it was asked under. The store counts how
+//     often it moved to another session (`binding`); an answer that comes back
+//     after a move is dropped, also when the panel is on that session again.
+// ─────────────────────────────────────────────────────────────────────────────
+
+import { replyFailed } from './ocp-v2-caps.js';
+import { captureBinding } from './ocp-v2-binding.js';
+
+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 [];
+};
+
+export const requestOwner = (req) => String(req?.sessionID || req?.sessionId || '');
+
+export const ANCESTRY_MAX_DEPTH = 12;
+
+/**
+ * Is `sessionId` a descendant of `ancestorId`? Walks child → parent.
+ *   parentOf      Map(child → parent) learned from session.created/updated
+ *   roots         Set of sessions known to have no parent (optional cache)
+ *   fetchParent   async (id) → the parent id, '' for a root session; a throw or
+ *                 anything that is not a string means "unknown"
+ * Unknown is false: ancestry that cannot be established is not ancestry.
+ */
+export async function verifyDescendant(sessionId, ancestorId, { parentOf, roots, fetchParent } = {}) {
+  if (!sessionId || !ancestorId || sessionId === ancestorId) return false;
+  const seen = new Set([sessionId]);
+  let cursor = sessionId;
+  for (let depth = 0; depth < ANCESTRY_MAX_DEPTH; depth++) {
+    let parent = parentOf?.get(cursor);
+    if (parent === undefined) {
+      if (roots?.has(cursor) || typeof fetchParent !== 'function') return false;
+      try { parent = await fetchParent(cursor); } catch { return false; }
+      if (typeof parent !== 'string') return false;
+      if (parent) parentOf?.set(cursor, parent);
+      else roots?.add(cursor);
+    }
+    if (!parent) return false;
+    if (parent === ancestorId) return true;
+    if (seen.has(parent)) return false;
+    seen.add(parent);
+    cursor = parent;
+  }
+  return false;
+}
+
+/**
+ * The same walk without asking anyone: true only when every link from
+ * `sessionId` up to `ancestorId` is already in `parentOf`. For code that cannot
+ * wait (rendering); verifyDescendant records the links it had to fetch, so a
+ * request that was verified once passes here too.
+ */
+export function knownDescendant(sessionId, ancestorId, parentOf) {
+  if (!sessionId || !ancestorId || sessionId === ancestorId || !parentOf) return false;
+  const seen = new Set([sessionId]);
+  let cursor = sessionId;
+  for (let depth = 0; depth < ANCESTRY_MAX_DEPTH; depth++) {
+    const parent = parentOf.get(cursor);
+    if (!parent || seen.has(parent)) return false;
+    if (parent === ancestorId) return true;
+    seen.add(parent);
+    cursor = parent;
+  }
+  return false;
+}
+
+/**
+ * The requests a panel bound to `sessionId` may show: its own, and those of a
+ * session already known to descend from it. A request of any other session is
+ * left out, whatever put it in the queue.
+ */
+export function requestsVisibleIn(list, sessionId, isKnownDescendant) {
+  return (Array.isArray(list) ? list : []).filter((req) => {
+    const owner = requestOwner(req);
+    if (!owner || !sessionId) return false;
+    if (owner === sessionId) return true;
+    try { return typeof isKnownDescendant === 'function' && isKnownDescendant(owner, sessionId) === true; } catch { return false; }
+  });
+}
+
+/**
+ * Does `req` belong to the panel bound to `sessionId`? Its own requests do; a
+ * sub-agent's do when `isDescendant(owner, sessionId)` confirms the ancestry.
+ * A request that names no session cannot be placed and belongs to nobody.
+ */
+export async function requestBelongsTo(req, sessionId, isDescendant) {
+  const owner = requestOwner(req);
+  if (!owner || !sessionId) return false;
+  if (owner === sessionId) return true;
+  if (typeof isDescendant !== 'function') return false;
+  try { return (await isDescendant(owner, sessionId)) === true; } catch { return false; }
+}
+
+/**
+ * Requests that belong in this panel: the session's own, plus those of a
+ * verified descendant that has no panel of its own (a sub-agent whose child
+ * panel is not open). `hasPanel(sessionId)` says whether some panel is bound.
+ */
+export async function requestsForPanel(list, sessionId, { hasPanel = () => false, isDescendant } = {}) {
+  const out = [];
+  for (const req of Array.isArray(list) ? list : []) {
+    const owner = requestOwner(req);
+    if (!owner) continue;
+    if (owner !== sessionId && hasPanel(owner)) continue;
+    if (await requestBelongsTo(req, sessionId, isDescendant)) out.push(req);
+  }
+  return out;
+}
+
+export const REHYDRATE_ATTEMPTS = 3;
+
+// `() => boolean`: is the store still on `sessionId`, under the binding it has
+// right now? False once the panel moved away, and stays false if it comes back.
+// The same token every other asynchronous flow of the panel captures
+// (ocp-v2-binding.js), pinned to the session the recovery was asked for.
+function bindingCheck(store, sessionId, isCurrent) {
+  return captureBinding(store, { sessionId, isCurrent }).isCurrent;
+}
+
+/**
+ * Bring `store` in line with the server for `sessionId`. Each read is
+ * independent: one that fails or that the server does not support leaves that
+ * part of the store alone, and so does one that live events kept overtaking.
+ * `isCurrent()` (optional) lets the caller veto late answers, e.g. for a panel
+ * that was closed meanwhile. Resolves what it applied, for the caller's log.
+ */
+export async function rehydrateSessionState(store, api, { sessionId, cwd, hasPanel, isDescendant, isCurrent } = {}) {
+  const applied = { status: false, permissions: false, questions: false, todos: false };
+  if (!sessionId) return applied;
+  const stillBound = bindingCheck(store, sessionId, isCurrent);
+  const revisionOf = (slice) => (typeof store.getRevisions === 'function' ? store.getRevisions()[slice] : 0);
+
+  // read → (prepare) → apply, unless the slice changed while the read was out.
+  async function sync(slice, read, prepare, apply) {
+    for (let attempt = 0; attempt < REHYDRATE_ATTEMPTS; attempt++) {
+      const before = revisionOf(slice);
+      let res;
+      try { res = await read(); } catch (err) { res = { ok: false, error: err?.message || String(err) }; }
+      if (!stillBound() || replyFailed(res)) return;
+      const value = await prepare(res);
+      if (value === undefined || !stillBound()) return;
+      if (revisionOf(slice) !== before) continue;   // a live event is newer than this snapshot
+      apply(value);
+      applied[slice] = true;
+      return;
+    }
+  }
+
+  await Promise.all([
+    sync('status',
+      () => api.sessionStatus({ sessionId, cwd }),
+      (res) => (res.data?.status?.type ? res.data.status : undefined),
+      (current) => {
+        store.setSessionStatus(current);
+        // OpenCode's own answer beats the guess made from unfinished messages: a
+        // turn that died mid-reply leaves one behind and is not running.
+        const busy = current.type === 'busy' || current.type === 'retry';
+        if (store.getState().running !== busy) store.setRunning(busy);
+      }),
+    sync('permissions',
+      () => api.permissionList({ sessionId, cwd }),
+      (res) => requestsForPanel(listOf(res), sessionId, { hasPanel, isDescendant }),
+      // The server's own list: what is not in it is no longer open (`listed`).
+      (mine) => store.setPendingPermissions(mine, { listed: true })),
+    sync('questions',
+      () => api.questionList({ sessionId, cwd }),
+      (res) => (typeof res.data === 'string' ? undefined : requestsForPanel(listOf(res), sessionId, { hasPanel, isDescendant })),
+      (mine) => store.setPendingQuestions(mine)),
+    sync('todos',
+      () => (api.sessionTodo ? api.sessionTodo({ sessionId, cwd }) : { ok: false }),
+      (res) => (Array.isArray(res.data) ? res.data : undefined),
+      (todos) => store.setTodos(todos)),
+  ]);
+  return applied;
+}
+
+/** True when a transcript snapshot shows a turn still in flight. */
+export function transcriptInFlight(items) {
+  for (const item of Array.isArray(items) ? items : []) {
+    const info = item?.info;
+    if (info?.role === 'assistant') {
+      const completed = info?.time?.completed;
+      if (completed == null || completed === 0) return true;
+    }
+    for (const part of (item?.parts || [])) {
+      const status = part?.state?.status || part?.status;
+      if (status === 'running' || status === 'pending') return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Read the transcript of `sessionId` and apply it, unless the panel moved on
+ * while the read was out. The one way a transcript snapshot enters a store.
+ *   • The answer is dropped when the store is on another session, or left this
+ *     one and came back (`superseded`): it is another binding's answer.
+ *   • `syncRunning` (default on) also sets the run state from the snapshot
+ *     (an unfinished assistant message = running), but only when nothing live
+ *     touched the run state since the read began. A snapshot that says
+ *     "finished" never ends a turn an event has just reported running.
+ * `beforeApply(items)` runs right before the snapshot goes into the store (the
+ * composer drops its optimistic bubble there), and only when it does.
+ * Resolves `{ applied, superseded, error, items }`.
+ */
+export async function hydrateTranscript(store, api, { sessionId, isCurrent, syncRunning = true, beforeApply } = {}) {
+  const out = { applied: false, superseded: false, error: '', items: [] };
+  if (!sessionId) { out.error = 'No session.'; return out; }
+  const current = bindingCheck(store, sessionId, isCurrent);
+  if (!current()) { out.superseded = true; return out; }
+  const statusBefore = typeof store.getRevisions === 'function' ? store.getRevisions().status : 0;
+  let list;
+  try { list = await api.sessionMessages(sessionId); } catch (err) { list = { ok: false, error: err?.message || String(err) }; }
+  if (!current()) { out.superseded = true; return out; }
+  if (replyFailed(list)) {
+    out.error = (typeof list?.error === 'string' && list.error) || (typeof list?.data?.error === 'string' && list.data.error) || 'Session messages unavailable';
+    return out;
+  }
+  const items = Array.isArray(list?.data) ? list.data : [];
+  if (typeof beforeApply === 'function') {
+    try { beforeApply(items); } catch (err) { console.warn('[ocp-v2-rehydrate] beforeApply failed', err); }
+  }
+  store.hydrateMessages(items);
+  out.applied = true;
+  out.items = items;
+  if (syncRunning) {
+    // The guess from the transcript, unless an event already said otherwise;
+    // session.status is the authority where the server has it.
+    const untouched = typeof store.getRevisions !== 'function' || store.getRevisions().status === statusBefore;
+    const inFlight = transcriptInFlight(items);
+    if (untouched && store.getState().running !== inFlight) store.setRunning(inFlight);
+  }
+  return out;
+}
+
+/**
+ * Everything a panel shows for its session, re-read from the server:
+ * session info, transcript, run state, approvals, todos. Used by the primary
+ * panel (boot, tab switch, auto-heal, after a compaction) and by a sub-agent
+ * panel (when it is created, and again after the socket came back, because
+ * whatever happened during the outage reached nobody).
+ * `isCurrent()` is asked after every answer, and so is the store's binding: a
+ * panel that was destroyed or bound to another session meanwhile takes
+ * nothing, and `moved` says so.
+ *   refreshInfo   read the session itself first (session:get)
+ *   requireInfo   stop when that read fails: the session is gone (`unavailable`)
+ */
+export async function rehydratePanelSession(store, api, {
+  sessionId, hasPanel, isDescendant, isCurrent, refreshInfo = true, requireInfo = false,
+} = {}) {
+  const out = { info: false, transcript: false, live: null, moved: false, unavailable: false, error: '' };
+  if (!sessionId) return out;
+  const current = bindingCheck(store, sessionId, isCurrent);
+  const left = () => { out.moved = true; return out; };
+  if (!current()) return left();
+
+  if (refreshInfo) {
+    let res;
+    try { res = await api.sessionGet(sessionId); } catch (err) { res = { ok: false, error: err?.message || String(err) }; }
+    if (!current()) return left();
+    if (!replyFailed(res) && res.data) { store.setSession(sessionId, res.data); out.info = true; }
+    else if (requireInfo) {
+      out.unavailable = true;
+      out.error = (typeof res?.error === 'string' && res.error) || `Session ${String(sessionId).slice(0, 8)} is unavailable`;
+      return out;
+    }
+    // Otherwise the transcript may still answer.
+  }
+  const transcript = await hydrateTranscript(store, api, { sessionId, isCurrent: current });
+  if (transcript.superseded) return left();
+  out.transcript = transcript.applied;
+  if (!transcript.applied) out.error = transcript.error;
+  const s = store.getState();
+  out.live = await rehydrateSessionState(store, api, {
+    sessionId,
+    cwd: s.cwd || s.sessionInfo?.directory || undefined,
+    hasPanel,
+    isDescendant,
+    isCurrent: current,
+  });
+  if (!current()) out.moved = true;
+  return out;
+}
+
+/**
+ * Calls `onReconnect()` once per reconnect: after the socket reopened and the
+ * server said what it understands (`capabilities()`), or `graceMs` after the
+ * reopen for a server that never says (it predates the list). The first open
+ * is not a reconnect.
+ */
+export function createReconnectNotifier(onReconnect, { graceMs = 1500, setTimer = setTimeout, clearTimer = clearTimeout } = {}) {
+  let opened = false;
+  let pending = false;
+  let timer = null;
+  const fire = () => {
+    if (timer) { clearTimer(timer); timer = null; }
+    if (!pending) return;
+    pending = false;
+    try { onReconnect(); } catch (err) { console.warn('[ocp-v2-rehydrate] reconnect listener failed', err); }
+  };
+  return {
+    opened() {
+      if (!opened) { opened = true; return; }
+      pending = true;
+      if (timer) clearTimer(timer);
+      timer = setTimer(fire, graceMs);
+    },
+    capabilities() { fire(); },
+    closed() {
+      pending = false;
+      if (timer) { clearTimer(timer); timer = null; }
+    },
+  };
+}
+
+/**
+ * The errors a recovery may clear when it is done: those that were on screen
+ * when it began, on the binding it began on. `begin` it before the recovery
+ * waits on anything; `clear()` afterwards removes exactly those errors, and
+ * only while the panel is still on that binding. An error that appeared while
+ * the recovery was out (a send or a rename that failed meanwhile) is newer
+ * than what was recovered from and stays. A notice is never one of them. When
+ * the user moved to another session meanwhile, that session's errors are its
+ * own and stay; when the recovery itself bound a new session, the store
+ * already started it clean.
+ * Returns whether anything was this recovery's to clear.
+ */
+export function recoveredErrorSweep(store) {
+  const at = captureBinding(store);
+  const ids = (store.getState().errors || []).filter((err) => !err?.notice).map((err) => err.id);
+  return {
+    clear() {
+      if (!at.isCurrent()) return false;
+      store.clearErrors(ids);
+      return true;
+    },
+  };
+}

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

@@ -0,0 +1,189 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// OpenCode V2 — what the transcript shows (no DOM; the renderer builds nodes
+// from these answers and node:test checks them directly)
+// ─────────────────────────────────────────────────────────────────────────────
+
+import { describeError } from './ocp-v2-events.js';
+
+// Bookkeeping parts with nothing to read: step boundaries and the snapshot
+// hash OpenCode records for undo.
+const HIDDEN_PART_TYPES = new Set(['step-start', 'step-finish', 'snapshot']);
+
+/** True for a part the transcript shows. */
+export function isVisiblePart(part) {
+  if (!part || HIDDEN_PART_TYPES.has(part.type)) return false;
+  // `ignored` text never reached the model; `synthetic` text was written by
+  // OpenCode on the user's behalf (file contents, "the user ran this tool").
+  if (part.type === 'text' && (part.ignored || part.synthetic)) return false;
+  return true;
+}
+
+/** A message's parts in display order, hidden ones removed. */
+export function visibleParts(msg) {
+  const parts = msg?.parts instanceof Map ? [...msg.parts.values()] : (Array.isArray(msg?.parts) ? msg.parts : []);
+  return parts
+    .filter(isVisiblePart)
+    .sort((a, b) => (a.index ?? Number.POSITIVE_INFINITY) - (b.index ?? Number.POSITIVE_INFINITY));
+}
+
+// Captures everything visible about a part, so the reconciler can tell an
+// up-to-date DOM node from a stale one without rebuilding it.
+export function partSignature(part) {
+  if (!part) return '';
+  const t = part.type || '';
+  if (t === 'text' || t === 'reasoning') {
+    const text = String(part.text || '');
+    const tail = text.length > 80 ? text.slice(-80) : text;
+    return `${t}:${text.length}:${tail}:${part?.time?.end ? '1' : '0'}`;
+  }
+  if (t === 'tool') {
+    const state = part.state || {};
+    const status = state.status || part.status || '';
+    const input = state.input ?? part.input;
+    const output = state.output ?? part.output;
+    const error = state.error ?? part.error;
+    const inp = input ? JSON.stringify(input).length : 0;
+    const out = output == null
+      ? 0
+      : typeof output === 'string'
+        ? output.length
+        : JSON.stringify(output).length;
+    const meta = state.metadata ? JSON.stringify(state.metadata).length : 0;
+    return `tool:${status}:${part.tool || part.name || ''}:${inp}:${out}:${error ? 'e' : ''}:${state.title || ''}:${meta}:${state.time?.end || ''}`;
+  }
+  if (t === 'file') return `file:${part.url || part.path || ''}:${String(part.text || '').length}`;
+  if (t === 'retry') return `retry:${part.attempt || 0}:${describeError(part.error).message.length}`;
+  if (t === 'compaction') return `compaction:${part.auto ? 'a' : 'm'}:${part.overflow ? 'o' : ''}`;
+  if (t === 'patch') return `patch:${part.hash || ''}:${(part.files || []).length}`;
+  return `${t}:${part.id || ''}`;
+}
+
+/** The error row under an assistant message, or null when it ended cleanly. */
+export function messageErrorView(info) {
+  if (!info || info.role !== 'assistant' || !info.error) return null;
+  const d = describeError(info.error);
+  const view = { kind: d.kind, name: d.name, text: d.message, action: null };
+  if (d.statusCode) view.text = `${d.message} (HTTP ${d.statusCode})`;
+  if (d.kind === 'overflow') view.action = 'compact';
+  else if (d.kind === 'auth') view.action = 'settings';
+  return view;
+}
+
+/** The banner shown while OpenCode waits to retry a failed provider call. */
+export function retryBannerView(status) {
+  if (!status || status.type !== 'retry') return null;
+  const attempt = Number(status.attempt) || 0;
+  const action = status.action && typeof status.action === 'object' ? status.action : null;
+  const link = typeof action?.link === 'string' && /^https?:\/\//i.test(action.link) ? action.link : '';
+  return {
+    title: attempt ? `Retrying (attempt ${attempt})` : 'Retrying',
+    message: String(action?.message || status.message || '').trim(),
+    nextAt: Number(status.next) > 0 ? Number(status.next) : 0,
+    actionLabel: link ? String(action.label || action.title || 'Open').trim() : '',
+    actionLink: link,
+  };
+}
+
+/** One line for a retry part left in the transcript. */
+export function retryPartText(part) {
+  const attempt = Number(part?.attempt) || 0;
+  const reason = describeError(part?.error).message;
+  return `Retry${attempt ? ` ${attempt}` : ''}: ${reason}`;
+}
+
+/** The divider label for a compaction marker. */
+export function compactionLabel(part) {
+  if (part?.overflow) return 'Context compacted automatically: the conversation outgrew the model';
+  return part?.auto ? 'Context compacted automatically' : 'Context compacted';
+}
+
+/** Short lines for the part types that are neither prose nor a tool call. */
+export function inlinePartText(part) {
+  switch (part?.type) {
+    case 'subtask': {
+      const agent = String(part.agent || '').trim();
+      const what = String(part.description || part.prompt || '').trim().split(/\r?\n/, 1)[0];
+      return `Subtask${agent ? ` · ${agent}` : ''}${what ? `: ${what}` : ''}`;
+    }
+    case 'agent':
+      return `@${String(part.name || 'agent')}`;
+    case 'patch': {
+      const files = Array.isArray(part.files) ? part.files.filter(Boolean) : [];
+      if (!files.length) return 'Files changed';
+      const names = files.slice(0, 3).map((f) => String(f).split(/[\\/]/).filter(Boolean).pop() || String(f));
+      const more = files.length > names.length ? ` +${files.length - names.length} more` : '';
+      return `Changed ${files.length} file${files.length === 1 ? '' : 's'}: ${names.join(', ')}${more}`;
+    }
+    default:
+      return '';
+  }
+}
+
+/** The last lines of reasoning that is still streaming. */
+export function reasoningPreview(text, maxChars = 240) {
+  const clean = String(text || '').replace(/\s+/g, ' ').trim();
+  return clean.length > maxChars ? `…${clean.slice(-maxChars)}` : clean;
+}
+
+/** The header status word, most urgent first. */
+export function headerStatus(s) {
+  if (s.healing) return { cls: 'healing', text: 'healing' };
+  const permissions = (s.pendingPermissions || []).length || (s.pendingPermission ? 1 : 0);
+  if (permissions) {
+    return { cls: 'awaiting', text: permissions > 1 ? `awaiting ${permissions} permissions` : 'awaiting permission' };
+  }
+  if ((s.pendingQuestions || []).length) return { cls: 'awaiting', text: 'awaiting answer' };
+  if (s.compacting) return { cls: 'running', text: 'compacting' };
+  if (s.sessionStatus?.type === 'retry') return { cls: 'reconnecting', text: 'retrying' };
+  if (s.running) return { cls: 'running', text: 'running' };
+  if (s.serverStatus === 'reconnecting') return { cls: 'reconnecting', text: 'reconnecting' };
+  if (s.serverStatus === 'error' || (s.errors || []).length) return { cls: 'error', text: 'error' };
+  if (s.serverStatus === 'offline') return { cls: '', text: 'offline' };
+  return { cls: 'ready', text: 'idle' };
+}
+
+/**
+ * Text the user typed into a card that is rebuilt (on every state event, and
+ * when the panel comes back to the session): kept by request id for as long
+ * as the request is open. Nothing is evicted to keep the store small: a draft
+ * goes only when its request does.
+ *   set(id, text, { sessionId })  the draft; `sessionId` is the session the
+ *                                 request belongs to. `set(id, '')` forgets.
+ *   clear(id)                     the request was answered, by whoever
+ *                                 (this card, another window, auto-accept).
+ *   forgetSession(sessionId)      the session is gone, and its requests with it.
+ *   settle(sessionId, openIds)    the server's own list of the session's open
+ *                                 requests: a draft of that session whose
+ *                                 request is not in it was answered while
+ *                                 nobody was listening (a socket outage).
+ */
+export function createCardDrafts() {
+  const drafts = new Map();         // request id → { text, sessionId }
+  return {
+    get: (id) => drafts.get(String(id || ''))?.text || '',
+    set(id, text, { sessionId = '' } = {}) {
+      const key = String(id || '');
+      if (!key) return;
+      const value = String(text || '');
+      if (!value) { drafts.delete(key); return; }
+      drafts.set(key, { text: value, sessionId: String(sessionId || drafts.get(key)?.sessionId || '') });
+    },
+    clear(id) { return drafts.delete(String(id || '')); },
+    forgetSession(sessionId) {
+      const sid = String(sessionId || '');
+      if (!sid) return 0;
+      let gone = 0;
+      for (const [key, draft] of [...drafts]) { if (draft.sessionId === sid) { drafts.delete(key); gone += 1; } }
+      return gone;
+    },
+    settle(sessionId, openIds) {
+      const sid = String(sessionId || '');
+      if (!sid) return 0;
+      const open = new Set((Array.isArray(openIds) ? openIds : []).map((id) => String(id || '')));
+      let gone = 0;
+      for (const [key, draft] of [...drafts]) { if (draft.sessionId === sid && !open.has(key)) { drafts.delete(key); gone += 1; } }
+      return gone;
+    },
+    size: () => drafts.size,
+  };
+}