synabun 2.0.9 → 2.0.10

package/neural-interface/lib/assistant-brains/opencode.js

@@ -36,6 +36,12 @@ export function opencodeImageParts(images = []) {
 
 /** The route-gate plugin (opencode-route-gate.js) as a file URL the serve can load. */
 export const OPENCODE_ROUTE_GATE_PLUGIN = pathToFileURL(resolve(dirname(fileURLToPath(import.meta.url)), 'opencode-route-gate.js')).href;
+/**
+ * The same gate for OpenCode 2 (opencode2-route-gate/: OpenCode 2 loads a plugin
+ * folder from the config's `plugins` list). Both entries are written: OpenCode 1
+ * ignores `plugins`, OpenCode 2 skips the 1.x file (a warning in its log).
+ */
+export const OPENCODE2_ROUTE_GATE_PLUGIN = pathToFileURL(resolve(dirname(fileURLToPath(import.meta.url)), 'opencode2-route-gate')).href;
 
 /**
  * SynaBun's plan agent. OpenCode adds its own read-only reminder ("commands may
@@ -96,9 +102,15 @@ export function patchOpenCodeAssistantConfig(xdgRoot, { persona = '', role = 'as
   // read-only classifier decides on the whole line.
   config.agent.plan = { ...(config.agent.plan || {}), permission: { ...(config.agent.plan?.permission || {}), bash: 'ask' } };
   const plugins = (Array.isArray(config.plugin) ? config.plugin : []).filter((entry) => (Array.isArray(entry) ? entry[0] : entry) !== OPENCODE_ROUTE_GATE_PLUGIN);
+  const plugins2 = (Array.isArray(config.plugins) ? config.plugins : []).filter((entry) => (entry && typeof entry === 'object' ? entry.package : entry) !== OPENCODE2_ROUTE_GATE_PLUGIN);
   // `remote`: a WhatsApp session's serve — the plugin refuses a call it could not check (fail closed).
-  if (routeGate?.url && routeGate?.session && routeGate?.token) plugins.push([OPENCODE_ROUTE_GATE_PLUGIN, { url: routeGate.url, session: routeGate.session, token: routeGate.token, ...(routeGate.remote === true ? { remote: true } : {}) }]);
+  if (routeGate?.url && routeGate?.session && routeGate?.token) {
+    const options = { url: routeGate.url, session: routeGate.session, token: routeGate.token, ...(routeGate.remote === true ? { remote: true } : {}) };
+    plugins.push([OPENCODE_ROUTE_GATE_PLUGIN, options]);
+    plugins2.push({ package: OPENCODE2_ROUTE_GATE_PLUGIN, options });
+  }
   if (plugins.length) config.plugin = plugins; else delete config.plugin;
+  if (plugins2.length) config.plugins = plugins2; else delete config.plugins;
   writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
   // It carries this brain's grants (the desktop grant): readable by this user only.
   try { chmodSync(configPath, 0o600); } catch { /* a filesystem without modes */ }

package/neural-interface/lib/assistant-brains/opencode2-browser-policy/index.js

@@ -0,0 +1,44 @@
+// SynaBun — an Assistant task run's browser policy as an OpenCode 2 plugin.
+// The same policy as ../opencode-browser-policy.js (read that file for what it
+// does and why), for OpenCode 2's plugin API: a directory OpenCode loads from
+// the config's `plugins` entry, whose default export is `{ id, setup(context) }`
+// with a hook on `tool.execute.before`; a refusal is thrown. OpenCode 2 calls
+// the shell tool `shell` and the sub-agent tool `subagent`: the policy, written
+// for OpenCode 1's names, is asked with `bash` and `task`.
+
+// An absolute file URL: the policy loads from SynaBun's lib/ wherever OpenCode imports this file from.
+const POLICY_URL = new URL('../../browser-tool-policy.js', import.meta.url).href;
+const V1_NAMES = { shell: 'bash', subagent: 'task' };
+
+// OpenCode's own tools that run no command and fetch no page (OpenCode 1's names).
+const OWN_TOOLS = new Set([
+  'read', 'list', 'glob', 'grep', 'edit', 'write', 'patch', 'multiedit', 'apply_patch', 'todowrite', 'todoread',
+  'task', 'skill', 'lsp', 'codesearch', 'question', 'batch', 'invalid', 'plan_exit', 'plan_enter',
+]);
+
+export default {
+  id: 'synabun.browser-policy',
+  async setup(context) {
+    const options = context?.options || {};
+    let policy = null;
+    let loadError = null;
+    try { policy = await import(POLICY_URL); } catch (error) { loadError = error; }
+    const cwd = (typeof options.cwd === 'string' && options.cwd) || context?.location?.directory || process.cwd();
+    if (typeof policy?.browserToolDenial !== 'function') {
+      const why = loadError?.message || 'browserToolDenial is missing';
+      console.error(`[SynaBun] browser policy could not load from ${POLICY_URL} (${why}); refusing bash, webfetch, websearch and other servers' tools for this run`);
+      await context.tool.hook('execute.before', async (call) => {
+        const raw = String(call?.tool || '');
+        const tool = V1_NAMES[raw] || raw;
+        if (/^synabun_/i.test(tool) || OWN_TOOLS.has(tool.toLowerCase())) return;
+        throw new Error(`SynaBun browser policy: ${tool} was refused — SynaBun's browser policy could not load (${why}), so no command, web tool or other server's tool can be checked for a browser launch. SynaBun's own tools (SynaBun_*) and file tools still work. Stop and report this.`);
+      });
+      return;
+    }
+    await context.tool.hook('execute.before', async (call) => {
+      const raw = String(call?.tool || '');
+      const reason = policy.browserToolDenial(V1_NAMES[raw] || raw, call?.input || {}, { host: 'opencode', cwd });
+      if (reason) throw new Error(reason);
+    });
+  },
+};

