synabun 2.0.9 → 2.1.0

package/neural-interface/lib/opencode-v2-ws-requests.js

@@ -9,11 +9,11 @@
 // deps (all supplied by handleOpencodeV2Ws):
 //   send(data)                     write one JSON message to this socket
 //   shared                         the shared-serve client (opencode-v2-client).
-//                                  SDK calls added for the panel are under
+//                                  Client calls added for the panel are under
 //                                  `client.extra.<group>.<method>`
 //   bound(sessionId)               the serve currently hosting the session's
 //                                  turn, else the shared client; never spawns
-//   turn(sessionId, mcpProfile)    the session's dedicated serve; may spawn it
+//   turn(sessionId, tools)    the session's dedicated serve; may spawn it
 //   proxy(method, path, body, timeoutMs, baseUrl)   raw HTTP to a serve
 //   baseUrlFor(sessionId)          base URL of the serve hosting the session
 //   directoryQuery(cwd)            `?directory=…` or ''
@@ -31,18 +31,15 @@
 // a type only when that type is listed.
 // ─────────────────────────────────────────────────────────────────────────────
 
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { compactOrSummarize, lastModelOf } from './opencode-v2-client.js';
-
-export { lastModelOf };
+import { OPENCODE_SESSION_TABLES } from './opencode-db-schema.js';
+import { opencodeMcpServerEntry } from './opencode-config.js';
+import { storedToolList } from './tool-lists.js';
 
 // Types answered by the switch in server.js.
 export const OPENCODE_V2_WS_INLINE_TYPES = Object.freeze([
   'init', 'identify',
   'session:list', 'session:create', 'session:get', 'session:update', 'session:delete', 'session:messages',
-  'mcp:profile:get', 'mcp:profile:set',
+  'mcp:tools:get', 'mcp:tools:set',
   'message:send', 'message:abort',
   'question:list', 'question:reject',
 ]);
