synabun 2.0.10 → 2.1.0

package/neural-interface/lib/codex-worker-app-server.js

@@ -0,0 +1,172 @@
+// One app-server per dispatched worker. The SDK-shaped surface keeps the native
+// worker's event/usage contract while thread/resume reopens its durable thread.
+import { spawn, execFileSync } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
+
+const toml = (v) => Array.isArray(v) ? `[${v.map(toml).join(',')}]`
+  : v && typeof v === 'object' ? `{${Object.entries(v).filter(([, x]) => x != null).map(([k, x]) => `${JSON.stringify(k)}=${toml(x)}`).join(',')}}`
+    : JSON.stringify(v);
+
+// Match the SDK's leaf overrides: pins/switches address only their intended
+// fields and leave native command/url/env definitions in the native config.
+// Codex splits override paths literally on dots (it does not parse TOML keys).
+// Top-level keys may already be override paths; nested keys are literal segments.
+export function codexWorkerConfigOverrides(config) {
+  const overrides = [];
+  const visit = (value, path) => {
+    if (value == null) return;
+    if (typeof value === 'object' && !Array.isArray(value)) {
+      for (const [key, child] of Object.entries(value)) {
+        if (path && /[.=\x00-\x1f\x7f]/.test(key)) throw new Error('Codex override paths cannot address this config key');
+        visit(child, path ? `${path}.${key}` : key);
+      }
+    } else overrides.push(`${path}=${toml(value)}`);
+  };
+  visit(config, '');
+  return overrides;
+}
+
+export class CodexWorkerAppServer {
+  constructor({ codexPathOverride, env, config = {}, configArgs = [], apiKey, signal, onProcess = () => {} }) {
+    this.pending = new Map();
+    this.seq = 0;
+    this.listener = null;
+    this.failure = null;
+    const args = [...configArgs];
+    for (const override of codexWorkerConfigOverrides(config)) args.push('-c', override);
+    // Run identity in the command line permits conservative orphan identification.
+    args.push('-c', `synabun_worker_run=${JSON.stringify(env.SYNABUN_TERMINAL_SESSION || '')}`, 'app-server');
+    this.proc = spawn(codexPathOverride, args, { env, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+    this.exited = new Promise((r) => this.proc.once('close', r));
+    onProcess({ pid: this.proc.pid, startedAt: new Date().toISOString() });
+    let buffer = '';
+    const decoder = new StringDecoder('utf8');
+    this.proc.stdout.on('data', (chunk) => {
+      buffer += decoder.write(chunk);
+      let end;
+      while ((end = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, end); buffer = buffer.slice(end + 1);
+        let msg; try { msg = JSON.parse(line); } catch { continue; }
+        if (msg.id != null && !msg.method) {
+          const p = this.pending.get(msg.id); if (!p) continue;
+          this.pending.delete(msg.id); clearTimeout(p.timer);
+          msg.error ? p.reject(new Error(msg.error.message || 'Codex RPC failed')) : p.resolve(msg.result);
+        } else if (msg.id != null) {
+          // Workers have approvalPolicy never. Never grant an unexpected request.
+          this.write({ id: msg.id, error: { code: -32601, message: 'Unattended worker does not accept interactive requests' } });
+        } else this.listener?.(msg);
+      }
+    });
+    // Drain stderr without exposing credentials/config to the worker transcript.
+    this.proc.stderr.resume();
+    this.proc.on('error', (error) => this.fail(error));
+    this.proc.stdin.on('error', (error) => this.fail(error));
+    this.proc.on('close', (code, signal) => this.fail(new Error(`Codex app-server exited (${signal || code})`)));
+    this.ready = (async () => {
+      await this.rpc('initialize', { clientInfo: { name: 'synabun-worker', version: '1.0.0' }, capabilities: { experimentalApi: true } });
+      this.write({ method: 'initialized', params: {} });
+      if (apiKey) await this.rpc('account/login/start', { type: 'apiKey', apiKey });
+    })();
+    this.ready.catch(() => {});
+    this.startupSignal = signal;
+    this.cancelStartup = () => { this.dispose().catch(() => {}); };
+    signal?.addEventListener('abort', this.cancelStartup, { once: true });
+    if (signal?.aborted) this.cancelStartup();
+  }
+  write(value) { if (!this.proc.stdin.destroyed) this.proc.stdin.write(JSON.stringify(value) + '\n'); }
+  fail(error) {
+    this.failure = error;
+    for (const p of this.pending.values()) { clearTimeout(p.timer); p.reject(error); }
+    this.pending.clear();
+    this.listener?.({ method: 'synabun/exit', error });
+  }
+  rpc(method, params) {
+    if (this.failure) return Promise.reject(this.failure);
+    return new Promise((resolve, reject) => {
+      const id = ++this.seq;
+      const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`Codex ${method} timed out`)); }, 30_000);
+      this.pending.set(id, { resolve, reject, timer });
+      this.write({ id, method, params });
+    });
+  }
+  startThread(options) { return this.thread(null, options); }
+  resumeThread(id, options) { return this.thread(id, options); }
+  thread(id, options) {
+    const owner = this;
+    const sandboxPolicy = options.sandboxMode === 'read-only' ? { type: 'readOnly', networkAccess: !!options.networkAccessEnabled }
+      : options.sandboxMode === 'workspace-write' ? { type: 'workspaceWrite', writableRoots: [options.workingDirectory, ...(options.additionalDirectories || [])], networkAccess: !!options.networkAccessEnabled }
+        : { type: 'dangerFullAccess' };
+    const ready = this.ready.then(async () => {
+      const reply = await this.rpc(id ? 'thread/resume' : 'thread/start', {
+        ...(id ? { threadId: id } : {}), cwd: options.workingDirectory,
+        model: options.model || null, approvalPolicy: 'never', sandbox: options.sandboxMode,
+        config: { web_search: options.webSearchMode || 'disabled', sandbox_workspace_write: { network_access: !!options.networkAccessEnabled, writable_roots: options.additionalDirectories || [] } },
+      });
+      const actual = reply?.thread?.id;
+      if (!actual || (id && actual !== id)) throw new Error('Codex did not resume the requested thread');
+      id = actual;
+    });
+    ready.catch(() => {});
+    return {
+      get id() { return id; }, ready: () => ready,
+      async runStreamed(prompt, { signal, outputSchema } = {}) {
+        await ready;
+        const queue = []; const text = new Map(); let wake; let done = false; let failure; let turnId;
+        const push = (event) => { queue.push(event); wake?.(); };
+        const abort = () => {
+          failure = Object.assign(new Error('Codex turn aborted'), { name: 'AbortError' }); done = true; wake?.();
+          if (turnId) owner.rpc('turn/interrupt', { threadId: id, turnId }).catch(() => {});
+        };
+        owner.listener = (msg) => {
+          const p = msg.params || {};
+          if (p.threadId && p.threadId !== id) return;
+          if (msg.method === 'synabun/exit') { failure = msg.error; done = true; wake?.(); }
+          if (msg.method === 'item/agentMessage/delta') {
+            const value = (text.get(p.itemId) || '') + (p.delta || '');
+            text.set(p.itemId, value);
+            push({ type: 'item.updated', item: { id: p.itemId, type: 'agent_message', text: value } });
+          }
+          if (msg.method === 'item/started' || msg.method === 'item/completed') {
+            const item = p.item || {};
+            const types = { agentMessage: 'agent_message', commandExecution: 'command_execution', fileChange: 'file_change', mcpToolCall: 'mcp_tool_call', webSearch: 'web_search', reasoning: 'reasoning' };
+            push({ type: msg.method === 'item/started' ? 'item.started' : 'item.completed', item: { ...item, type: types[item.type] || item.type, aggregated_output: item.aggregatedOutput, exit_code: item.exitCode } });
+          }
+          if (msg.method === 'turn/completed') {
+            if (p.turn?.status === 'failed') push({ type: 'turn.failed', error: p.turn.error || { message: 'Codex turn failed' } });
+            else if (p.turn?.status === 'interrupted') failure = Object.assign(new Error('Codex turn interrupted'), { name: 'AbortError' });
+            else push({ type: 'turn.completed' }); // rollout meter is authoritative across resumes
+            done = true; wake?.();
+          }
+        };
+        signal?.addEventListener('abort', abort, { once: true });
+        try {
+          if (signal?.aborted) throw Object.assign(new Error('Codex turn aborted'), { name: 'AbortError' });
+          const reply = await owner.rpc('turn/start', { threadId: id, input: [{ type: 'text', text: String(prompt), text_elements: [] }], approvalPolicy: 'never', sandboxPolicy, effort: options.modelReasoningEffort || null, ...(outputSchema ? { outputSchema } : {}) });
+          turnId = reply?.turn?.id;
+          if (signal?.aborted) abort();
+        } catch (error) { owner.listener = null; signal?.removeEventListener('abort', abort); throw error; }
+        return { events: (async function* () {
+          try {
+            yield { type: 'thread.started', thread_id: id };
+            while (!done || queue.length) {
+              if (queue.length) yield queue.shift();
+              else await new Promise((r) => { wake = r; });
+            }
+            if (failure) throw failure;
+          } finally { owner.listener = null; signal?.removeEventListener('abort', abort); }
+        })() };
+      },
+    };
+  }
+  async dispose() {
+    this.startupSignal?.removeEventListener('abort', this.cancelStartup);
+    if (this.proc.exitCode !== null || this.proc.signalCode) return;
+    if (process.platform === 'win32') {
+      try { execFileSync('taskkill', ['/pid', String(this.proc.pid), '/T', '/F'], { timeout: 5000, stdio: 'ignore', windowsHide: true }); } catch {}
+    } else this.proc.kill('SIGTERM');
+    let timer;
+    await Promise.race([this.exited, new Promise((r) => { timer = setTimeout(r, 1500); })]);
+    clearTimeout(timer);
+    if (this.proc.exitCode === null && !this.proc.signalCode) this.proc.kill('SIGKILL');
+  }
+}

