agentp 2.0.0 → 2.1.0

package/lib/ocmux.js

@@ -1,300 +1,37 @@
 'use strict';
 
-// tmux helpers for the agentp v2 model ("sessions live in projects").
-//
-// A project owns a tmux window (TUI only — pane 0) plus a `.ocmux.json` state
-// file recording the target session. The OpenCode **server is user-managed**
-// (started with `opencode serve`); this module never starts or stops it. All
-// tmux interactions must go through `_tmux()`.
+// TUI routing helpers. OpenCode owns the shared server and sessions; ocmux only
+// routes a selected session to an explicitly registered tmux pane when one is
+// available. There is no managed tmux session or per-project window layout.
 
-const fs = require('fs');
 const path = require('path');
-const crypto = require('crypto');
-const child_process = require('child_process');
+const registry = require('./tui-registry');
 
-const SESSION = 'Opencode';
-
-function _tmux(args) {
-  const result = child_process.spawnSync('tmux', args, { encoding: 'utf8', maxBuffer: 1024 * 1024 });
-  if (result.error && result.error.code === 'ENOENT') {
-    return { status: -1, stdout: '', stderr: 'tmux not found' };
-  }
-  return result;
-}
-
-function hashDir(dir) {
-  return crypto.createHash('md5').update(dir).digest('hex').slice(0, 12);
-}
-
-function logfileFor(dir) {
-  return `/tmp/opencode-serve-${hashDir(dir)}.log`;
-}
-
-function sleep(seconds) {
-  child_process.execSync(`sleep ${seconds}`, { stdio: 'ignore' });
-}
-
-function ensureSession() {
-  const r = _tmux(['has-session', '-t', SESSION]);
-  if (r.status !== 0) {
-    _tmux(['new-session', '-d', '-s', SESSION]);
-  }
-}
-
-function pinWindowName(windowIndex) {
-  _tmux(['set-window-option', '-t', `${SESSION}:${windowIndex}`, 'automatic-rename', 'off']);
-}
-
-function readState(file) {
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function statefileFor(dir) {
-  return path.join(dir, '.ocmux.json');
-}
-
-// Return the pane ID running the TUI in `windowIndex`, or null when the window
-// has no TUI. v2 layout: the TUI is the only pane (pane 0). Legacy layout
-// (transition only): pane 0 is a server and the TUI is a non-zero pane; the
-// last pane is used as the fallback.
-function tuiPaneId(windowIndex) {
-  const r = _tmux(['list-panes', '-t', `${SESSION}:${windowIndex}`, '-F', '#{pane_id}\t#{pane_index}']);
-  if (r.status !== 0) return null;
-  const panes = r.stdout.trim().split('\n').filter(Boolean);
-  if (panes.length === 0) return null;
-  if (panes.length === 1) return panes[0].split('\t')[0];
-  // Legacy layout with a server pane — assume the last pane is the TUI.
-  return panes[panes.length - 1].split('\t')[0];
-}
-
-function windowByDir(dir) {
-  let realDir;
-  try { realDir = fs.realpathSync(dir); } catch { realDir = dir; }
-  const r = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}\t#{window_name}']);
-  if (r.status !== 0) return null;
-  for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
-    const [idx, name] = line.split('\t');
-    if (name === dir) return parseInt(idx, 10);
-    try {
-      if (fs.realpathSync(name) === realDir) return parseInt(idx, 10);
-    } catch {}
-  }
-  return null;
-}
-
-function windowNameByIndex(idx) {
-  const r = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}\t#{window_name}']);
-  if (r.status !== 0) return null;
-  for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
-    const [wi, name] = line.split('\t');
-    if (parseInt(wi, 10) === idx) return name;
-  }
-  return null;
-}
-
-function activeWindowIndex() {
-  const r = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index} #{window_active}']);
-  if (r.status !== 0) return null;
-  for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
-    const [idx, active] = line.split(' ');
-    if (active === '1') return parseInt(idx, 10);
-  }
-  return null;
-}
-
-function paneCount(windowIndex) {
-  const r = _tmux(['list-panes', '-t', `${SESSION}:${windowIndex}`, '-F', '#{pane_id}']);
-  if (r.status !== 0) return 0;
-  return r.stdout.trim().split('\n').filter(Boolean).length;
-}
-
-// List project windows: every tmux window whose name is a directory holding a
-// `.ocmux.json`. Status derives from TUI pane liveness.
-function listProjects() {
-  const sessionR = _tmux(['has-session', '-t', SESSION]);
-  if (sessionR.status !== 0) return [];
-
-  const listR = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}\t#{window_name}']);
-  if (listR.status !== 0 || !listR.stdout.trim()) return [];
-
-  const rows = [];
-  for (const line of listR.stdout.trim().split('\n').filter(Boolean)) {
-    const [idx, dir] = line.split('\t');
-    const sf = statefileFor(dir);
-    if (!fs.existsSync(sf)) continue;
-    const state = readState(sf);
-    if (!state) continue;
-    const winIdx = parseInt(idx, 10);
-    rows.push({
-      dir,
-      index: winIdx,
-      status: tuiPaneId(winIdx) != null ? 'alive' : 'dead',
-      session: state.session || null,
-      server: state.server || state.url || null,
-    });
-  }
-  return rows;
-}
-
-function isWindowZoomed(windowIndex) {
-  const r = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}|#{window_zoomed_flag}']);
-  if (r.status !== 0) return false;
-  for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
-    const [wi, z] = line.split('|');
-    if (parseInt(wi, 10) === windowIndex && z === '1') return true;
-  }
-  return false;
-}
-
-// v2-only TUI launch command. `sessionId` may be null to continue the last one.
-function tuiAttachCommand(url, sessionId) {
-  if (sessionId) return `opencode --server '${url}' --session '${sessionId}'`;
-  return `opencode --server '${url}' --continue`;
-}
-
-function zoomPane(paneId) {
-  if (paneId) _tmux(['resize-pane', '-Z', '-t', paneId]);
-}
-
-// Focus a project window, restarting its TUI when dead (or opening it for the
-// first time). Reads nothing from disk — the caller supplies server/session.
-function activateProject(dir, index, server, session) {
-  const winIdx = index;
-  pinWindowName(winIdx);
-
-  let tuiPane = tuiPaneId(winIdx);
-  if (!tuiPane) {
-    const cmd = tuiAttachCommand(server, session);
-    const count = paneCount(winIdx);
-    if (count >= 1) {
-      const panesR = _tmux(['list-panes', '-t', `${SESSION}:${winIdx}`, '-F', '#{pane_id}']);
-      const panes = panesR.status === 0 ? panesR.stdout.trim().split('\n').filter(Boolean) : [];
-      const lastPane = panes[panes.length - 1];
-      if (lastPane) {
-        const respawnR = _tmux(['respawn-pane', '-k', '-t', lastPane, cmd]);
-        if (respawnR.status !== 0) _tmux(['send-keys', '-t', lastPane, cmd, 'Enter']);
-      }
-    } else {
-      _tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`, cmd, 'Enter']);
-    }
-  }
-
-  const activeWin = activeWindowIndex();
-  if (activeWin !== null && activeWin !== winIdx) {
-    _tmux(['select-window', '-t', `${SESSION}:${winIdx}`]);
-  }
-
-  if (!isWindowZoomed(winIdx)) {
-    tuiPane = tuiPaneId(winIdx);
-    zoomPane(tuiPane);
-  }
-
-  return true;
+function tuiArgs(server, session, directory) {
+  const args = ['--server', server];
+  if (session) args.push('--session', session);
+  else args.push('--continue');
+  if (directory) args.push(directory);
+  return args;
 }
 
-// Create a project TUI window (v2 layout: TUI is pane 0, no server pane).
-// Writes the v2 state file. The server must already be reachable.
-function createProjectWindow(dir, url, session) {
-  try { dir = fs.realpathSync(dir); } catch {}
-  ensureSession();
-
-  const newWinR = _tmux(['new-window', '-d', '-P', '-F', '#{window_index}', '-t', SESSION, '-n', dir, '-c', dir]);
-  if (newWinR.status !== 0) throw new Error(`failed to create tmux window for ${dir}`);
-  let winIdx = parseInt(newWinR.stdout.trim(), 10);
-  if (isNaN(winIdx)) {
-    winIdx = windowByDir(dir);
-    if (winIdx == null) throw new Error('could not determine new window index');
+function switchTui(directory, server, session, executable) {
+  const target = registry.resolve(directory);
+  if (!target) return { ok: false, reason: 'none' };
+  const result = registry.respawn(target.instance, {
+    executable: executable || path.resolve(__dirname, '..', 'bin', 'ocmux'),
+    directory,
+    server,
+    session,
+  });
+  if (!result.ok) {
+    registry.pruneDead();
+    return { ok: false, reason: 'failed', kind: target.kind, error: result.error };
   }
-
-  pinWindowName(winIdx);
-
-  const cmd = tuiAttachCommand(url, session);
-  _tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`, cmd, 'Enter']);
-  sleep(0.5);
-  const tuiPane = tuiPaneId(winIdx);
-  zoomPane(tuiPane);
-
-  const activeWin = activeWindowIndex();
-  if (activeWin !== null && activeWin !== winIdx) {
-    _tmux(['select-window', '-t', `${SESSION}:${winIdx}`]);
-  }
-
-  const stateFile = path.join(dir, '.ocmux.json');
-  let existing = {};
-  try { existing = JSON.parse(fs.readFileSync(stateFile, 'utf8')); } catch {}
-  const state = { ...existing, version: 2, directory: dir, session: session || existing.session || null, server: url };
-  fs.writeFileSync(stateFile, JSON.stringify(state) + '\n');
-
-  return { url, dir, index: winIdx };
-}
-
-// Point an existing project window's TUI at `session` by relaunching the TUI
-// process (OpenCode v2 exposes no HTTP TUI-steering endpoint).
-function relaunchTui(windowIndex, dir, server, session) {
-  const cmd = tuiAttachCommand(server, session);
-  const tuiPane = tuiPaneId(windowIndex);
-  if (tuiPane) {
-    const respawnR = _tmux(['respawn-pane', '-k', '-t', tuiPane, cmd]);
-    if (respawnR.status !== 0) _tmux(['send-keys', '-t', tuiPane, cmd, 'Enter']);
-  } else {
-    _tmux(['send-keys', '-t', `${SESSION}:${windowIndex}.0`, cmd, 'Enter']);
-  }
-  sleep(0.4);
-  // Keep the project's own window active (switching sessions must not leave
-  // another project's window selected).
-  const active = activeWindowIndex();
-  if (active !== null && active !== windowIndex) {
-    _tmux(['select-window', '-t', `${SESSION}:${windowIndex}`]);
-  }
-  const pane = tuiPaneId(windowIndex);
-  if (pane && !isWindowZoomed(windowIndex)) zoomPane(pane);
-}
-
-// Focus the tmux window belonging to a project directory (best-effort). Used by
-// agentp so the target project's TUI window is the one shown when a prompt runs.
-// Returns the window index, or null when the directory has no window.
-function focusWindowByDir(dir) {
-  const idx = windowByDir(dir);
-  if (idx == null) return null;
-  const activeWin = activeWindowIndex();
-  if (activeWin !== null && activeWin !== idx) {
-    _tmux(['select-window', '-t', `${SESSION}:${idx}`]);
-  }
-  const pane = tuiPaneId(idx);
-  if (pane && !isWindowZoomed(idx)) zoomPane(pane);
-  return idx;
-}
-
-// Close a project's tmux window (no server to stop in the v2 model).
-function closeProjectWindow(windowIndex) {
-  const r = _tmux(['kill-window', '-t', `${SESSION}:${windowIndex}`]);
-  if (r.status !== 0) throw new Error(`failed to kill window ${windowIndex}: ${r.stderr || 'unknown error'}`);
+  return { ok: true, kind: target.kind, instance: target.instance };
 }
 
 module.exports = {
-  SESSION,
-  readState,
-  statefileFor,
-  tuiPaneId,
-  windowByDir,
-  windowNameByIndex,
-  activeWindowIndex,
-  paneCount,
-  listProjects,
-  activateProject,
-  relaunchTui,
-  focusWindowByDir,
-  closeProjectWindow,
-  createProjectWindow,
-  hashDir,
-  logfileFor,
-  sleep,
-  ensureSession,
-  pinWindowName,
-  tuiAttachCommand,
-  isWindowZoomed,
-};
+  tuiArgs,
+  switchTui,
+};