package/neural-interface/lib/assistant-brains/opencode2-route-gate/index.js

@@ -0,0 +1,57 @@
+// SynaBun — the Assistant's route gate as an OpenCode 2 plugin.
+// The same gate as ../opencode-route-gate.js (read that file for what it does
+// and why), for OpenCode 2's plugin API: a directory OpenCode loads from the
+// config's `plugins` entry ({ package: <this folder as a file URL>, options }),
+// whose default export is `{ id, setup(context) }`; a hook on
+// `tool.execute.before` sees `{ tool, sessionID, input }` and refuses a call by
+// throwing (OpenCode records the message as that tool's error). OpenCode 2
+// calls two tools by other names than OpenCode 1 (`shell` for bash,
+// `subagent` for task): the gate is asked with OpenCode 1's names, which the
+// rest of SynaBun knows. OpenCode 1 never reads this folder (it loads the
+// `plugin` entry), and OpenCode 2 never loads the 1.x file.
+
+const MAX_INPUT_BYTES = 256 * 1024;
+const UNCHECKED = 'SynaBun could not check this call, so a WhatsApp session does not run it.';
+const V1_NAMES = { shell: 'bash', subagent: 'task' };
+
+/** { input, inputComplete }: the whole arguments when small enough to send, else their command/action. */
+function callArguments(args) {
+  if (!args || typeof args !== 'object' || Array.isArray(args)) return { input: {}, inputComplete: false };
+  let size = Infinity;
+  try { size = JSON.stringify(args).length; } catch {}
+  if (size <= MAX_INPUT_BYTES) return { input: args, inputComplete: true };
+  const subset = {};
+  for (const key of ['command', 'action']) {
+    if (typeof args[key] === 'string' && args[key].length <= 64 * 1024) subset[key] = args[key];
+  }
+  return { input: subset, inputComplete: false };
+}
+
+export default {
+  id: 'synabun.route-gate',
+  async setup(context) {
+    const { url, session, token, remote = false } = context?.options || {};
+    if (!url || !session || !token) return;
+    const post = (body) => fetch(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ session, token, host: 'opencode', ...body }),
+      signal: AbortSignal.timeout(5000),
+    });
+    // Never blocks loading; a lost hello only keeps the reactive fallback on.
+    post({ hello: true }).catch(() => {});
+    await context.tool.hook('execute.before', async (call) => {
+      const name = String(call?.tool || '');
+      let decision = null;
+      try {
+        const response = await post({ tool: V1_NAMES[name] || name, providerSessionId: call?.sessionID || null, ...callArguments(call?.input) });
+        decision = await response.json();
+      } catch {
+        if (remote === true) throw new Error(UNCHECKED);
+        return;
+      }
+      if (decision && decision.allow === false) throw new Error(String(decision.reason || 'SynaBun route gate: call agent_route first.'));
+      if (remote === true && !(decision && decision.allow === true)) throw new Error(UNCHECKED);
+    });
+  },
+};

package/neural-interface/lib/assistant-catalog.js