@@ -70,6 +67,10 @@ const SESSION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
  */
 export function canonicalizeOpencodeV2Message(msg) {
   if (!msg || typeof msg !== 'object') return failure(400, 'malformed request');
+  if (msg.tools !== undefined && msg.tools !== null) {
+    try { msg.tools = storedToolList({ tools: msg.tools }); }
+    catch (error) { return failure(400, error.message, { code: error.code, problems: error.problems }); }
+  }
   const raw = msg.sessionId;
   if (raw === undefined || raw === null) {
     msg.sessionId = undefined;
@@ -133,18 +134,11 @@ function modelOf(value) {
   return providerID && modelID ? { providerID, modelID } : null;
 }
 
-// session.compact with the session.summarize fallback (see compactOrSummarize).
+// OpenCode compacts a session on the model it runs on.
 async function compactSession(msg, deps) {
-  const client = await deps.turn(sessionKeyOf(msg), msg.mcpProfile);
-  try {
-    return await compactOrSummarize(client, {
-      sessionID: sessionIdOf(msg), directory: directoryOf(msg), model: modelOf(msg.model),
-    });
-  } catch (err) {
-    // "Pick a model first" is an answer for the user, not a server error.
-    if (err?.status === 400) return failure(400, err.message);
-    throw err;
-  }
+  const client = await deps.turn(sessionKeyOf(msg), msg.tools);
+  const r = await client.session.compact({ sessionID: sessionIdOf(msg), directory: directoryOf(msg) });
+  return { status: r?.status, data: r?.data };
 }
 
 const PERMISSION_REPLIES = new Set(['once', 'always', 'reject']);
@@ -229,45 +223,18 @@ async function sessionStatus(msg, deps) {
   return { status: r.status, data: { status: statusForSession(r.data, sessionIdOf(msg)) } };
 }
 
-// What the relay forwards to panels. OpenCode 1.18 mirrors every bus event as
-// a `sync` envelope ({ type: 'sync', syncEvent }); the panel acts on the bus
-// event itself, so the mirror is dropped. Everything else passes.
-export function shouldRelayOpencodeV2Message(data) {
-  return !(data?.type === 'event' && data.eventType === 'sync');
-}
-
-// Body of `POST /mcp` for a server SynaBun describes as { command, args, env }
-// or { url, headers }. OpenCode takes McpLocalConfig (`type: 'local'`, the
-// command as one array, `environment`) or McpRemoteConfig; `type: 'stdio'` with
-// a string command is answered 400.
+// An MCP server as OpenCode 2 takes it (`mcp.servers.<name>`, lib/opencode-config.js), from what SynaBun
+// describes as { command, args, env } or { url, headers }: type local with the command as one array and its
+// `environment`, or type remote. Every word goes through as it is: an argument may be empty or carry spaces on
+// purpose, and what is registered must be what was typed.
 export function buildOpencodeRuntimeMcpConfig(config = {}) {
-  if (config.type === 'local' || config.type === 'remote') return { ...config };
-  if (typeof config.url === 'string' && config.url) {
-    return {
-      type: 'remote',
-      url: config.url,
-      ...(config.headers && typeof config.headers === 'object' ? { headers: config.headers } : {}),
-      enabled: config.enabled !== false,
-    };
-  }
-  // Every word goes through as it is: an argument may be empty or carry
-  // spaces on purpose, and what is registered must be what was typed.
-  const head = Array.isArray(config.command) ? config.command : [config.command];
-  const command = [...head, ...(Array.isArray(config.args) ? config.args : [])]
-    .filter((part) => typeof part === 'string');
-  const environment = config.environment || config.env;
-  return {
-    type: 'local',
-    command,
-    ...(environment && typeof environment === 'object' ? { environment } : {}),
-    enabled: config.enabled !== false,
-  };
+  return opencodeMcpServerEntry(config);
 }
 
 // ── Session list (read straight from OpenCode's SQLite) ─────────────────────
-// The SDK's session.list only answers for the serve's own project; the panel
-// lists every project, so server.js reads the `session` table. The query and
-// the row mapping live here so they can be tested against a real table.
+// The client's session.list only answers for the serve's own project; the panel
+// lists every project, so server.js reads OpenCode's `session_v2` table. The
+// query and the row mapping live here so they can be tested against a real table.
 export const SESSION_LIST_MAX = 500;
 
 /**
@@ -278,6 +245,7 @@ export const SESSION_LIST_MAX = 500;
  * Un-archiving writes time_archived = 0, so "live" is NULL or 0.
  */
 export function buildSessionListQuery(options = {}) {
+  const tables = OPENCODE_SESSION_TABLES;
   const where = [];
   const params = [];
   where.push(options.archived === true
@@ -293,10 +261,10 @@ export function buildSessionListQuery(options = {}) {
   const requested = Number(options.limit);
   const limit = Number.isInteger(requested) && requested > 0 ? Math.min(requested, SESSION_LIST_MAX) : null;
   const sql = `
-    SELECT s.id, s.title, s.directory, s.slug, s.project_id, s.parent_id, s.share_url,
+    SELECT s.id, s.title, s.directory, s.slug, s.project_id, s.parent_id,
            s.time_created, s.time_updated, s.time_archived,
-           (SELECT COUNT(*) FROM message m WHERE m.session_id = s.id) AS message_count
-    FROM session s
+           ${tables.messageCount} AS message_count
+    FROM ${tables.session} s
     WHERE ${where.join(' AND ')}
     ORDER BY s.time_updated DESC${limit ? '\n    LIMIT ?' : ''}
   `;
@@ -317,20 +285,19 @@ export function mapSessionListRow(row) {
     time: { created: epochMs(row.time_created), updated: epochMs(row.time_updated) },
   };
   if (row.parent_id) out.parentID = row.parent_id;
-  if (row.share_url) out.share = { url: row.share_url };
   const archived = epochMs(row.time_archived);
   if (archived) out.time.archived = archived;
   return out;
 }
 
-// ── Session lifecycle (revert, fork, share, children, delete message) ───────
+// ── Session lifecycle (revert, fork, children) ──────────────────────────────
 
 const messageIdOf = (msg) => (typeof msg?.messageID === 'string' && msg.messageID.trim()
   ? msg.messageID.trim()
   : (typeof msg?.messageId === 'string' ? msg.messageId.trim() : ''));
 
-// Reverting or deleting under a running turn would pull the transcript out
-// from under the model.
+// Reverting under a running turn would pull the transcript out from under the
+// model.
 function refuseWhileRunning(msg, deps, what) {
   return deps.isTurnActive?.(sessionIdOf(msg))
     ? failure(409, `Stop the running turn before you ${what}.`)
@@ -368,48 +335,6 @@ async function sessionChildren(msg, deps) {
   return { status: r.status, data: Array.isArray(r.data) ? r.data : [] };
 }
 
-async function messageDelete(msg, deps) {
-  const busy = refuseWhileRunning(msg, deps, 'delete a message');
-  if (busy) return busy;
-  const messageID = messageIdOf(msg);
-  if (!messageID) return failure(400, 'messageID is required');
-  const r = await deps.bound(sessionKeyOf(msg)).extra.session.deleteMessage({
-    sessionID: sessionIdOf(msg), messageID, directory: directoryOf(msg),
-  });
-  return { status: r.status, data: r.data };
-}
-
-// OpenCode's `share` setting: manual (default), auto, or disabled.
-export function sharePolicyOf(config) {
-  const value = config?.share;
-  if (value === 'disabled' || value === 'auto' || value === 'manual') return value;
-  return 'manual';
-}
-
-async function readSharePolicy(msg, deps) {
-  const r = await deps.shared.extra.config.get({ directory: directoryOf(msg) });
-  return sharePolicyOf(r.data);
-}
-
-async function sessionSharePolicy(msg, deps) {
-  return { status: 200, data: { share: await readSharePolicy(msg, deps) } };
-}
-
-// Publishes the transcript at a public opencode URL. The panel confirms with
-// the user every time; the server refuses when the config forbids sharing.
-async function sessionShare(msg, deps) {
-  if (await readSharePolicy(msg, deps) === 'disabled') {
-    return failure(403, 'Sharing is disabled in the OpenCode config.');
-  }
-  const r = await deps.shared.extra.session.share({ sessionID: sessionIdOf(msg), directory: directoryOf(msg) });
-  return { status: r.status, data: r.data };
-}
-
-async function sessionUnshare(msg, deps) {
-  const r = await deps.shared.extra.session.unshare({ sessionID: sessionIdOf(msg), directory: directoryOf(msg) });
-  return { status: r.status, data: r.data };
-}
-
 // ── Composer: slash commands, shell, file search ────────────────────────────
 
 /** What the slash menu needs of a Command; the template can be 16 KB and is not sent. */
@@ -438,10 +363,12 @@ function modelRef(value) {
 
 // Run something that occupies the session like a prompt does: on the
 // session's dedicated serve, inside the same turn bookkeeping as message:send.
-async function withTurn(msg, deps, run) {
+async function withTurn(msg, deps, run, { needsMcp = true } = {}) {
   const scope = deps.turnScope(sessionIdOf(msg));
   try {
-    const client = await deps.turn(sessionKeyOf(msg), msg.mcpProfile);
+    const client = await deps.turn(sessionKeyOf(msg), msg.tools);
+    if (needsMcp) await deps.waitForTools?.(client, sessionIdOf(msg), directoryOf(msg), scope.signal);
+    if (scope.signal?.aborted) throw Object.assign(new Error('OpenCode turn stopped before sending'), { name: 'AbortError', status: 499 });
     const r = await run(client, scope.signal ? { signal: scope.signal } : undefined);
     return { status: r.status, data: r.data };
   } finally {
@@ -479,7 +406,7 @@ async function sessionShell(msg, deps) {
     agent: typeof msg.agent === 'string' && msg.agent ? msg.agent : 'build',
     model: modelOf(msg.model) || undefined,
     directory: directoryOf(msg),
-  }, options));
+  }, options), { needsMcp: false });
 }
 
 export const FIND_FILES_LIMIT = 50;
@@ -647,55 +574,6 @@ async function vcsDiff(msg, deps) {
   return { status: r.status, data: capFileDiffs(r.data) };
 }
 
-// ── Worktrees ───────────────────────────────────────────────────────────────
-
-// worktree.create answers a Worktree { name, branch, directory }; worktree.list
-// answers the directories only (confirmed on 1.18.34).
-function worktreeRow(w) {
-  const directory = typeof w === 'string' ? w : (w && typeof w.directory === 'string' ? w.directory : '');
-  if (!directory) return null;
-  const leaf = directory.split(/[\\/]/).filter(Boolean).pop() || directory;
-  return {
-    name: typeof w === 'object' && w.name ? String(w.name) : leaf,
-    branch: typeof w === 'object' && typeof w.branch === 'string' ? w.branch : '',
-    directory,
-  };
-}
-
-async function worktreeList(msg, deps) {
-  if (!directoryOf(msg)) return failure(400, 'cwd is required');
-  const r = await deps.shared.extra.worktree.list({ directory: directoryOf(msg) });
-  return { status: r.status, data: (Array.isArray(r.data) ? r.data : []).map(worktreeRow).filter(Boolean) };
-}
-
-async function worktreeCreate(msg, deps) {
-  if (!directoryOf(msg)) return failure(400, 'cwd is required');
-  const name = typeof msg.name === 'string' ? msg.name.trim() : '';
-  if (name && !/^[A-Za-z0-9][\w.-]{0,63}$/.test(name)) {
-    return failure(400, 'A worktree name may use letters, digits, ".", "_" and "-".');
-  }
-  const r = await deps.shared.extra.worktree.create({
-    directory: directoryOf(msg),
-    worktreeCreateInput: name ? { name } : {},
-  });
-  const row = worktreeRow(r.data);
-  if (!row) return failure(502, 'OpenCode did not return the new worktree.');
-  return { status: r.status, data: row };
-}
-
-// Removing deletes a directory, so only one OpenCode itself lists as a worktree
-// of this project is accepted.
-async function worktreeRemove(msg, deps) {
-  const cwd = directoryOf(msg);
-  const target = typeof msg.directory === 'string' ? msg.directory.trim() : '';
-  if (!cwd || !target) return failure(400, 'cwd and directory are required');
-  const listed = await deps.shared.extra.worktree.list({ directory: cwd });
-  const known = (Array.isArray(listed.data) ? listed.data : []).some((w) => worktreeRow(w)?.directory === target);
-  if (!known) return failure(404, 'That directory is not a worktree of this project.');
-  const r = await deps.shared.extra.worktree.remove({ directory: cwd, worktreeRemoveInput: { directory: target } });
-  return { status: r.status, data: true };
-}
-
 // ── Environment: MCP servers, LSP, formatters ───────────────────────────────
 
 // SynaBun's own MCP entry is pinned by the runtime (profile, terminal identity,
@@ -740,19 +618,6 @@ async function mcpSwitch(msg, deps, connect) {
   return { status: r.status, data: after ? mcpRows(after.data) : [] };
 }
 
-// OAuth for a remote MCP server: OpenCode opens the browser itself and waits
-// for the callback, so the request can take minutes.
-async function mcpAuthenticate(msg, deps) {
-  const name = mcpNameOf(msg);
-  if (!name) return failure(400, 'MCP server name is required');
-  if (isManagedMcpName(name)) return failure(403, `${name} is managed by SynaBun.`);
-  const path = `/mcp/${encodeURIComponent(name)}/auth/authenticate${deps.directoryQuery(msg.cwd)}`;
-  const r = await deps.proxy('POST', path, {}, 5 * 60 * 1000, deps.baseUrlFor(sessionKeyOf(msg)));
-  if (r.status >= 400 || typeof r.data === 'string') {
-    return failure(r.status >= 400 ? r.status : 502, proxyErrorText(r.data, 'Authentication did not complete'));
-  }
-  return { status: r.status, data: r.data };
-}
 
 const MCP_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/;
 const stringMap = (value) => value && typeof value === 'object' && !Array.isArray(value)
@@ -860,10 +725,6 @@ const HANDLERS = {
   'session:unrevert': { session: true, mutates: true, run: sessionUnrevert },
   'session:fork': { session: true, mutates: true, run: sessionFork },
   'session:children': { session: true, run: sessionChildren },
-  'session:share': { session: true, mutates: true, run: sessionShare },
-  'session:unshare': { session: true, mutates: true, run: sessionUnshare },
-  'session:share:policy': { run: sessionSharePolicy },
-  'message:delete': { session: true, mutates: true, run: messageDelete },
   'command:list': { run: commandList },
   'command:run': { session: true, mutates: true, run: commandRun },
   'session:shell': { session: true, mutates: true, run: sessionShell },
@@ -876,13 +737,9 @@ const HANDLERS = {
   'vcs:get': { run: vcsGet },
   'vcs:status': { run: vcsStatus },
   'vcs:diff': { run: vcsDiff },
-  'worktree:list': { run: worktreeList },
-  'worktree:create': { run: worktreeCreate },
-  'worktree:remove': { run: worktreeRemove },
   'mcp:status': { run: mcpStatus },
   'mcp:connect': { session: true, mutates: true, run: (msg, deps) => mcpSwitch(msg, deps, true) },
   'mcp:disconnect': { session: true, mutates: true, run: (msg, deps) => mcpSwitch(msg, deps, false) },
-  'mcp:authenticate': { session: true, mutates: true, run: mcpAuthenticate },
   'mcp:add': { session: true, mutates: true, run: mcpAdd },
   'env:status': { run: envStatus },
 };
@@ -898,29 +755,12 @@ export const OPENCODE_V2_WS_MODULE_TYPES = Object.freeze(Object.keys(HANDLERS));
 // Behaviours of an existing type that an older server lacks. Listed next to
 // the types so the panel can gate on them the same way; never a request type.
 export const OPENCODE_V2_WS_FEATURES = Object.freeze([
+  'feature:tool-lists',
   'feature:permission-reply-message',   // permission:reply forwards a rejection reason
-  'feature:compact-summarize',          // session:compact falls back to session.summarize
   'feature:session-list-filters',       // session:list takes search / archived / roots / limit, rows carry parentID
   'feature:mcp-add-persist',            // mcp:add with persist:true saves the server without starting it a second time
 ]);
 
-// The version of the @opencode-ai/sdk this server talks to OpenCode through,
-// for the panel's Versions rows ('' when its package.json cannot be read).
-let _sdkVersion;
-export function opencodeSdkVersion() {
-  if (_sdkVersion !== undefined) return _sdkVersion;
-  _sdkVersion = '';
-  try {
-    let dir = dirname(fileURLToPath(import.meta.resolve('@opencode-ai/sdk/v2')));
-    for (let i = 0; i < 6 && dir !== dirname(dir); i += 1, dir = dirname(dir)) {
-      let pkg = null;
-      try { pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')); } catch { /* not the package root */ }
-      if (pkg?.name === '@opencode-ai/sdk') { _sdkVersion = String(pkg.version || ''); break; }
-    }
-  } catch { /* stays '' */ }
-  return _sdkVersion;
-}
-
 // Everything this server answers, for the panel's feature gating.
 export function opencodeV2WsCapabilities() {
   return [...OPENCODE_V2_WS_INLINE_TYPES, ...OPENCODE_V2_WS_MODULE_TYPES, ...OPENCODE_V2_WS_FEATURES];

package/neural-interface/lib/opencode-worker-activity.js

@@ -0,0 +1,229 @@
+/**
+ * What the Assistant page sees of a dispatched OpenCode worker: its tool calls.
+ *
+ * Claude and Codex workers reach the page through the sync socket
+ * (sidepanel:provider-event); an OpenCode worker's events stay on its own
+ * isolated `opencode serve`, which only its V2 panel reads, so server.js keeps
+ * them off the socket. The Assistant's run stage and agents tray
+ * (public/shared/assistant/asst-scenes.js activityOf) only need to know which
+ * call the worker is on, so this relay forwards a copy of each tool call's
+ * start (its part turns `running`) and finish (`completed` or `error`), once
+ * each, in the real event shape: { provider: 'opencode', runId, eventType:
+ * 'message.part.updated', event: { sessionID, part: { type: 'tool', tool,
+ * callID, state: { status, input } } } }. Nothing else goes: no text,
+ * reasoning or file parts, no output, title, metadata or error text, and of
+ * the call's input only the short fields a step line names ("Editing
+ * router.js", "Running npm test", "Opening localhost:3344"), made safe
+ * (public/shared/assistant/asst-redact.js: credentials masked, a command's
+ * heredoc and inline file bodies omitted, an address without its query) and
+ * then clipped; a file tool's path only; never an edit's text, a written file
+ * or a typed value.
+ *
+ * Bounded: at most one event per run every `minIntervalMs`; a call seen inside
+ * the window waits for its end, the newest replacing the one before (so the
+ * page always learns the latest call), and a run's state goes with its end.
+ * Calls overlap (OpenCode runs tools in parallel): the end of a call older than
+ * one still running is no news to the page and is never sent, so it can never
+ * replace or follow the newer call's start, in the window or after it.
+ */
+
+import { redactSecrets, safeCommand, safeUrl } from '../public/shared/assistant/asst-redact.js';
+
+export const OPENCODE_ACTIVITY_MIN_MS = 250;
+const MAX_CALLS_PER_RUN = 256; // callIDs remembered per run (start / finish seen)
+const MAX_RUNS = 64;           // runs tracked at once (each forgotten at its end)
+const FIELD_MAX = 300;         // characters of an input field
+const PLAN_ITEMS = 20;         // todowrite items forwarded
+const PLAN_ITEM_MAX = 120;
+
+const str = (v) => (v == null ? '' : String(v));
+const clip = (v, max = FIELD_MAX) => {
+  const s = str(v).replace(/\s+/g, ' ').trim();
+  return s.length > max ? `${s.slice(0, max - 1).trimEnd()}…` : s;
+};
+
+/** Input fields a step line reads (asst-tool-kinds.js sayCall), whatever the tool. */
+const STEP_FIELDS = Object.freeze([
+  'command', 'cmd', // a shell command
+  'filePath', 'file_path', 'path', 'notebook_path', // a file, a folder
+  'pattern', 'query', 'q', 'include', 'glob', // a search
+  'url', 'href', // a page
+  'element', 'label', 'name', 'target', 'selector', 'ref', 'key', 'keys', // a browser control, a key, never what is typed into it
+  'subagent_type', 'agent', 'action', // a sub-agent, a desktop or memory action
+]);
+const STEP_NUMBERS = Object.freeze(['offset', 'limit']);
+/** Fields that are a step only for some tools: a click's visible text, a sub-agent's one-line description. */
+const TOOL_FIELDS = Object.freeze([
+  [/(^|_)browser_(click|hover)$/i, ['text']],
+  [/^task$/i, ['description']],
+]);
+/** File tools: their step is the file, so the path is all that goes (a read keeps its line range). */
+const FILE_TOOLS = /^(?:read|edit|write|patch|multiedit|notebook_?(?:read|edit))$/i;
+const PATH_FIELDS = Object.freeze(['filePath', 'file_path', 'path', 'notebook_path']);
+const COMMAND_FIELDS = new Set(['command', 'cmd']);
+const URL_FIELDS = new Set(['url', 'href']);
+
+/** A field as its step line may say it: a command and an address made safe, anything else masked, then clipped. */
+function safeField(key, value) {
+  const text = COMMAND_FIELDS.has(key) ? safeCommand(value) : URL_FIELDS.has(key) ? safeUrl(value) : redactSecrets(value);
+  return clip(text);
+}
+
+/**
+ * The part of a tool call's input its step line needs: a command with its credentials masked and its heredoc or
+ * inline file bodies left out, an address as scheme://host/path, a file tool's path only; every field masked
+ * (asst-redact.js) before it is clipped. Never an edit's text, a file's content or a typed value.
+ */
+export function stepInput(tool, input) {
+  const i = input && typeof input === 'object' && !Array.isArray(input) ? input : {};
+  const out = {};
+  const file = FILE_TOOLS.test(str(tool));
+  const fields = file ? [...PATH_FIELDS] : [...STEP_FIELDS];
+  if (!file) for (const [re, extra] of TOOL_FIELDS) if (re.test(str(tool))) fields.push(...extra);
+  for (const key of fields) {
+    const value = i[key];
+    if (typeof value === 'string' && value.trim()) out[key] = safeField(key, value);
+    else if (Array.isArray(value) && value.every((v) => typeof v === 'string')) {
+      const joined = safeField(key, value.join(' '));
+      if (joined) out[key] = joined;
+    }
+  }
+  if (file && !/^read$/i.test(str(tool))) return out;
+  for (const key of STEP_NUMBERS) if (Number.isFinite(i[key])) out[key] = i[key];
+  if (file) return out;
+  // A plan: its items' words and states (planState's current step), never more than a short list.
+  if (Array.isArray(i.todos)) {
+    out.todos = i.todos.filter((x) => x && typeof x === 'object').slice(0, PLAN_ITEMS)
+      .map((x) => ({ content: clip(redactSecrets(x.content ?? x.text), PLAN_ITEM_MAX), status: clip(x.status, 24) }));
+  }
+  return out;
+}
+
+/**
+ * One OpenCode provider event ({ provider, runId, eventType, event }, the
+ * adapter's onEvent payload) as a tool call's start or finish, or null for
+ * anything else (text, reasoning, files, a sub-agent's session, other events).
+ * → { callID, phase: 'start' | 'finish', payload } with `payload` the compact
+ * copy the page gets.
+ */
+export function openCodeToolCall(payload) {
+  if (!payload || payload.provider !== 'opencode' || payload.childSession) return null;
+  if (!/^message[.:]part[.:]updated$/i.test(str(payload.eventType))) return null;
+  const event = payload.event && typeof payload.event === 'object' ? payload.event : {};
+  const part = event.part && typeof event.part === 'object' ? event.part : null;
+  if (!part || part.type !== 'tool' || !str(part.tool).trim()) return null;
+  const status = str(part.state?.status);
+  const phase = status === 'running' ? 'start' : status === 'completed' || status === 'error' ? 'finish' : null;
+  if (!phase) return null; // pending: its input is still streaming
+  const tool = clip(part.tool, 160);
+  const callID = str(part.callID || part.id);
+  const sessionID = str(event.sessionID || part.sessionID) || undefined;
+  return {
+    callID,
+    phase,
+    payload: {
+      provider: 'opencode',
+      runId: payload.runId,
+      eventType: 'message.part.updated',
+      event: {
+        sessionID,
+        part: { id: str(part.id) || undefined, sessionID, messageID: str(part.messageID) || undefined, type: 'tool', callID, tool, state: { status, input: stepInput(tool, part.state?.input) } },
+      },
+    },
+  };
+}
+
+const TERMINAL = new Set(['sidepanel:run-completed', 'sidepanel:run-failed', 'sidepanel:run-stopped']);
+
+/**
+ * createOpenCodeActivityRelay({ send, minIntervalMs, now, setTimer, clearTimer })
+ * observe(message) takes every NativeLoopRuntime message (onEvent): it returns
+ * true for an OpenCode provider event, which it never passes on as it is
+ * (its tool calls go to send() as compact copies, at the bounded rate), and
+ * false for everything else, which the caller sends as before.
+ */
+export function createOpenCodeActivityRelay({
+  send,
+  minIntervalMs = OPENCODE_ACTIVITY_MIN_MS,
+  now = () => Date.now(),
+  setTimer = (fn, ms) => { const timer = setTimeout(fn, ms); timer.unref?.(); return timer; },
+  clearTimer = (timer) => clearTimeout(timer),
+} = {}) {
+  const runs = new Map(); // runId → { calls: Map(callID → { phase, seq }), seq, last, pending, timer }
+
+  function forget(runId) {
+    const state = runs.get(runId);
+    if (!state) return;
+    if (state.timer) clearTimer(state.timer);
+    runs.delete(runId);
+  }
+
+  function stateOf(runId) {
+    let state = runs.get(runId);
+    if (!state) {
+      while (runs.size >= MAX_RUNS) forget(runs.keys().next().value);
+      state = { calls: new Map(), seq: 0, last: -Infinity, pending: null, timer: null };
+      runs.set(runId, state);
+    }
+    return state;
+  }
+
+  /** A call that started after the one `seq` names is still running. */
+  function newerRunning(state, callID, seq) {
+    for (const [id, c] of state.calls) if (id !== callID && c.phase === 'start' && c.seq > seq) return true;
+    return false;
+  }
+
+  function emit(state, message) {
+    state.last = now();
+    try { send(message); } catch { /* the socket is gone */ }
+  }
+
+  function flush(runId) {
+    const state = runs.get(runId);
+    if (!state) return;
+    state.timer = null;
+    const message = state.pending;
+    state.pending = null;
+    if (message) emit(state, message);
+  }
+
+  function observe(message) {
+    const type = str(message?.type);
+    if (TERMINAL.has(type)) {
+      const runId = message.run?.runId || message.runId;
+      if (runId) forget(runId);
+      return false;
+    }
+    if (type !== 'sidepanel:provider-event' || message.event?.provider !== 'opencode') return false;
+    const call = openCodeToolCall(message.event);
+    const runId = str(message.run?.runId || message.event?.runId);
+    if (!call || !runId) return true;
+    const state = stateOf(runId);
+    // Once per call and phase (OpenCode updates a running part many times); a start after its finish is old news.
+    const seen = state.calls.get(call.callID);
+    if (call.callID && (seen?.phase === call.phase || seen?.phase === 'finish')) return true;
+    const seq = seen?.seq ?? ++state.seq; // the order calls started in (a call first seen at its end starts now)
+    if (call.callID) {
+      state.calls.delete(call.callID);
+      state.calls.set(call.callID, { phase: call.phase, seq });
+      while (state.calls.size > MAX_CALLS_PER_RUN) state.calls.delete(state.calls.keys().next().value);
+    }
+    // An older call's end, while a newer call runs: the page shows the newer one, and keeps it.
+    if (call.phase === 'finish' && newerRunning(state, call.callID, seq)) return true;
+    const out = { type: 'sidepanel:provider-event', run: message.run, event: call.payload };
+    const wait = state.last + minIntervalMs - now();
+    if (wait <= 0 && !state.timer) { emit(state, out); return true; }
+    state.pending = out; // the newest call the window held back
+    if (!state.timer) state.timer = setTimer(() => flush(runId), Math.max(0, wait));
+    return true;
+  }
+
+  return {
+    observe,
+    /** Runs with state (tests and devtools). */
+    size: () => runs.size,
+    /** Drop every run's state and timer (shutdown). */
+    clear() { for (const runId of [...runs.keys()]) forget(runId); },
+  };
+}

package/neural-interface/lib/opencode-worker-data.js

@@ -0,0 +1,27 @@
+// Isolate the serve/config, not the provider's credential database. OpenCode 2
+// keeps credentials and sessions together. Pin the original XDG stores so a
+// restart cannot silently select another HOME/account or an empty database.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+
+export function openCodeWorkerData(configRoot, { resume = false, env = process.env, home = homedir() } = {}) {
+  const file = join(configRoot, 'worker-data.json');
+  const keys = ['XDG_DATA_HOME', 'XDG_STATE_HOME', 'XDG_CACHE_HOME'];
+  if (resume || existsSync(file)) {
+    let saved;
+    try { saved = JSON.parse(readFileSync(file, 'utf8')); } catch { throw new Error('OpenCode durable session data descriptor is gone'); }
+    if (!keys.every(key => typeof saved[key] === 'string' && isAbsolute(saved[key]))) throw new Error('OpenCode durable session data descriptor is invalid');
+    if (!existsSync(join(saved.XDG_DATA_HOME, 'opencode', 'opencode.db'))) throw new Error('OpenCode durable session database is gone');
+    return Object.fromEntries(keys.map(key => [key, saved[key]]));
+  }
+  const saved = {
+    XDG_DATA_HOME: env.XDG_DATA_HOME || join(home, '.local', 'share'),
+    XDG_STATE_HOME: env.XDG_STATE_HOME || join(home, '.local', 'state'),
+    XDG_CACHE_HOME: env.XDG_CACHE_HOME || join(home, '.cache'),
+  };
+  if (!keys.every(key => isAbsolute(saved[key]))) throw new Error('OpenCode XDG directories must be absolute');
+  mkdirSync(configRoot, { recursive: true });
+  writeFileSync(file, JSON.stringify(saved) + '\n', { mode: 0o600 });
+  return saved;
+}