package/lib/opencode.js

@@ -46,10 +46,14 @@ function parseBody(body) {
 
 function makeRequest(options, data, cancelRef, timeoutMs) {
   return new Promise((resolve, reject) => {
+    const cleanup = (req) => {
+      if (cancelRef && cancelRef.current === req) cancelRef.current = null;
+    };
     const req = http.request(options, (res) => {
       let body = '';
       res.on('data', (chunk) => { body += chunk; });
       res.on('end', () => {
+        cleanup(req);
         if (res.statusCode === 401) {
           reject(new Error('OpenCode server authentication failed. Set OPENCODE_SERVER_PASSWORD to match the server password.'));
         } else {
@@ -60,10 +64,14 @@ function makeRequest(options, data, cancelRef, timeoutMs) {
     if (timeoutMs) {
       req.setTimeout(timeoutMs, () => {
         req.destroy();
+        cleanup(req);
         reject(new Error('Request timed out'));
       });
     }
-    req.on('error', reject);
+    req.on('error', (err) => {
+      cleanup(req);
+      reject(err);
+    });
     if (cancelRef) cancelRef.current = req;
     if (data) req.write(data);
     req.end();
@@ -159,6 +167,8 @@ function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
       if (callbacks.onConnected) callbacks.onConnected();
       let buffer = '';
       let collected = '';
+      let currentTextStart = null;
+      let currentTextHadDelta = false;
       let resolved = false;
       let completionTimer = null;
 
@@ -248,12 +258,12 @@ function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
           }
           if (!data || typeof data !== 'object') continue;
 
+          if (sessionId && data.sessionID && String(data.sessionID) !== String(sessionId)) continue;
+
           // Interrupted → resolve immediately with what we have. Every other
-          // event counts as activity — including sub-agent events from child
-          // sessions flowing on the same stream — and defers completion: we
-          // only finish after a silent grace window following the last
-          // terminal signal (a long-running tool or sub-agent would otherwise
-          // truncate the answer).
+          // in-scope event counts as activity and defers completion: we only
+          // finish after a silent grace window following the last terminal
+          // signal (a long-running tool would otherwise truncate the answer).
           if (ev.type === 'session.execution.interrupted') {
             sseLog(`  [SSE] session.execution.interrupted for session ${sessionId || 'any'}\n`);
             finishResolve(collected);
@@ -261,8 +271,6 @@ function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
           }
           cancelCompletion();
 
-          if (sessionId && data.sessionID && String(data.sessionID) !== String(sessionId)) continue;
-
           if (ev.type === 'session.text.started') {
             // v2 emits one text segment per step; separate them so the answer
             // doesn't run adjacent segments together (as the TUI shows them).
@@ -271,13 +279,35 @@ function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
               if (callbacks.onText) callbacks.onText(sep);
               collected += sep;
             }
+            currentTextStart = collected.length;
+            currentTextHadDelta = false;
           } else if (ev.type === 'session.text.delta') {
             if (data.delta != null && data.delta !== '') {
+              if (currentTextStart === null) {
+                currentTextStart = collected.length;
+                currentTextHadDelta = false;
+              }
               if (callbacks.onText) callbacks.onText(data.delta);
               collected += data.delta;
+              currentTextHadDelta = true;
             }
           } else if (ev.type === 'session.text.ended') {
-            if (collected === '' && data.text != null) collected = data.text;
+            if (data.text != null) {
+              if (currentTextStart === null) {
+                if (collected !== '' && !collected.endsWith('\n\n')) {
+                  const sep = '\n\n';
+                  if (callbacks.onText) callbacks.onText(sep);
+                  collected += sep;
+                }
+                currentTextStart = collected.length;
+                currentTextHadDelta = false;
+              }
+              const replacement = String(data.text);
+              collected = collected.slice(0, currentTextStart) + replacement;
+              if (!currentTextHadDelta && callbacks.onText && replacement) callbacks.onText(replacement);
+              currentTextStart = null;
+              currentTextHadDelta = false;
+            }
           } else if (ev.type === 'session.reasoning.delta') {
             if (data.delta != null && data.delta !== '' && callbacks.onThinking) callbacks.onThinking(data.delta);
           } else if (ev.type === 'session.execution.started' || ev.type === 'session.retry.scheduled') {
@@ -322,16 +352,129 @@ async function getActiveSessions(server) {
 // List all sessions from the OpenCode server, optionally filtered by project
 // directory (exact match on the session's location.directory).
 async function listSessions(server, directory) {
-  let url = `${await apiBase(server)}/session`;
-  if (directory) url += '?directory=' + encodeURIComponent(directory);
+  const base = `${await apiBase(server)}/session`;
+  let cursor = null;
+  const seen = new Set();
+  const sessions = [];
+  do {
+    const params = new URLSearchParams();
+    params.set('limit', '200');
+    if (directory) params.set('directory', directory);
+    if (cursor) params.set('cursor', cursor);
+    const { status, body } = await makeRequest(buildJsonRequest(`${base}?${params}`, 'GET'));
+    if (status !== 200) throw new Error(`Failed to list sessions: ${status}`);
+    const parsed = JSON.parse(body);
+    const page = parsed && typeof parsed === 'object' && Array.isArray(parsed.data)
+      ? parsed.data
+      : (Array.isArray(parsed) ? parsed : []);
+    sessions.push(...page);
+    const next = parsed && parsed.cursor && parsed.cursor.next;
+    cursor = typeof next === 'string' && next && !seen.has(next) ? next : null;
+    if (cursor) seen.add(cursor);
+  } while (cursor);
+  return sessions;
+}
+
+// List projects known to the connected OpenCode data store.
+async function listProjects(server) {
+  const url = `${await apiBase(server)}/project`;
   const { status, body } = await makeRequest(buildJsonRequest(url, 'GET'));
-  if (status !== 200) throw new Error(`Failed to list sessions: ${status}`);
-  return parseBody(body);
+  if (status !== 200) throw new Error(`Failed to list projects: ${status}`);
+  const result = parseBody(body);
+  return Array.isArray(result) ? result : [];
 }
 
-// Send a message directly to a specific session. Attaches to the event stream
-// FIRST (so no events are missed), then posts a steered prompt, and resolves
-// with the collected text when execution completes.
+// Wait for OpenCode's foreground execution drain to become idle. The v2 wait
+// endpoint follows successor executions admitted during cleanup, unlike a
+// client-side silence timer. Returns false only when an older v2 server does
+// not implement the experimental route.
+async function waitForSessionIdle(server, sessionId, cancelRef) {
+  const encoded = encodeURIComponent(sessionId);
+  const base = await apiBase(server);
+  const { status } = await makeRequest(
+    buildJsonRequest(`${base}/experimental/session/${encoded}/wait`, 'POST'),
+    null,
+    cancelRef,
+  );
+  if (status === 204) return true;
+  if (status === 404 || status === 503) return false;
+  throw new Error(`Failed to wait for session: ${status}`);
+}
+
+// Read message pages newest-first until the submitted prompt is found. The
+// returned array contains only messages newer than that prompt, in timeline
+// order. This avoids loading an entire long session while still respecting the
+// API's pagination contract.
+async function messagesAfterPrompt(server, sessionId, promptId, cancelRef) {
+  const encoded = encodeURIComponent(sessionId);
+  const base = await apiBase(server);
+  let cursor = null;
+  const seen = new Set();
+  const newer = [];
+  do {
+    const params = new URLSearchParams({ limit: '200', order: 'desc' });
+    if (cursor) {
+      params.delete('order');
+      params.set('cursor', cursor);
+    }
+    const url = `${base}/session/${encoded}/message?${params}`;
+    const { status, body } = await makeRequest(buildJsonRequest(url, 'GET'), null, cancelRef);
+    if (status !== 200) throw new Error(`Failed to read session messages: ${status}`);
+    const parsed = JSON.parse(body);
+    const page = parsed && typeof parsed === 'object' && Array.isArray(parsed.data)
+      ? parsed.data
+      : (Array.isArray(parsed) ? parsed : []);
+    for (const message of page) {
+      if (String(message.id) === String(promptId)) return newer.reverse();
+      newer.push(message);
+    }
+    const next = parsed && parsed.cursor && parsed.cursor.next;
+    cursor = typeof next === 'string' && next && !seen.has(next) ? next : null;
+    if (cursor) seen.add(cursor);
+  } while (cursor);
+  throw new Error(`Submitted prompt ${promptId} was not found in session messages`);
+}
+
+function answerFromTurn(messages) {
+  const idle = messages.findIndex(message => message && message.type === 'idle');
+  const turn = idle === -1 ? messages : messages.slice(0, idle);
+  const text = [];
+  for (const message of turn) {
+    if (!message || message.type !== 'assistant' || !Array.isArray(message.content)) continue;
+    for (const part of message.content) {
+      if (part && part.type === 'text' && part.text != null && part.text !== '') text.push(String(part.text));
+    }
+  }
+  return text.join('\n\n');
+}
+
+async function readTurnAnswer(server, sessionId, promptId, cancelRef) {
+  return answerFromTurn(await messagesAfterPrompt(server, sessionId, promptId, cancelRef));
+}
+
+// Compatibility fallback for v2 servers predating the wait route. Do not use a
+// deadline that can turn a valid long response into a successful partial one:
+// wait until the submitted prompt is projected and a newer idle transition is
+// visible while the process reports no active drain.
+async function pollForSessionIdle(server, sessionId, promptId, admittedAt, cancelRef) {
+  for (;;) {
+    let messages = null;
+    try { messages = await messagesAfterPrompt(server, sessionId, promptId, cancelRef); } catch {}
+    const hasIdle = messages && messages.some(message => message && message.type === 'idle');
+    const active = await getActiveSessions(server);
+    let idle = 0;
+    try {
+      const session = await getSession(server, sessionId);
+      idle = session && session.time && session.time.idle || 0;
+    } catch {}
+    if (hasIdle && !active.has(String(sessionId)) && (!admittedAt || idle >= admittedAt)) return;
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+}
+
+// Send a message directly to a specific session. Prompt admission gives us a
+// durable message ID; wait for OpenCode to become idle, then reconstruct the
+// answer from projected messages so missed/late SSE deltas cannot truncate it.
 async function sendToSession(server, sessionId, text, agent, cancelRef) {
   const encoded = encodeURIComponent(sessionId);
   const base = await apiBase(server);
@@ -340,32 +483,27 @@ async function sendToSession(server, sessionId, text, agent, cancelRef) {
     const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}/agent`, 'POST', body), body);
     if (status !== 200 && status !== 204) throw new Error(`Failed to set agent: ${status}`);
   }
-  let sendAt = Date.now();
-  let verifyTries = 0;
-  return listenV2(server, sessionId, {}, cancelRef, null, {
-    start: async () => {
-      const body = JSON.stringify({ text, delivery: 'steer' });
-      const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}/prompt`, 'POST', body), body, cancelRef);
-      if (status !== 200) throw new Error(`Failed to send to session: ${status}`);
-      sendAt = Date.now();
-    },
-    // After a quiescence candidate, only treat the turn as done when the
-    // session's idle marker is newer than our send — otherwise the terminal
-    // signal probably belonged to an older queued execution (which would
-    // produce an empty/partial answer). Give up after a few tryouts so a
-    // stalled session can't hang the caller forever.
-    verify: async () => {
-      verifyTries++;
-      if (verifyTries > 5) return true;
-      try {
-        const s = await getSession(server, sessionId);
-        const idle = s && s.time && s.time.idle;
-        return !!(idle && idle >= sendAt - 1000);
-      } catch {
-        return true; // cannot verify → trust the quiescence window
-      }
-    },
-  });
+  const body = JSON.stringify({ text, delivery: 'steer' });
+  const { status, body: responseBody } = await makeRequest(
+    buildJsonRequest(`${base}/session/${encoded}/prompt`, 'POST', body),
+    body,
+    cancelRef,
+  );
+  if (status !== 200) throw new Error(`Failed to send to session: ${status}`);
+  let admitted;
+  try { admitted = parseBody(responseBody); } catch {}
+  const promptId = admitted && admitted.id;
+  if (!promptId) throw new Error('OpenCode did not return the submitted prompt ID');
+
+  const supported = await waitForSessionIdle(server, sessionId, cancelRef);
+  if (!supported) {
+    // Confirm the session still exists before interpreting a 404 as an older
+    // server without the experimental route.
+    await getSession(server, sessionId);
+    const admittedAt = admitted.time && admitted.time.created;
+    await pollForSessionIdle(server, sessionId, promptId, admittedAt, cancelRef);
+  }
+  return readTurnAnswer(server, sessionId, promptId, cancelRef);
 }
 
 // Create a new session. Optionally set a title and pin it to a project
@@ -740,7 +878,12 @@ module.exports = {
   listenForFinalAnswer,
   respondToQuestion,
   listSessions,
+  listProjects,
   getActiveSessions,
+  waitForSessionIdle,
+  messagesAfterPrompt,
+  answerFromTurn,
+  readTurnAnswer,
   getSession,
   createSession,
   updateSession,
@@ -768,4 +911,4 @@ module.exports = {
   _setApiVersion,
   _resetApiCache,
   _setCompletionGraceMs,
-};
+};

package/lib/project-state.js

@@ -60,6 +60,9 @@ function normalizeState(raw, statefile) {
   const annotations = state.annotations && typeof state.annotations === 'object' && !Array.isArray(state.annotations)
     ? state.annotations
     : {};
+  const broadcast = Array.isArray(state.broadcast)
+    ? state.broadcast.filter(x => typeof x === 'string' && x)
+    : null;
   return {
     file: statefile,
     version: typeof state.version === 'number' ? state.version : 1,
@@ -68,6 +71,7 @@ function normalizeState(raw, statefile) {
     server,
     status,
     annotations,
+    broadcast,
   };
 }
 
@@ -109,6 +113,10 @@ function writeProjectState(statefile, patch) {
   if (patch.session !== undefined) next.session = patch.session;
   if (patch.server !== undefined) next.server = patch.server;
   if (patch.status !== undefined) next.status = patch.status;
+  if (patch.broadcast !== undefined) {
+    if (Array.isArray(patch.broadcast) && patch.broadcast.length >= 2) next.broadcast = [...patch.broadcast];
+    else delete next.broadcast;
+  }
   const tmp = statefile + '.tmp';
   fs.writeFileSync(tmp, JSON.stringify(next) + '\n');
   fs.renameSync(tmp, statefile);