package/neural-interface/lib/confined-fs.js

@@ -19,7 +19,7 @@
 // sequence; it does not remove it.
 
 import {
-  openSync, closeSync, fstatSync, lstatSync, readSync, writeSync, ftruncateSync, fsyncSync,
+  openSync, closeSync, fstatSync, fchmodSync, lstatSync, readSync, writeSync, ftruncateSync, fsyncSync,
   mkdirSync, readdirSync, rmSync, unlinkSync, renameSync, realpathSync, createReadStream, constants,
 } from 'node:fs';
 import { randomBytes } from 'node:crypto';
@@ -142,6 +142,17 @@ export function writeConfinedFile(base, path, data, { exclusive = false, mode =
     if (!st.isFile()) throw new PathConfineError(400, 'Not a regular file.');
     if (!created) ftruncateSync(fd, 0);
     writeAll(fd, data);
+  } catch (err) {
+    // A file this call created and could not fill (the disk filled, the data could not be had) is not left
+    // half written: it is removed while it is still the file that was opened.
+    if (created) {
+      try {
+        const mine = fstatSync(fd);
+        const now = lstatSync(real);
+        if (now.dev === mine.dev && now.ino === mine.ino) unlinkSync(real);
+      } catch { /* gone already, or no longer ours */ }
+    }
+    throw err;
   } finally { try { closeSync(fd); } catch {} }
   return real;
 }