@@ -605,6 +605,8 @@ export function compactRow(row) {
  * @param {(change:{providers:string[], generatedAt:string})=>void} [deps.onChange] a build listed other
  *   models than the build before it (hiding has its own event and does not count)
  * @param {number} [deps.retryMs] how soon a build is redone while Claude Code or Codex gave no verified list
+ * @param {boolean} [deps.staleWhileRevalidate] an old build (past its lifetime) is given at once and built
+ *   again in the background, one build at a time; only a first build, invalidate() and force wait for one
  */
 export function createAssistantCatalog({
   fetchJson,
@@ -617,6 +619,7 @@ export function createAssistantCatalog({
   onChange = null,
   ttlMs = 30_000,
   retryMs = 5_000,
+  staleWhileRevalidate = false,
   now = Date.now,
   log = () => {},
 } = {}) {
@@ -753,7 +756,17 @@ export function createAssistantCatalog({
    */
   async function full({ force = false, deep = false } = {}) {
     if (!force && !deep && cache && now() - cache.at < cache.ttl) return cache.value;
+    // Past its lifetime: with staleWhileRevalidate the old build is the answer while the next one is made
+    // (never a build that began before an invalidate(): `current` says it was made for the lists as they are).
+    if (staleWhileRevalidate && !force && !deep && cache?.current) {
+      if (!inflight) startBuild({ deep: false }).catch((error) => log('catalog:background-error', error?.message || String(error)));
+      return cache.value;
+    }
     if (inflight) return inflight;
+    return startBuild({ deep });
+  }
+
+  function startBuild({ deep = false } = {}) {
     const started = epoch;
     inflight = build({ deep }).then((built) => {
       const { changedProviders, ...value } = built;
@@ -762,7 +775,7 @@ export function createAssistantCatalog({
       const degraded = ['claude-code', 'codex'].some((p) => value.sources[p] !== 'live');
       degradedBuilds = degraded ? degradedBuilds + 1 : 0;
       const ttl = degraded ? Math.min(ttlMs, retryMs * 2 ** (degradedBuilds - 1)) : ttlMs;
-      cache = { at: now(), value, ttl: started === epoch ? ttl : 0 };
+      cache = { at: now(), value, ttl: started === epoch ? ttl : 0, current: started === epoch };
       if (changedProviders.length && typeof onChange === 'function') {
         try { onChange({ providers: changedProviders, generatedAt: value.generatedAt }); } catch (error) { log('catalog:onchange-error', error?.message || String(error)); }
       }
@@ -872,6 +885,8 @@ export function createAssistantCatalog({
   }
 
   function invalidate() { cache = null; epoch += 1; }
+  /** The lists may have changed (a serve restarted, a CLI updated): the next read still answers with this build and makes the next one. */
+  function markStale() { if (cache) cache = { ...cache, at: -Infinity }; }
   /** A provider's own list changed: drop the copy and build the next one now (onChange reports the difference). */
   function refresh() {
     invalidate();
@@ -879,5 +894,5 @@ export function createAssistantCatalog({
     return pending ? pending.catch(() => null).then(() => full()) : full();
   }
 
-  return { get, full, peek, find, hiddenId, manageRows, manageSnapshot, brainInfo, invalidate, refresh };
+  return { get, full, peek, find, hiddenId, manageRows, manageSnapshot, brainInfo, invalidate, markStale, refresh };
 }

package/neural-interface/lib/assistant-dispatch.js

@@ -1894,6 +1894,9 @@ export function createAssistantDispatcher({
       liveState.turnTokens = null;
       entry.turns = [...(entry.turns || []), turn].slice(-50);
       entry.lastResult = parsed;
+      // The run's own descriptor (lib/native-loop-runtime.js) carries it too, for the surfaces that read that one
+      // (the OpenCode panel's pill): a warm worker whose turn ended asking waits on the user, it does not rest.
+      ctx.setOutcome?.(parsed.status || null);
       entry.lastText = text.slice(0, 20_000);
       // The turn has ended: its result is in. Idle time from here on is not work.
       pauseWork(entry, liveState);

package/neural-interface/lib/assistant-envelope.js

@@ -449,7 +449,7 @@ export function opencodeControlResponse(pending, response = {}) {
 export function createOpenCodeEnvelopeTranslator({ sessionId, emit, onTurnEnd = () => {}, onUsageEvent = () => {}, brain = {}, planTurn = () => false } = {}) {
   // costUsd is the session's running total: OpenCode reports cost per assistant
   // message, so costs are summed by message id (the runtime takes deltas).
-  const state = { sessionId, roles: new Map(), order: [], textParts: new Map(), reasoningParts: new Map(), tools: new Map(), started: false, announcedInit: false, lastText: '', costUsd: 0, costByMessage: new Map(), usage: null };
+  const state = { sessionId, roles: new Map(), order: [], textParts: new Map(), reasoningParts: new Map(), partKinds: new Map(), tools: new Map(), started: false, announcedInit: false, lastText: '', costUsd: 0, costByMessage: new Map(), usage: null };
   const event = (payload) => emit({ type: 'event', event: payload });
   const belongs = (ev) => {
     const sid = ev?.sessionID || ev?.sessionId || ev?.part?.sessionID || ev?.info?.sessionID || ev?.info?.id || ev?.session?.id || null;
@@ -485,12 +485,15 @@ export function createOpenCodeEnvelopeTranslator({ sessionId, emit, onTurnEnd =
   function handlePart(part = {}) {
     if (!part.messageID) return;
     if (state.roles.get(part.messageID) === 'user') return;
+    if ((part.type === 'text' || part.type === 'reasoning') && part.id) state.partKinds.set(part.id, { messageID: part.messageID, type: part.type });
     if (part.type === 'text' && typeof part.text === 'string') {
       let parts = state.textParts.get(part.messageID);
       if (!parts) { parts = new Map(); state.textParts.set(part.messageID, parts); }
       const key = part.id || `${parts.size}`;
       const prev = parts.get(key) || '';
       const next = part.text;
+      // An update made before the deltas that already arrived streams nothing again.
+      if (prev.length > next.length && prev.startsWith(next)) return;
       parts.set(key, next);
       const delta = next.startsWith(prev) ? next.slice(prev.length) : next;
       const shown = delta && planTurn() === true ? planTextDelta(`${part.messageID}:${key}`, delta) : delta;
@@ -500,6 +503,7 @@ export function createOpenCodeEnvelopeTranslator({ sessionId, emit, onTurnEnd =
     if (part.type === 'reasoning' && typeof part.text === 'string') {
       const key = `${part.messageID}:${part.id || 'r'}`;
       const prev = state.reasoningParts.get(key) || '';
+      if (prev.length > part.text.length && prev.startsWith(part.text)) return;
       state.reasoningParts.set(key, part.text);
       const delta = part.text.startsWith(prev) ? part.text.slice(prev.length) : part.text;
       if (delta) { startIfNeeded(); event(thinkingDelta(delta)); }
@@ -521,6 +525,19 @@ export function createOpenCodeEnvelopeTranslator({ sessionId, emit, onTurnEnd =
       }
     }
   }
+  // A part's text arrives as `message.part.delta` between the update that announces the part and the one that
+  // ends it (OpenCode 2 streams only this way, through lib/opencode2-translate.js): each delta extends that part,
+  // and streams as an update would. A delta for a part not announced yet is left to the update that ends it,
+  // which carries the whole text.
+  function handleDelta(ev = {}) {
+    if ((ev.field && ev.field !== 'text') || typeof ev.delta !== 'string' || !ev.delta) return;
+    const known = state.partKinds.get(ev.partID);
+    if (!known || (ev.messageID && ev.messageID !== known.messageID)) return;
+    const prev = known.type === 'text'
+      ? state.textParts.get(known.messageID)?.get(ev.partID) || ''
+      : state.reasoningParts.get(`${known.messageID}:${ev.partID}`) || '';
+    handlePart({ id: ev.partID, messageID: known.messageID, type: known.type, text: `${prev}${ev.delta}` });
+  }
   return {
     state,
     handle(eventType, ev = {}) {
@@ -546,6 +563,7 @@ export function createOpenCodeEnvelopeTranslator({ sessionId, emit, onTurnEnd =
         return true;
       }
       if (/^message[.:]part[.:]updated$/i.test(eventType)) { handlePart(ev.part || {}); return true; }
+      if (/^message[.:]part[.:]delta$/i.test(eventType)) { handleDelta(ev); return true; }
       if (/^session[.:]idle$/i.test(eventType)) {
         if (state.errored) { state.errored = false; state.started = false; return true; } // error already closed this turn
         const said = latestAssistantText();

package/neural-interface/lib/assistant-runtime.js

@@ -9,7 +9,7 @@
 // obligation nudges. All server dependencies are injected.
 
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
-import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { createClaudeBrain } from './assistant-brains/claude.js';
 import { createCodexBrain } from './assistant-brains/codex.js';
@@ -252,6 +252,8 @@ export function createAssistantRuntime({
   if (!dataDir) throw new Error('createAssistantRuntime requires dataDir');
   const settings = {
     idleDisposeMs: Math.max(60_000, Number(config.idleDisposeMinutes || 120) * 60_000),
+    // A draft (a session the panel opened, before its first prompt) with no socket attached goes after this.
+    draftIdleMs: Math.max(60_000, Number(config.draftIdleMinutes || 10) * 60_000),
     // A remote session on OpenCode waits this long for its gate plugin's hello before a turn (else refused).
     remoteGateHelloMs: Math.max(0, Number(config.remoteGateHelloMs ?? 5000)),
     // An OpenCode turn's end waits this long for the serve's stored messages (the usage meter's
@@ -295,11 +297,30 @@ export function createAssistantRuntime({
 
   // ── persistence ────────────────────────────────────────────────────────────
   function transcriptPath(id) { return resolve(dataDir, 'assistant', id, 'transcript.jsonl'); }
+  function transcriptHasEntries(id) { try { return statSync(transcriptPath(id)).size > 0; } catch { return false; } }
+  function transcriptHasPrompt(id) { try { return readFileSync(transcriptPath(id), 'utf8').includes('"synabun.user_prompt"'); } catch { return false; } }
+  /**
+   * A record from before `chatStartedAt`: its chat started when it ran a turn, adopted a provider
+   * conversation or holds a human prompt (the time is its best guess). One that never did is listed
+   * nowhere; with nothing in it at all (no transcript, no runs, not remote, no spend) it is dropped.
+   */
+  function settleLegacyRow(row) {
+    if (row.chatStartedAt) return 'started';
+    if (Number(row.turns) > 0 || row.providerSessionId || row.providerThreadId || transcriptHasPrompt(row.id)) {
+      row.chatStartedAt = row.lastActiveAt || row.updatedAt || row.createdAt || iso(now());
+      return 'started';
+    }
+    const holds = transcriptHasEntries(row.id) || (Array.isArray(row.dispatchRunIds) && row.dispatchRunIds.length > 0)
+      || !!row.remote || !!row.channel || Number(row.costUsd) > 0;
+    return holds ? 'unstarted' : 'empty';
+  }
   function loadIndex() {
     const rows = readJson(indexPath, []);
     if (!Array.isArray(rows)) return;
+    let dropped = 0;
     for (const row of rows) {
       if (!row?.id) continue;
+      if (settleLegacyRow(row) === 'empty') { dropped += 1; continue; }
       sessions.set(row.id, makeLive({ ...row, status: row.status === 'ended' ? 'ended' : 'idle', windowIds: [] }));
       // A remote session nobody registered again since the restart reads as read-only.
       if (row.remote) {
@@ -307,11 +328,14 @@ export function createAssistantRuntime({
         try { remotePolicy?.setSessionBrain?.(row.id, row.brain?.provider || null); } catch {}
       }
     }
+    // The index is written again without them (and with the started marks).
+    if (dropped) { log('assistant:index', `${dropped} session record(s) without a conversation dropped`); persist(); }
   }
   let persistTimer = null;
   function persist({ force = false } = {}) {
     const write = () => {
-      const rows = [...sessions.values()].map((live) => publicRecord(live.record, { withLive: false, persisted: true }))
+      // A draft is never written: it exists on disk only once its first prompt was sent (startChat).
+      const rows = [...sessions.values()].filter((live) => !live.draft).map((live) => publicRecord(live.record, { withLive: false, persisted: true }))
         .sort((a, b) => String(b.updatedAt || '').localeCompare(String(a.updatedAt || '')))
         .slice(0, settings.retention);
       try { writeJsonAtomic(indexPath, rows); } catch (error) { log('assistant:index-error', error?.message || String(error)); }
@@ -341,6 +365,9 @@ export function createAssistantRuntime({
   function makeLive(record) {
     return {
       record, brain: null, brainProvider: null, brainMeter: null, brainMeterProvider: null, turnTaskId: null, turnTasks: [], sockets: new Set(), buffer: [], running: false, pendingControls: new Map(), controlTimers: new Map(),
+      // A draft: opened by a panel and not chatted in yet. Kept in memory only, listed nowhere, and
+      // gone when it is closed or left without a socket (draftTimer); its first prompt stores it (startChat).
+      draft: false, draftTimer: null,
       mailbox: [], mailboxTimer: null, obligations: new Set(), rememberedThisTurn: false, disposeTimer: null, personaText: '',
       // The last human prompt and where it came from ('ui', 'whatsapp', 'api'): a route continuation
       // answers there (lastPromptOrigin; the transcript's after a restart).
@@ -909,7 +936,9 @@ export function createAssistantRuntime({
       out.testDensityExplicit = normalizeTestDensity(record.testDensity, null);
       // `rename`: this server keeps a rename on the record (userRenamed), so a panel writes it here.
       // `adminSandbox`: the global setting is served here (PUT /api/assistant/admin-sandbox).
-      out.features = { routing: !!router, computer: computerSupported(), testDensity: true, rename: true, adminSandbox: !!adminSandbox };
+      // `drafts`: a session is stored and listed from its first prompt on; `remove`: DELETE stops its work and purges it.
+      out.features = { routing: !!router, computer: computerSupported(), testDensity: true, rename: true, adminSandbox: !!adminSandbox, drafts: true, remove: true };
+      out.draft = live.draft === true;
       if (adminSandbox) { try { out.adminSandbox = adminSandbox.enabled() === true; } catch { out.adminSandbox = false; } }
       out.budget = sessionMoney(record.id);
       out.remoteLevel = policy ? effectiveLevel(policy, { untrusted: live.turnUntrusted === true, now: now() }) : null;
@@ -2302,6 +2331,8 @@ export function createAssistantRuntime({
       live.lastPromptOrigin = origin ? String(origin) : null;
       // A prompt from elsewhere (WhatsApp, the API) is news to the panel: it goes live too.
       const promptPacket = { type: 'event', event: { type: 'synabun.user_prompt', text: prompt, images: images.length, ...(origin && origin !== 'ui' ? { origin: String(origin) } : {}) } };
+      // The chat starts with its first human prompt: from here on the session is stored and listed.
+      startChat(live);
       appendTranscript(live.record.id, { at: iso(now()), packet: promptPacket });
       if (origin && origin !== 'ui') sendToSockets(live, promptPacket);
       if (live.brainProvider !== 'claude-code' && memory?.recallForPrompt) {
@@ -2672,8 +2703,56 @@ export function createAssistantRuntime({
   }
 
   // ── public API ─────────────────────────────────────────────────────────────
+  /**
+   * Every session list (REST, the socket's list_sessions, the catalog view) reads this: only sessions
+   * whose chat started. A draft, or a record nobody ever prompted, is in none of them. `activeRuns`:
+   * the workers it dispatched that still run (a removal stops them, and its question says so).
+   */
   function listSessions() {
-    return [...sessions.values()].map((live) => view(live)).sort((a, b) => String(b.updatedAt || '').localeCompare(String(a.updatedAt || '')));
+    const runs = new Map();
+    try {
+      for (const run of dispatcher?.list?.({ activeOnly: true, limit: 500 }) || []) {
+        if (run?.assistantSessionId) runs.set(run.assistantSessionId, (runs.get(run.assistantSessionId) || 0) + 1);
+      }
+    } catch {}
+    return [...sessions.values()].filter((live) => !live.draft && !!live.record.chatStartedAt)
+      .map((live) => ({ ...view(live), activeRuns: runs.get(live.record.id) || 0 }))
+      .sort((a, b) => String(b.updatedAt || '').localeCompare(String(a.updatedAt || '')));
+  }
+  /**
+   * The first human prompt (or a provider conversation adopted with `resume`) starts the chat: the
+   * record is marked, and a draft becomes a stored session (written now, listed from now on).
+   */
+  function startChat(live) {
+    if (live.record.chatStartedAt && !live.draft) return;
+    live.record.chatStartedAt ||= iso(now());
+    const wasDraft = live.draft;
+    live.draft = false;
+    if (live.draftTimer) { clearTimeout(live.draftTimer); live.draftTimer = null; }
+    persist({ force: true });
+    if (wasDraft) broadcast('assistant:session-created', live);
+  }
+  /** A draft with no socket attached is removed after settings.draftIdleMs (a page that went and never came back). */
+  function armDraftExpiry(live) {
+    if (live.draftTimer) { clearTimeout(live.draftTimer); live.draftTimer = null; }
+    if (!live.draft || live.sockets.size || shuttingDown || sessions.get(live.record.id) !== live) return;
+    live.draftTimer = setTimeout(() => {
+      live.draftTimer = null;
+      if (!live.draft || live.sockets.size || sessions.get(live.record.id) !== live || sessionBusy(live) || live.closing) return;
+      destroySession(live.record.id).catch((error) => log('assistant:draft-expiry', error?.message || String(error)));
+    }, settings.draftIdleMs);
+    live.draftTimer.unref?.();
+  }
+  /**
+   * Whether closing a session keeps its record (ended, reopenable) or removes it: a session that
+   * never held a conversation (no prompt, no turn, no runs, nothing in its transcript, not remote,
+   * no work under way) leaves nothing behind.
+   */
+  function holdsConversation(live) {
+    const r = live.record;
+    return !!r.chatStartedAt || Number(r.turns) > 0 || (Array.isArray(r.dispatchRunIds) && r.dispatchRunIds.length > 0)
+      || !!r.providerSessionId || !!r.providerThreadId || !!r.remote || !!r.channel || Number(r.costUsd) > 0
+      || sessionBusy(live) || !!workReserved(live) || transcriptHasEntries(r.id);
   }
   function getSession(id, { transcript = true, limit = 400 } = {}) {
     const live = sessions.get(id);
@@ -2698,7 +2777,7 @@ export function createAssistantRuntime({
     if (!row) throw Object.assign(new Error('Auto requires a signed-in subscription account.'), { code: 'ACCOUNT_NO_SUBSCRIPTION', status: 409 });
     return { ...brain, accountId: row.id };
   }
-  async function createSession({ brain = {}, label = null, cwd = null, windowId = null, fallback = false, channel = null } = {}, internal = {}) {
+  async function createSession({ brain = {}, label = null, cwd = null, windowId = null, fallback = false, channel = null, draft = false } = {}, internal = {}) {
     const id = `assistant-${randomUUID()}`;
     const requested = normalizeBrain({ ...brain, cwd: brain?.cwd || cwd || settings.defaultBrain.cwd || PACKAGE_ROOT }, settings.defaultBrain, { catalog: catalog?.peek?.() || null });
     const enabled = await enabledBrain(requested, { fallback: fallback === true, named: !!brain?.model });
@@ -2729,8 +2808,16 @@ export function createAssistantRuntime({
       live.creating = false;
       record.brain = clampedBrain(live, record.brain);
     }
-    persist({ force: true });
-    broadcast('assistant:session-created', live);
+    // `draft` (a panel's new session, POST /sessions): stored and announced by its first prompt
+    // (startChat); until then it lives here only, and is removed when it is closed or left (armDraftExpiry).
+    // A remote session is never one: its bridge sends the prompt it was made for.
+    if (draft === true && !remote && !record.channel) {
+      live.draft = true;
+      armDraftExpiry(live);
+    } else {
+      persist({ force: true });
+      broadcast('assistant:session-created', live);
+    }
     return enabled.fallback ? { ...view(live), fallback: enabled.fallback } : view(live);
   }
   function applyRouteMode(live, mode) {
@@ -2830,6 +2917,12 @@ export function createAssistantRuntime({
   }
   async function closeSession(id) {
     const live = requireLive(id);
+    // Never chatted in (a draft, a record nobody prompted): closing it leaves nothing behind.
+    if (!holdsConversation(live)) {
+      const gone = { ...view(live), status: 'destroyed', removed: true };
+      await destroySession(id);
+      return gone;
+    }
     const closed = await endSessionWork(live);
     try {
       await disposeBrain(live, 'closed');
@@ -2847,6 +2940,9 @@ export function createAssistantRuntime({
     if (!live) return false;
     const closed = await endSessionWork(live);
     try {
+      if (sessions.get(id) !== live) return false; // another removal got there first
+      if (live.draftTimer) { clearTimeout(live.draftTimer); live.draftTimer = null; }
+      if (live.disposeTimer) { clearTimeout(live.disposeTimer); live.disposeTimer = null; }
       await disposeBrain(live, 'closed');
       for (const ws of live.sockets) { try { ws.close(1000, 'session destroyed'); } catch {} }
       sessions.delete(id);
@@ -2863,6 +2959,24 @@ export function createAssistantRuntime({
     } finally { closed(); }
     return true;
   }
+  /**
+   * The Sessions menu's Remove (DELETE /api/assistant/sessions/:id): the session goes for good, in
+   * every host and list, and its work goes with it: the workers it dispatched that still run are
+   * stopped (no orphaned run is left), then the running turn and the brain (destroySession). Only
+   * the record, its transcript and its usage journal are removed: memories made from it (its
+   * assistant-threads record included) stay, and so do the dispatcher's records of its runs.
+   */
+  async function removeSession(id) {
+    const live = sessions.get(String(id || ''));
+    if (!live) return { removed: false, stoppedRuns: [] };
+    let stoppedRuns = [];
+    try {
+      const result = await dispatcher?.killAll?.({ assistantSessionId: live.record.id, reason: 'session_removed' });
+      stoppedRuns = Array.isArray(result?.stopped) ? result.stopped : [];
+    } catch (error) { log('assistant:remove', `${live.record.id}: stopping its runs failed (${error?.message || error})`); }
+    const removed = await destroySession(live.record.id);
+    return { removed, stoppedRuns };
+  }
   /**
    * MCP terminal pin → assistant session id. Claude brains pin the session id
    * itself; the OpenCode brain pins `assistant-oc-<24>` (its isolated serve).
@@ -3127,6 +3241,7 @@ export function createAssistantRuntime({
     ws.on('close', () => {
       live.sockets.delete(ws);
       scheduleDispose(live);
+      armDraftExpiry(live);
     });
     if (held) {
       while (live.closing) await live.closing;
@@ -3137,6 +3252,7 @@ export function createAssistantRuntime({
       if (ws.readyState !== 1) return; // gone while it waited
     }
     if (live.disposeTimer) { clearTimeout(live.disposeTimer); live.disposeTimer = null; }
+    if (live.draftTimer) { clearTimeout(live.draftTimer); live.draftTimer = null; }
     live.sockets.add(ws);
     live.record.status = live.record.status === 'ended' ? 'idle' : live.record.status;
     const engine = live.brain ? { type: 'engine', engine: live.brainProvider === 'claude-code' ? 'sdk' : live.brainProvider, brain: live.brainProvider, sdkVersion } : { type: 'engine', engine: 'assistant', brain: live.record.brain.provider, sdkVersion };
@@ -3268,6 +3384,8 @@ export function createAssistantRuntime({
         if (msg.providerSessionId) {
           const moved = msg.providerSessionId !== live.record.providerSessionId;
           live.record.providerSessionId = msg.providerSessionId;
+          // A provider conversation adopted (/resume <id>): the session holds a chat now.
+          startChat(live);
           // Another provider session: the meter's baseline was the old one's.
           if (moved) resetMeterIdentity(live, msg.providerSessionId);
           // …and so was the frozen user-context digest.
@@ -3728,6 +3846,7 @@ export function createAssistantRuntime({
     for (const live of sessions.values()) {
       if (live.mailboxTimer) clearTimeout(live.mailboxTimer);
       if (live.disposeTimer) clearTimeout(live.disposeTimer);
+      if (live.draftTimer) clearTimeout(live.draftTimer);
       if (live.workTimer) clearTimeout(live.workTimer);
       await disposeBrain(live, 'shutdown').catch(() => {});
       live.record.status = 'idle';
@@ -3754,7 +3873,7 @@ export function createAssistantRuntime({
   broadcastSync = (message) => { try { originalBroadcast(message); } catch {} if (message?.type === 'assistant:permission-request' || message?.type === 'assistant:permission-resolved') onPermissionBroadcast(message); };
 
   return {
-    handleWebSocket, listSessions, getSession, createSession, updateSession, closeSession, destroySession,
+    handleWebSocket, listSessions, getSession, createSession, updateSession, closeSession, destroySession, removeSession,
     resolveTerminal, accountInUse, ownsIsolatedServe, noteDispatch, subscribe, shutdown,
     observeBroadcast: onPermissionBroadcast,
     testDensityFor, routerSession, routerSend, routerEvent, routerMailbox, routerContinue, routerSinks, routerRouted, routerRouteFailed, routerComputerApproved, gateCheck, isPlanning, isPlanReadOnly,

package/neural-interface/lib/claude-model-catalog.js

@@ -43,7 +43,39 @@ const DISCOVERY_TIMEOUT_MS = 15000;
 const CACHE_TTL_MS = 10 * 60 * 1000;
 
 let _cache = { at: 0, key: '', models: [] };
-let _inflight = null;
+const _inflight = new Map(); // cache key → the discovery running for it
+// Where the last verified list is kept across restarts ({ read(), write(entry) },
+// lib/launch-cache.js createSnapshotStore): a start answers with it at once and
+// asks the CLI again in the background.
+let _store = null;
+let _storeRead = false;
+
+export function setClaudeModelStore(store) {
+  _store = store && typeof store.read === 'function' && typeof store.write === 'function' ? store : null;
+  _storeRead = false;
+}
+
+// The list the last run verified, for this very binary and account: given at once
+// after a restart (as an old answer, so the first read asks the CLI again).
+function adoptStoredModels(key) {
+  if (_storeRead || !_store) return;
+  _storeRead = true;
+  if (_cache.models.length) return;
+  try {
+    const saved = _store.read();
+    const models = saved?.key === key && Array.isArray(saved.models)
+      ? saved.models.filter(m => m && typeof m === 'object' && typeof m.id === 'string' && m.id)
+      : [];
+    if (models.length) _cache = { at: 0, key, models };
+  } catch { /* nothing kept: the first read asks the CLI */ }
+}
+
+// What the list depends on: the binary (an update changes it, binaryIdentity) and
+// the account it was read under (another account can be entitled to other models).
+function cacheKeyOf(bin, account) {
+  const who = String(account || '');
+  return who ? `${binaryIdentity(bin)}#${who}` : binaryIdentity(bin);
+}
 
 // Who else keeps a copy of this list (the Assistant's model catalog). Told when a
 // discovery returns a list that differs from the one before it, so a copy is
@@ -286,37 +318,55 @@ export function queryClaudeCliModels(claudeBin, { cwd, timeoutMs = DISCOVERY_TIM
 }
 
 // Cached discovery. `source` lets the UI distinguish a verified list from the
-// baked-in fallback. Cache is keyed on the binary's identity, so switching the
-// configured CLI (Settings > Terminal) or updating it re-discovers.
-export async function discoverClaudeModels(claudeBin, { force = false, cwd, query = queryClaudeCliModels } = {}) {
+// baked-in fallback. Cache is keyed on the binary's identity (and the account
+// the list was read under, `account`), so switching the configured CLI
+// (Settings > Terminal), updating it or signing in to another account
+// re-discovers. A list that is merely old is still given at once, and the CLI is
+// asked again in the background (one discovery at a time): only a first read, a
+// changed key or `force` waits for the CLI.
+export async function discoverClaudeModels(claudeBin, { force = false, cwd, query = queryClaudeCliModels, account = '' } = {}) {
   const bin = String(claudeBin || '');
-  const key = binaryIdentity(bin);
-  const fresh = _cache.models.length
-    && _cache.key === key
-    && Date.now() - _cache.at < CACHE_TTL_MS;
-  if (!force && fresh) return { source: 'cache', models: _cache.models };
-  if (_inflight) return _inflight;
-
-  _inflight = (async () => {
+  const key = cacheKeyOf(bin, account);
+  adoptStoredModels(key);
+  const known = _cache.models.length && _cache.key === key;
+  if (!force && known) {
+    if (Date.now() - _cache.at >= CACHE_TTL_MS) discover(bin, key, cwd, query).catch(() => {});
+    return { source: 'cache', models: _cache.models };
+  }
+  return discover(bin, key, cwd, query);
+}
+
+function discover(bin, key, cwd, query) {
+  if (_inflight.has(key)) return _inflight.get(key);
+  const job = (async () => {
     try {
       const raw = await query(bin, { cwd });
       const models = normalizeClaudeModels(raw);
       if (models.length) {
         const changed = claudeModelsSignature(models) !== claudeModelsSignature(_cache.models);
         _cache = { at: Date.now(), key, models };
+        try { _store?.write({ key, at: _cache.at, models }); } catch { /* kept in memory still */ }
         if (changed) notifyModelsChanged(models);
         return { source: 'cli', models };
       }
       return { source: 'fallback', models: [...CLAUDE_FALLBACK_MODELS] };
     } finally {
-      _inflight = null;
+      if (_inflight.get(key) === job) _inflight.delete(key);
     }
   })();
-  return _inflight;
+  _inflight.set(key, job);
+  return job;
+}
+
+/** The kept list is due again: the next read still answers with it and asks the CLI in the background. */
+export function markClaudeModelsStale() {
+  _cache = { ..._cache, at: 0 };
 }
 
 export function clearClaudeModelCache() {
   _cache = { at: 0, key: '', models: [] };
+  _inflight.clear();
+  _storeRead = !!_store;
   _skewCache = { key: null, result: undefined };
   _skewInflight.clear();
 }