@@ -173,14 +184,29 @@ export function removeConfinedEntry(base, path) {
   return true;
 }
 
+/**
+ * What is at `path` itself, a link not followed: 'absent', 'file', 'dir', 'link' or 'other' (a FIFO, a
+ * socket, a device). Nothing is opened.
+ */
+export function entryKind(path) {
+  let st;
+  try { st = lstatSync(String(path)); } catch { return 'absent'; }
+  if (st.isSymbolicLink()) return 'link';
+  if (st.isFile()) return 'file';
+  if (st.isDirectory()) return 'dir';
+  return 'other';
+}
+
 /**
  * Replace `path` with `data` through a temporary file in the same folder:
  * created exclusively under an unpredictable name, never through a link, then
  * renamed over `path` (a rename replaces a link, it does not follow it).
  * `expect` is the file's state when it was read ({ dev, ino, mtimeMs, size }):
- * a file that changed since is not overwritten (409).
+ * a file that changed since is not overwritten (409). `exactMode`: the new
+ * file gets `mode` as it is, not narrowed by the process umask (a file that
+ * replaces another keeps the permissions that one had).
  */
-export function replaceFileAtomic(path, data, { mode = 0o600, expect = null } = {}) {
+export function replaceFileAtomic(path, data, { mode = 0o600, expect = null, exactMode = false } = {}) {
   const dir = realPathOf(dirname(String(path)));
   const target = join(dir, basename(String(path)));
   const tmp = join(dir, `.${basename(target)}.${randomBytes(12).toString('hex')}.tmp`);
@@ -190,6 +216,7 @@ export function replaceFileAtomic(path, data, { mode = 0o600, expect = null } =
     try {
       const st = verifyOpened(fd, tmp);
       if (!st.isFile()) throw moved();
+      if (exactMode) fchmodSync(fd, mode & 0o7777);
       writeAll(fd, data);
       try { fsyncSync(fd); } catch {}
     } finally { try { closeSync(fd); } catch {} }

package/neural-interface/lib/crash-notice-api.js

@@ -0,0 +1,98 @@
+// ═══════════════════════════════════════════
+// SynaBun — /api/system/crash-notice: the notice after an automatic restart
+// ═══════════════════════════════════════════
+//
+//   GET  /api/system/crash-notice           { ok, notice }   null, or the crash the supervisor recovered from
+//   POST /api/system/crash-notice/dismiss   { id }           { ok, notice }: what is left (a newer crash's, or null)
+//
+// When the server crashes after it was up, its supervisor (lib/server-supervisor.js at the package root) starts
+// it again and leaves DATA_HOME/data/server-crash.json (lib/server-crash-record.js) for it. The owner's pages ask
+// for it when they load and every time their sync socket connects (a page that was open through the crash
+// reconnects, it is not reloaded: public/shared/ui-crash-notice.js), and show it until the owner dismisses it. A
+// dismissal removes the record, and every open tab and window drops the notice at once (`crash-notice:changed`
+// on the sync socket); none shows it again after a reload. The next crash writes a new record, with a new id,
+// which shows again. A record that cannot be removed (a read-only data folder) is kept dismissed in memory for
+// the life of this server.
+//
+// The owner's only: /api/system is admin-only (lib/request-gate.js), and every route takes the owner's guard by
+// itself (lib/http-guards.js ownerRouteGuard: this server's Host, its Origin on the write, no guest, no cross-site
+// write) and refuses an agent's request (uiOnly: X-SynaBun-Terminal, -Role, -Assistant, -Desktop-Grant, as
+// /api/system/app does). The dismissal is the owner's write from SynaBun's own page: X-SynaBun-UI: 1, a JSON body,
+// and this boot's page secret (lib/page-session.js, as Skills Studio's owner writes), which a local process that
+// merely leaves the agent headers out lacks; a tab that stayed open through the restart carries the previous boot's
+// cookie, and the page's own recovery (public/shared/page-session.js) gets this boot's and sends the dismissal once
+// more. A request names an id, never a path.
+
+import { Router } from 'express';
+import { clearCrashRecord, readCrashRecord } from '../../lib/server-crash-record.js';
+import { sendGuardError, uiOnly } from './http-guards.js';
+
+const ID = /^[0-9a-f]{16}$/;
+
+/** What a page is shown of a record (already checked field by field when it was read), or null. */
+export function crashNoticeOf(record) {
+  if (!record || typeof record !== 'object') return null;
+  const { v, ...notice } = record;
+  return notice;
+}
+
+/**
+ * @param {object} deps
+ * @param {string} deps.dataHome
+ * @param {import('express').RequestHandler} deps.guard   the owner's guard (lib/http-guards.js ownerRouteGuard)
+ * @param {{ verify(req): boolean, require: import('express').RequestHandler }} [deps.pageSession]  lib/page-session.js:
+ *   the page secret a dismissal carries (server.js hands it in; without one, as in a unit test, none is asked)
+ * @param {(message: object) => void} [deps.broadcast]     the owner's open pages (server.js broadcastSync keeps
+ *   `crash-notice:` from invite guests)
+ * @param {() => Promise<{ tunnel?: 'unknown' }>} [deps.leftovers]  what the crashed server may have left running that
+ *   this one could not end (server.js: its cloudflared, sweepLeftoverTunnels): added to the notice
+ */
+export function createCrashNoticeApi({
+  dataHome, guard, pageSession = null, broadcast = () => {}, log = () => {}, read = readCrashRecord, clear = clearCrashRecord,
+  leftovers = async () => ({}),
+} = {}) {
+  if (!dataHome || typeof guard !== 'function') throw new Error('createCrashNoticeApi needs the data home and the owner\'s guard');
+  const router = Router();
+  // Dismissed while the record could not be removed: never shown again by this server.
+  const dismissed = new Set();
+  const current = () => {
+    const notice = crashNoticeOf(read(dataHome));
+    return notice && !dismissed.has(notice.id) ? notice : null;
+  };
+  // The notice as a page is shown it: the record, and what the crashed server may have left open.
+  const shown = async (notice) => {
+    if (!notice) return null;
+    let left = {};
+    try { left = await leftovers(); } catch { left = {}; }
+    return { ...notice, ...(left?.tunnel === 'unknown' ? { tunnel: 'unknown' } : {}) };
+  };
+
+  router.use(guard, uiOnly, (req, res, next) => { res.set('Cache-Control', 'no-store'); next(); });
+
+  router.get('/', async (req, res) => { res.json({ ok: true, notice: await shown(current()) }); });
+
+  router.post('/dismiss', (req, res, next) => {
+    if (req.get('x-synabun-ui') !== '1') return sendGuardError(res, 403, 'UI_HEADER_REQUIRED', 'A notice is dismissed from SynaBun\'s own page.');
+    // The page secret: what a local process that merely sends the page's headers lacks.
+    if (pageSession && !pageSession.verify(req)) return pageSession.require(req, res, next);
+    next();
+  }, async (req, res) => {
+    if (!req.is('application/json')) return res.status(415).json({ ok: false, code: 'JSON_REQUIRED', error: 'Send JSON.' });
+    const id = req.body?.id;
+    if (typeof id !== 'string' || !ID.test(id)) return res.status(400).json({ ok: false, code: 'BAD_REQUEST', error: 'Send { id } of the notice.' });
+    if (!clear(dataHome, { id })) {
+      const still = crashNoticeOf(read(dataHome));
+      if (still?.id === id) {
+        dismissed.add(id);
+        log(`[crash-notice] the record could not be removed; ${id} stays dismissed until the server restarts`);
+      }
+    } else {
+      log(`[crash-notice] dismissed ${id}`);
+    }
+    const notice = await shown(current());
+    try { broadcast({ type: 'crash-notice:changed', notice }); } catch {}
+    res.json({ ok: true, notice });
+  });
+
+  return router;
+}

package/neural-interface/lib/editor-completion-opencode.js

@@ -4,20 +4,18 @@
 // input tokens before a line of code, and every request would show up as a
 // session in the OpenCode panel. So completions get a serve of their own:
 //
-//   - its own XDG_CONFIG_HOME (DATA_HOME/data/editor-complete/) whose config
-//     holds what makes the user's models reachable (their `provider` blocks and
-//     the provider allow / deny lists) and one agent, `synabun-complete`: the
-//     completion instruction as its prompt, every tool denied. No MCP servers,
-//     no instruction files, no plugins. A provider block that names a file by
-//     a path relative to the user's configuration ({file:./key}) is written
-//     with that path made whole: here it would be looked for in this folder;
+//   - its own XDG_CONFIG_HOME (DATA_HOME/data/editor-complete/) whose
+//     opencode.json holds what makes the user's models reachable (their
+//     provider blocks and the provider allow / deny rules, as the user wrote
+//     them) and one agent, `synabun-complete`: the completion instruction as
+//     its system prompt, every tool denied. No MCP servers, no instruction
+//     files, no plugins. A provider block that names a file by a path relative
+//     to the user's configuration ({file:./key}) is written with that path
+//     made whole: here it would be looked for in this folder;
 //   - OPENCODE_DISABLE_CLAUDE_CODE and OPENCODE_DISABLE_PROJECT_CONFIG, so no
 //     CLAUDE.md, AGENTS.md or opencode.json of a folder above is read either;
 //   - the user's own data home, so stored provider credentials keep working.
 //
-// Measured on OpenCode 1.18.34 (2026-10-12): about 200 input tokens of overhead
-// per request against 5,500 with the tools left on, and 810 with an AGENTS.md
-// one folder up and project configuration left on.
 //
 // Started on the first request, stopped after ten idle minutes and at server
 // shutdown. One request is one session in an empty working folder: create,
@@ -35,13 +33,12 @@
 
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, resolve, sep } from 'node:path';
-import { checkOpencodeServer, newServePassword } from './opencode-protocol.js';
+import { checkOpencodeServer, newServePassword, servePasswordReader } from './opencode-protocol.js';
+import { OPENCODE_CONFIG_FILE, OPENCODE_CONFIG_SCHEMA } from './opencode-config.js';
 
-// OpenCode 2 (lib/opencode-protocol.js) runs the same way: the serve gets a
-// password of its own, is healthy only when its /api answers JSON, and is
-// spoken to through lib/opencode2-client.js; its configuration is the OpenCode
-// 1 file below, which OpenCode 2 reads (agent → agents, prompt → system,
-// temperature → request body).
+// The serve gets a password of its own, is healthy only when OpenCode 2's /api
+// answers JSON (lib/opencode-protocol.js), and is spoken to through
+// lib/opencode2-client.js; its configuration is OpenCode 2's opencode.json.
 
 export const COMPLETION_AGENT = 'synabun-complete';
 /** Every session of this serve carries this title: no title is generated, and leftovers of a crash are recognisable. */
@@ -53,8 +50,10 @@ export const SWEEP_TIMEOUT_MS = 5000;
 /** How many ports a start tries when another server takes the one it was given. */
 export const START_ATTEMPTS = 3;
 
-// What of the user's OpenCode configuration decides which models can be reached.
-const CARRIED_KEYS = ['provider', 'disabled_providers', 'enabled_providers'];
+// What of the user's OpenCode configuration decides which models can be reached: the provider blocks and the
+// provider allow / deny rules, in either shape the user wrote them (OpenCode 2 reads both).
+const PROVIDER_KEYS = ['providers', 'provider'];
+const CARRIED_LISTS = ['policies', 'disabled_providers', 'enabled_providers'];
 // Reasoning settings a model may offer, the lightest first: a completion wants the least.
 const LIGHT_VARIANTS = ['none', 'minimal', 'low'];
 
@@ -87,18 +86,21 @@ function rebaseFileReferences(value, dir, seen) {
 }
 
 /**
- * The configuration of the dedicated serve.
- * @param {object | null} userConfig the user's own OpenCode configuration (~/.config/opencode/config.json)
+ * The configuration of the dedicated serve (its opencode.json).
+ * @param {object | null} userConfig the user's own OpenCode configuration (opencode.json, then opencode.jsonc over it)
  * @param {{ system: string, configDir?: string | null, log?: (tag: string, message: string) => void }} o `system`:
  *   the completion instruction, the agent's whole prompt; `configDir`: the folder the user's configuration is in,
  *   which a relative {file:…} reference of a provider is resolved against. Without it, a provider that holds such
  *   a reference is left out (and logged): from the serve's own folder it would name another file, or none.
  */
 export function buildCompletionServeConfig(userConfig, { system, configDir = null, log = () => {} }) {
-  const config = { $schema: 'https://opencode.ai/config.json', autoupdate: false, share: 'disabled', snapshot: false };
-  for (const key of CARRIED_KEYS) {
+  const config = { $schema: OPENCODE_CONFIG_SCHEMA, update: 'disable', share: 'disabled', snapshots: false };
+  for (const key of CARRIED_LISTS) {
+    const value = isObject(userConfig) ? userConfig[key] : undefined;
+    if (Array.isArray(value)) config[key] = structuredClone(value);
+  }
+  for (const key of PROVIDER_KEYS) {
     const value = isObject(userConfig) ? userConfig[key] : undefined;
-    if (key !== 'provider') { if (Array.isArray(value)) config[key] = structuredClone(value); continue; }
     if (!isObject(value)) continue;
     const providers = {};
     for (const [id, definition] of Object.entries(value)) {
@@ -110,15 +112,15 @@ export function buildCompletionServeConfig(userConfig, { system, configDir = nul
       }
       providers[id] = carried;
     }
-    if (Object.keys(providers).length || !Object.keys(value).length) config.provider = providers;
+    if (Object.keys(providers).length || !Object.keys(value).length) config[key] = providers;
   }
-  config.agent = {
+  config.agents = {
     [COMPLETION_AGENT]: {
       description: 'SynaBun code editor autocomplete',
       mode: 'primary',
-      prompt: system,
-      temperature: 0.1,
-      permission: { '*': 'deny' },
+      system,
+      request: { body: { temperature: 0.1 } },
+      permissions: [{ action: '*', resource: '*', effect: 'deny' }],
     },
   };
   return config;
@@ -128,7 +130,7 @@ export function buildCompletionServeConfig(userConfig, { system, configDir = nul
  * The environment of the dedicated serve: the server's own, pointed at the lean configuration and told to read
  * nothing else.
  * @param {object} base the environment to start from (process.env)
- * @param {{ configHome: string }} o the XDG_CONFIG_HOME that holds opencode/config.json
+ * @param {{ configHome: string }} o the XDG_CONFIG_HOME that holds opencode/opencode.json
  */
 export function completionServeEnvironment(base, { configHome }) {
   const env = { ...base };
@@ -160,7 +162,7 @@ export function splitModelId(id) {
   return { providerID: text.slice(0, slash), modelID: text.slice(slash + 1) };
 }
 
-/** Each connected model's variant names, from the serve's /provider answer: Map("provider/model" → string[]). */
+/** Each connected model's variant names, from the serve's provider list: Map("provider/model" → string[]). */
 export function variantsByModel(providers) {
   const out = new Map();
   const body = isObject(providers?.data) && (providers.data.all || providers.data.connected) ? providers.data : providers;
@@ -176,7 +178,7 @@ export function variantsByModel(providers) {
 }
 
 /**
- * The text and the token counts of a prompt's answer (`POST /session/{id}/message`).
+ * The text and the token counts of a prompt's answer (the client's `session.prompt`).
  * @returns {{ text: string, tokens: { input: number, output: number }, error: string | null }} `input` counts the
  *   tokens read from and written to the provider's cache too; `output` counts reasoning
  */
@@ -202,23 +204,24 @@ function abortError() {
 
 /**
  * @param {object} deps
- * @param {string} deps.dataDir DATA_HOME/data/editor-complete: holds opencode/config.json and the empty work folder
+ * @param {string} deps.dataDir DATA_HOME/data/editor-complete: holds opencode/opencode.json and the empty work folder
  * @param {string} deps.system the completion instruction (the agent's prompt)
  * @param {() => object | null} deps.readUserConfig the user's OpenCode configuration, read at each start
  * @param {() => string | null} [deps.userConfigDir] the folder that configuration is in (relative {file:…}
  *   references of its providers are resolved against it)
  * @param {() => number | null | Promise<number | null>} deps.allocPort a free port (server.js: what an earlier
  *   SynaBun left running goes first, then allocOpencodeIsoPort)
- * @param {(o: { port: number, env: object, cwd: string, protocol: 1 | 2 | null, password: string | null }) => object}
- *   deps.spawnServe starts `opencode serve` on the port (OpenCode 2: with that password) and returns its process
+ * @param {(o: { port: number, env: object, cwd: string, password: string }) => object}
+ *   deps.spawnServe starts `opencode serve` on the port with that password and returns its process
  *   (`on('exit')`, `kill()`)
  * @param {(proc: object, signal?: string) => void} [deps.killServe] stops that process: SIGTERM, or SIGKILL for a
  *   failed start's process that did not end (default: proc.kill(signal))
- * @param {(o: { port: number, protocol?: number, password?: string | null, version?: string }) => object}
+ * @param {(o: { port: number, password?: string | null, version?: string }) => object}
  *   deps.createClient lib/opencode-v2-client.js createClientInstance
- * @param {() => Promise<number | null | { protocol: number | null, major?: number | null, supported?: boolean, reason?: string }>}
- *   [deps.detectProtocol] the OpenCode major the serve will be (server.js detectOpencodeProtocol); 1 when not given
- * @param {(protocol: number | null, run: () => Promise<any>) => Promise<any>} [deps.startOneAtATime] runs a start
+ * @param {() => Promise<{ major?: number | null, supported?: boolean, reason?: string } | null>}
+ *   [deps.detectOpencode] which OpenCode the serve will be (server.js detectOpencode): one SynaBun does not drive
+ *   never starts
+ * @param {(run: () => Promise<any>) => Promise<any>} [deps.startOneAtATime] runs a start
  *   in its turn among every serve SynaBun starts (server.js oneOpencodeStartAtATime); by itself when not given
  * @param {number} [deps.exitWaitMs] how long a failed start waits for its process to exit after SIGTERM, and again
  *   after SIGKILL, before its turn ends
@@ -238,8 +241,9 @@ export function createOpencodeCompletionEngine({
   killServe = (proc, signal = 'SIGTERM') => { try { proc.kill(signal); } catch { /* gone */ } },
   createClient, fetchImpl = (...args) => fetch(...args), env = process.env, now = Date.now,
   idleMs = IDLE_STOP_MS, startTimeoutMs = START_TIMEOUT_MS, sweepTimeoutMs = SWEEP_TIMEOUT_MS, healthPollMs = 100, log = () => {},
-  detectProtocol = async () => 1, newPassword = newServePassword,
-  startOneAtATime = (_protocol, run) => run(), exitWaitMs = 3000, trackServe = () => {},
+  detectOpencode = async () => null, newPassword = newServePassword,
+  passwordFrom = 'env', checkServer = checkOpencodeServer,
+  startOneAtATime = (run) => run(), exitWaitMs = 3000, trackServe = () => {},
 } = {}) {
   if (!dataDir || !system) throw new Error('createOpencodeCompletionEngine requires dataDir and system');
   if (typeof allocPort !== 'function' || typeof spawnServe !== 'function' || typeof createClient !== 'function') {
@@ -256,7 +260,6 @@ export function createOpencodeCompletionEngine({
   const deleting = new Set();   // session deletions on their way: a stop waits for them (drain)
 
   const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
-  const serveUrl = (port, path) => `http://127.0.0.1:${port}${path}${path.includes('?') ? '&' : '?'}directory=${encodeURIComponent(workDir)}`;
 
   function touch() {
     lastUsed = now();
@@ -301,22 +304,22 @@ export function createOpencodeCompletionEngine({
     try { userConfig = readUserConfig(); } catch (error) { log('editor-complete:serve', `could not read the OpenCode configuration: ${error?.message || error}`); }
     let configDir = null;
     try { configDir = userConfigDir() || null; } catch { configDir = null; }
-    writeFileSync(join(dataDir, 'opencode', 'config.json'), `${JSON.stringify(buildCompletionServeConfig(userConfig, { system, configDir, log }), null, 2)}\n`, 'utf8');
+    writeFileSync(join(dataDir, 'opencode', OPENCODE_CONFIG_FILE), `${JSON.stringify(buildCompletionServeConfig(userConfig, { system, configDir, log }), null, 2)}\n`, 'utf8');
 
-    // Which OpenCode this is (null: not known, told apart by what answers); a major SynaBun does not speak never starts.
-    const detected = await detectProtocol();
-    const protocol = detected && typeof detected === 'object' ? (detected.protocol ?? null) : (detected ?? null);
+    // An OpenCode SynaBun does not drive (OpenCode 1, an OpenCode 2 older than the minimum) never starts; a version
+    // not known here (a command line in Settings) is told by what answers.
+    const detected = await detectOpencode();
     if (detected && typeof detected === 'object' && detected.supported === false && detected.major != null) {
       throw new Error(detected.reason || `OpenCode ${detected.major} is not supported`);
     }
     if (mine !== epoch) throw new Error('The completion server was stopped while it was starting');
-    const password = protocol === 1 ? null : newPassword();
+    const password = passwordFrom === 'stdout' ? null : newPassword();
 
     // Another server that takes the port while the serve boots is a start collision: it is left running, this start's
     // own process is ended, and the start tries another port (START_ATTEMPTS ports at most).
     for (let attempt = 1; ; attempt++) {
       try {
-        return await startOn(port, { mine, protocol, password });
+        return await startOn(port, { mine, password });
       } catch (error) {
         if (!error?.portTaken || attempt >= START_ATTEMPTS || mine !== epoch) throw error;
         log('editor-complete:serve', `another server answers on port ${port}: it is left running, and the completion server tries another port`);
@@ -343,8 +346,8 @@ export function createOpencodeCompletionEngine({
     return false;
   }
 
-  async function startOn(port, { mine, protocol, password }) {
-    const started = { port, proc: null, client: null, variants: new Map(), providers: null, providersAt: 0, exited: false, killed: false, halt: null, protocol, password };
+  async function startOn(port, { mine, password }) {
+    const started = { port, proc: null, client: null, variants: new Map(), providers: null, providersAt: 0, exited: false, killed: false, halt: null, password };
     // What a stop wakes: a start that waits (for the serve to answer, for the next look) goes on at once.
     const halted = new Promise((done) => { started.halt = done; });
     // Both are checked before and after each wait: a stop may have been asked for, or the process may be gone.
@@ -357,9 +360,13 @@ export function createOpencodeCompletionEngine({
       // One start at a time with every other serve SynaBun starts (OpenCode 2 cannot open its database while
       // another serve is opening it): from the spawn until this serve answers, or until a failed start's process
       // is gone.
-      const check = await startOneAtATime(protocol, async () => {
+      const check = await startOneAtATime(async () => {
         stillWanted();
-        started.proc = spawnServe({ port, env: completionServeEnvironment(env, { configHome: dataDir }), cwd: workDir, protocol, password });
+        started.proc = spawnServe({ port, env: completionServeEnvironment(env, { configHome: dataDir }), cwd: workDir, password, passwordFrom });
+        if (passwordFrom === 'stdout') {
+          const readPassword = servePasswordReader();
+          started.proc?.stdout?.on('data', chunk => { started.password = readPassword(chunk); });
+        }
         starts++;
         spawned = started;
         started.proc?.on?.('exit', () => {
@@ -371,8 +378,9 @@ export function createOpencodeCompletionEngine({
           const deadline = now() + startTimeoutMs;
           for (;;) {
             stillWanted();
-            // The right API answering JSON, never a web page (lib/opencode-protocol.js).
-            const answer = await Promise.race([checkOpencodeServer({ port, protocol, password, fetchImpl, timeoutMs: 2000 }), halted]);
+            // OpenCode 2's API answering JSON, never a web page (lib/opencode-protocol.js).
+            const answer = passwordFrom === 'stdout' && !started.password ? null
+              : await Promise.race([checkServer({ port, password: started.password, fetchImpl, timeoutMs: 2000 }), halted]);
             if (answer?.ok) {
               // Only this start's own process counts: another server that took the port answers for itself.
               let verdict = null;
@@ -395,8 +403,7 @@ export function createOpencodeCompletionEngine({
       });
       stillWanted();
 
-      started.protocol = check.protocol || protocol || 1;
-      started.client = createClient({ port, protocol: started.protocol, password, version: check.version || '' });
+      started.client = createClient({ port, password: started.password, version: check.version || '' });
       // It answers, and takes no request yet. First the sessions a crash left behind go: a sweep that ran beside the
       // first requests would find their sessions in its listing and delete them under the model call. Meanwhile,
       // which lighter reasoning setting each model offers; worth a short wait, as without it the first completions
@@ -423,18 +430,11 @@ export function createOpencodeCompletionEngine({
 
   async function loadProviders(serve, { signal } = {}) {
     if (serve.providers && now() - serve.providersAt < 60_000) return serve.providers;
-    if (serve.protocol === 2) {
-      // OpenCode 2 has no /provider: its client answers in OpenCode 1's shape ({ all, default, connected }).
-      const listed = await serve.client.getClient().provider.list({ directory: workDir });
-      if (listed?.error) throw new Error(`The completion server answered ${listed.response?.status || 'an error'} for its model list`);
-      serve.providers = listed.data;
-      serve.providersAt = now();
-      serve.variants = variantsByModel(serve.providers);
-      return serve.providers;
-    }
-    const res = await fetchImpl(serveUrl(serve.port, '/provider'), { signal: signal || AbortSignal.timeout(8000) });
-    if (!res.ok) throw new Error(`The completion server answered ${res.status} for its model list`);
-    serve.providers = await res.json();
+    if (signal?.aborted) throw abortError();
+    // The client answers with the provider list SynaBun reads ({ all, default, connected }).
+    const listed = await serve.client.getClient().provider.list({ directory: workDir });
+    if (listed?.error) throw new Error(`The completion server answered ${listed.response?.status || 'an error'} for its model list`);
+    serve.providers = listed.data;
     serve.providersAt = now();
     serve.variants = variantsByModel(serve.providers);
     return serve.providers;
@@ -517,7 +517,7 @@ export function createOpencodeCompletionEngine({
   return {
     complete,
     /**
-     * The serve's /provider answer (every known provider, and which are connected), or null while the serve is
+     * The serve's provider list (every known provider, and which are connected), or null while the serve is
      * not running and `start` is not set.
      */
     async providers({ start: startIt = false, signal } = {}) {