agentp 2.0.0 → 2.0.1

package/README.md

@@ -214,7 +214,8 @@ The ticket is `agentp_ticket` followed by a JSON object with these fields:
 - `ctime` — creation timestamp (ISO 8601). Only used to compute `elapsed`.
 - `path` — path to the temp file holding the result.
 - `server` — OpenCode server URL used by the deferred job.
-- `sessionId` — OpenCode session ID used by the deferred job.
+- `sessionId` — OpenCode session ID used by a normal deferred job.
+- `sessionIds` — array of OpenCode session IDs used by a **broadcast** deferred job (replaces `sessionId`).
 - `elapsed` — seconds since `ctime`, included only when the ticket is re-printed (not on first print).
 - `defer` — the timeout requested at submission, included only when it was > 0.
 - `cancelled` — always present (defaults to `false`). Set it to `true` and pipe the ticket back to cancel the running job (see below).
@@ -229,6 +230,13 @@ printf "Refactor the auth module" | agentp --defer --onlineTicket
 
 Both formats are accepted when piping a ticket back to `agentp --defer`.
 
+When `ocmux` has a broadcast selection, `agentp --defer` creates a ticket with
+`sessionIds` and sends the prompt to every selected session. On retrieval,
+`--qa` includes the original prompt plus one `💬 <name> [<id>]` answer section
+per session. Individual failures/incomplete sessions are listed with an error
+and timestamp. Broadcast tickets do **not** support queued follow-up text (a
+follow-up is inherently ambiguous across multiple sessions).
+
 You can also append follow-up text after a not-yet-ready ticket to queue more
 input into the original running task, similar to typing into the OpenCode TUI
 while the agent is busy:
@@ -328,10 +336,25 @@ Without arguments (and with a TTY), opens an **interactive session picker** for
 the project found upward from `<directory>` (default: `$PWD`):
 
 - sessions are listed most-recently-viewed first
-- `Enter`/`Space` switches (menu stays open) · `n` create (name input) ·
-  `r` rename (edit in place) · `R` set a reminder · `d` delete (confirm) ·
-  `a` switch agent · `m` switch model · `p` project switcher · `h` help ·
-  `q`/`Ctrl+C` quit
+- `/` starts an **incremental search** of the list (matches title/id,
+  case-insensitive, space-separated tokens are ANDed). While the search line is
+  active it shows `Enter: confirm · Esc: cancel` on the right: `Enter` keeps the
+  filter and returns to normal navigation, `ESC` clears it, `/` resumes editing
+  it, and `Backspace` on an already-empty search also exits it. The same `/`
+  search works in the model/agent pickers and the project switcher.
+- `Enter` switches (menu stays open). `Space` over a different session enters
+  **broadcast mode**: Space selects/deselects sessions; `Enter` keeps the list
+  and switches normally; `ESC`/`q` cancels back to the session list and returns
+  the TUI to the stored session; deselecting down to a single session selects
+  that remaining session. New selections open in the TUI for inspection.
+  Broadcast mode also has `h` help, `d` delete, and `m` to change the model for
+  every selected session.
+- `n` create (name input) · `r` rename (edit in place) · `R` set a reminder ·
+  `d` delete (confirm) · `a` switch agent · `m` switch model · `p` project
+  switcher · `h` help · `q` quit
+- **`q` only quits the session picker.** In every other menu (model/agent
+  pickers, project switcher, help/input prompts) `q`/`ESC` just closes that menu
+  and returns to the previous one. **`Ctrl+C` fully exits** `ocmux` from any menu.
 - switching updates `.ocmux.json` and relaunches the TUI on the chosen session
   (`opencode --server <url> --session <id>`); silent on success
 - new sessions inherit the model of the previously selected session (v2
@@ -340,6 +363,11 @@ the project found upward from `<directory>` (default: `$PWD`):
 Reminders (`R`) are stored in the `.ocmux.json` `annotations` map; `agentp`
 prepends a session's reminder to every prompt sent to it.
 
+Broadcast selections are stored in `.ocmux.json` as `broadcast`. `agentp`
+sends a prompt to all selected sessions (waiting for busy sessions to go idle),
+and prints a labeled answer section for each. Errors/incomplete targets are
+reported individually with session name, id, error, and timestamp.
+
 Subcommands:
 
 - **`serve [--server <url>] [--git|--GIT] [dir]`** — create a project TUI window

package/bin/agentp

@@ -18,6 +18,7 @@ const {
   selectSession,
   sortSessionsByRecency,
   interruptSession,
+  getActiveSessions,
 } = require('../lib/opencode');
 const projectState = require('../lib/project-state');
 const ocmuxLib = require('../lib/ocmux');
@@ -168,7 +169,7 @@ function parseDeferredTicketInput(text) {
   if (!data || typeof data.path !== 'string' || !data.path) return null;
   const rest = afterPrefix.slice(jsonEnd);
   const followupText = rest.trim() ? stripFollowupRow(rest.trimStart()) : '';
-  return {
+  const ticket = {
     ctime: typeof data.ctime === 'string' ? data.ctime : null,
     path: data.path,
     defer: typeof data.defer === 'number' && data.defer > 0 ? data.defer : 0,
@@ -177,6 +178,10 @@ function parseDeferredTicketInput(text) {
     cancelled: data.cancelled === true,
     followupText,
   };
+  if (Array.isArray(data.sessionIds)) {
+    ticket.sessionIds = data.sessionIds.filter(x => typeof x === 'string' && x);
+  }
+  return ticket;
 }
 
 function parseDeferredTicket(text) {
@@ -193,6 +198,7 @@ function formatTicket(ticket, elapsed, compact) {
   const fields = { ctime: ticket.ctime, path: ticket.path };
   if (ticket.server) fields.server = ticket.server;
   if (ticket.sessionId) fields.sessionId = ticket.sessionId;
+  if (Array.isArray(ticket.sessionIds) && ticket.sessionIds.length > 0) fields.sessionIds = ticket.sessionIds;
   if (elapsed !== undefined) fields.elapsed = elapsed;
   if (ticket.defer > 0) fields.defer = ticket.defer;
   // Always present so it can be flipped to true and piped back to cancel.
@@ -204,8 +210,12 @@ function formatTicket(ticket, elapsed, compact) {
 // the ticket. Prints a message and exits 0.
 async function cancelTicket(ticket) {
   let interrupted = false;
-  if (ticket.server && ticket.sessionId) {
-    interrupted = await interruptSession(ticket.server, ticket.sessionId);
+  const ids = Array.isArray(ticket.sessionIds) && ticket.sessionIds.length > 0
+    ? ticket.sessionIds
+    : (ticket.sessionId ? [ticket.sessionId] : []);
+  if (ticket.server && ids.length > 0) {
+    const interruptedAll = await Promise.all(ids.map(id => interruptSession(ticket.server, id)));
+    interrupted = interruptedAll.some(Boolean);
   }
   try { fs.unlinkSync(ticket.path); } catch {}
   try { fs.unlinkSync(ticket.path + '.lock'); } catch {}
@@ -269,7 +279,9 @@ async function resolveTargetSession(serverBase, sessionName, newSession, opts =
   }
 
   if (sessions && sessions.length > 0) {
-    const sorted = sortSessionsByRecency(sessions).filter(s => s.id);
+    // Only "main" sessions (no parentID) are considered as implicit targets —
+    // child/subagent sessions are work products, not conversation targets.
+    const sorted = sortSessionsByRecency(sessions).filter(s => s.id && !s.parentID);
     if (sorted.length > 0) return sorted[0].id;
   }
 
@@ -414,6 +426,114 @@ function outputReadyResult(filePath, result, qaMode, unusedFollowupText, header)
   process.exit(0);
 }
 
+// ── Broadcast (ocmux "Space" multi-session send) ───────────────────
+
+// One answer section: a heading with the session name and a separator below it.
+function buildBroadcastSection(title, id, answer) {
+  let s = `\n💬 ${title} [${id}]\n${'━'.repeat(40)}\n`;
+  s += answer;
+  if (!answer.endsWith('\n')) s += '\n';
+  return s;
+}
+
+// Send a prompt to every session in `ids` and collect the answers.
+//   deps.getActiveSessions(server) -> Set of busy session ids
+//   deps.getSession(server, id)    -> session object (title)
+//   deps.sendToSession(server, id, text) -> answer text
+//   deps.readBroadcast()           -> current .ocmux.json broadcast list (null/[] = cancelled)
+// Waits for each session to become idle before sending; stops as soon as the
+// broadcast list disappears (ocmux exited broadcast mode early).
+async function runBroadcastSend(server, ids, prompt, deps) {
+  const { getActiveSessions, getSession, sendToSession, readBroadcast, getPrompt, pollMs = 1000, busyTimeoutMs = 15 * 60 * 1000 } = deps;
+  const initial = new Set(ids.map(String));
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  const cancelled = () => {
+    try { return !isBroadcastActive(readBroadcast(), initial); } catch { return false; }
+  };
+
+  // Race a sent session's answer against ocmux leaving broadcast mode. We do
+  // not interrupt the model: we merely stop waiting/discard its later answer,
+  // exactly as the UI contract promises.
+  const awaitAnswerOrCancel = (promise) => new Promise((resolve) => {
+    let done = false;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      clearInterval(timer);
+      resolve(value);
+    };
+    const timer = setInterval(() => {
+      if (cancelled()) finish({ cancelled: true });
+    }, pollMs);
+    promise.then(answer => finish({ answer }), err => finish({ error: err }));
+  });
+
+  const runOne = async (id) => {
+    let title = id;
+    try {
+      const s = await getSession(server, id);
+      title = (s && (s.title || s.id)) || id;
+    } catch {
+      return { missing: { id, title, error: 'Unable to read session', timestamp: new Date().toISOString() } };
+    }
+    // Wait for the session to become idle (skip prompts into a busy session).
+    const deadline = Date.now() + busyTimeoutMs;
+    let busy = true;
+    while (busy && Date.now() < deadline) {
+      if (cancelled()) {
+        return { missing: { id, title, error: 'Broadcast cancelled while waiting for idle', timestamp: new Date().toISOString() } };
+      }
+      const active = await getActiveSessions(server);
+      if (!active.has(String(id))) busy = false;
+      else await sleep(pollMs);
+    }
+    if (busy) {
+      return { missing: { id, title, error: 'Session stayed busy until timeout', timestamp: new Date().toISOString() } };
+    }
+    try {
+      const result = await awaitAnswerOrCancel(sendToSession(server, id, getPrompt ? getPrompt(id, prompt) : prompt));
+      if (result.cancelled) {
+        return { missing: { id, title, error: 'Broadcast cancelled before this session replied', timestamp: new Date().toISOString() } };
+      }
+      if (result.error) {
+        return { missing: { id, title, error: result.error.message || String(result.error), timestamp: new Date().toISOString() } };
+      }
+      return { result: { id, title, answer: result.answer } };
+    } catch (err) {
+      return { missing: { id, title, error: err.message || String(err), timestamp: new Date().toISOString() } };
+    }
+  };
+
+  // Run independently so one busy/model-limited session never prevents all
+  // other selected sessions from receiving the prompt.
+  const settled = await Promise.all(ids.map(runOne));
+  const results = settled.filter(x => x.result).map(x => x.result);
+  const missing = settled.filter(x => x.missing).map(x => x.missing);
+  return { results, missing, requested: ids.length };
+}
+
+// A broadcast list is still active while it is an array that contains every
+// session we were asked to reach.
+function isBroadcastActive(broadcast, initial) {
+  return Array.isArray(broadcast)
+    && broadcast.length >= 2
+    && [...initial].every((id) => broadcast.includes(id));
+}
+
+// Assemble the final broadcast output: heading per session + missing note.
+function formatBroadcastResults({ results, missing, requested }) {
+  let out = `🌐 Broadcast to ${requested} sessions\n`;
+  for (const r of results) out += buildBroadcastSection(r.title, r.id, r.answer);
+  if (missing.length > 0) {
+    out += '\n⚠️  Prompt not completed in the following sessions:\n';
+    for (const m of missing) {
+      out += `- 💬 ${m.title} [${m.id}]\n  - Error: ${m.error || 'Unknown'}\n`;
+      if (m.timestamp) out += `  - At: ${m.timestamp}\n`;
+    }
+  }
+  return out;
+}
+
 // Structured header (project path + session id/title) prepended to --qa output,
 // so a piped answer is self-describing about where it came from.
 async function buildSessionHeader(server, sessionId) {
@@ -434,7 +554,7 @@ async function buildSessionHeader(server, sessionId) {
 
 // Header for deferred-ticket retrieval (ticket carries server + sessionId).
 async function ticketHeader(ticket, qaMode) {
-  if (qaMode && ticket && ticket.server && ticket.sessionId) {
+  if (qaMode && ticket && ticket.server && ticket.sessionId && !(Array.isArray(ticket.sessionIds) && ticket.sessionIds.length >= 2)) {
     try { return await buildSessionHeader(ticket.server, ticket.sessionId); } catch {}
   }
   return '';
@@ -457,7 +577,7 @@ const FINAL_ROW = '    —————————————————\n';
 // Write the prompt to a temp file, lock the output file, and spawn a detached
 // `--defer-child` process that runs the prompt and writes the answer. Returns
 // the ticket describing this deferred run.
-function spawnDeferredChild({ promptText, serverBase, sessionName, newSession, qaMode, tgMode, flushMode, targetSessionId, deferSeconds }) {
+function spawnDeferredChild({ promptText, serverBase, sessionName, newSession, qaMode, tgMode, flushMode, targetSessionId, targetSessionIds, deferSeconds }) {
   const tempPath = generateTempFilename();
   const promptTempPath = tempPath + '.prompt';
 
@@ -471,6 +591,7 @@ function spawnDeferredChild({ promptText, serverBase, sessionName, newSession, q
     defer: deferSeconds || 0,
     server: serverBase,
     sessionId: targetSessionId,
+    sessionIds: targetSessionIds,
     cancelled: false,
   };
 
@@ -488,7 +609,10 @@ function spawnDeferredChild({ promptText, serverBase, sessionName, newSession, q
     childArgs.push('--session', sessionName);
     if (newSession) childArgs.push('--new');
   }
-  childArgs.push('--resolved-session-id', targetSessionId);
+  if (targetSessionId) childArgs.push('--resolved-session-id', targetSessionId);
+  if (Array.isArray(targetSessionIds) && targetSessionIds.length > 0) {
+    childArgs.push('--resolved-session-ids', JSON.stringify(targetSessionIds));
+  }
   childArgs.push(serverBase);
 
   const child = child_process.spawn(process.execPath, childArgs, {
@@ -522,6 +646,7 @@ async function main() {
   let outputFile = null;
   let sessionName = null;
   let resolvedSessionId = null;
+  let resolvedSessionIds = null;
   let newSession = false;
   // tgMode: false = disabled, 'auto' = auto-detect, true = explicit --tg
   let tgMode = null;
@@ -624,6 +749,16 @@ async function main() {
         console.error('Error: --resolved-session-id requires a session id');
         process.exit(1);
       }
+    } else if (args[i] === '--resolved-session-ids') {
+      i++;
+      try {
+        const ids = JSON.parse(args[i]);
+        if (!Array.isArray(ids) || ids.length < 2 || ids.some(id => typeof id !== 'string' || !id)) throw new Error('bad ids');
+        resolvedSessionIds = ids;
+      } catch {
+        console.error('Error: --resolved-session-ids requires a JSON array of at least two session ids');
+        process.exit(1);
+      }
     } else if (args[i] === '--new') {
       newSession = true;
     } else if (args[i] === '--getLast') {
@@ -844,15 +979,22 @@ async function main() {
     }
 
     // This is a regular prompt — create deferred execution
-    let targetSessionId;
-    try {
-      targetSessionId = await resolveTargetSession(serverBase, sessionName, newSession, {
-        directory: projectDir,
-        preferredSession,
-      });
-    } catch (err) {
-      console.error(err.message);
-      process.exit(1);
+    const broadcastIds = (resolvedSessionIds && resolvedSessionIds.length >= 2)
+      ? resolvedSessionIds
+      : ((ctx && ctx.state && Array.isArray(ctx.state.broadcast) && ctx.state.broadcast.length >= 2)
+        ? ctx.state.broadcast
+        : null);
+    let targetSessionId = null;
+    if (!broadcastIds) {
+      try {
+        targetSessionId = await resolveTargetSession(serverBase, sessionName, newSession, {
+          directory: projectDir,
+          preferredSession,
+        });
+      } catch (err) {
+        console.error(err.message);
+        process.exit(1);
+      }
     }
 
     const newTicket = spawnDeferredChild({
@@ -864,6 +1006,7 @@ async function main() {
       tgMode,
       flushMode,
       targetSessionId,
+      targetSessionIds: broadcastIds,
       deferSeconds,
     });
 
@@ -938,15 +1081,20 @@ async function main() {
     }
 
     // Regular prompt: submit via a detached child and wait for the answer.
-    let targetSessionId;
-    try {
-      targetSessionId = await resolveTargetSession(serverBase, sessionName, newSession, {
-        directory: projectDir,
-        preferredSession,
-      });
-    } catch (err) {
-      console.error(err.message);
-      process.exit(1);
+    const broadcastIds = (ctx && ctx.state && Array.isArray(ctx.state.broadcast) && ctx.state.broadcast.length >= 2)
+      ? ctx.state.broadcast
+      : null;
+    let targetSessionId = null;
+    if (!broadcastIds) {
+      try {
+        targetSessionId = await resolveTargetSession(serverBase, sessionName, newSession, {
+          directory: projectDir,
+          preferredSession,
+        });
+      } catch (err) {
+        console.error(err.message);
+        process.exit(1);
+      }
     }
 
     const newTicket = spawnDeferredChild({
@@ -958,6 +1106,7 @@ async function main() {
       tgMode,
       flushMode,
       targetSessionId,
+      targetSessionIds: broadcastIds,
       deferSeconds: 0,
     });
 
@@ -993,34 +1142,64 @@ async function main() {
   // Wrap main processing in try-catch for deferChildMode to write errors to output file
   let tgError = null;
   async function runMain() {
-    const sessionId = resolvedSessionId || await resolveTargetSession(serverBase, sessionName, newSession, {
-      directory: projectDir,
-      preferredSession,
-    });
+    // Broadcast mode: ocmux's Space key selected multiple sessions in
+    // .ocmux.json — send the prompt to all of them.
+    const broadcastIds = (ctx && ctx.state && Array.isArray(ctx.state.broadcast) && ctx.state.broadcast.length >= 2)
+      ? ctx.state.broadcast
+      : null;
 
-    // v2: focus the target project's TUI window so the user sees the prompt
-    // stream, and prepend the session's annotation (if any) to the prompt.
-    let prompt = actualPromptText;
-    try {
-      if (ctx && ctx.statefile) {
-        const ann = projectState.readAnnotations(ctx.statefile)[sessionId];
-        if (ann) prompt = ann + '\n\n' + actualPromptText;
+    let sessionId = null;
+    let answer;
+    if (broadcastIds) {
+      try { if (projectDir) ocmuxLib.focusWindowByDir(projectDir); } catch {}
+      const bres = await runBroadcastSend(serverBase, broadcastIds, actualPromptText, {
+        getActiveSessions,
+        getSession,
+        sendToSession,
+        getPrompt: (id, text) => {
+          try {
+            const ann = ctx && ctx.statefile && projectState.readAnnotations(ctx.statefile)[id];
+            return ann ? ann + '\n\n' + text : text;
+          } catch {
+            return text;
+          }
+        },
+        readBroadcast: () => (ctx && ctx.statefile ? projectState.readProjectState(ctx.statefile).broadcast : null),
+      });
+      answer = formatBroadcastResults(bres);
+    } else {
+      sessionId = resolvedSessionId || await resolveTargetSession(serverBase, sessionName, newSession, {
+        directory: projectDir,
+        preferredSession,
+      });
+
+      // v2: focus the target project's TUI window so the user sees the prompt
+      // stream, and prepend the session's annotation (if any) to the prompt.
+      let prompt = actualPromptText;
+      try {
+        if (ctx && ctx.statefile) {
+          const ann = projectState.readAnnotations(ctx.statefile)[sessionId];
+          if (ann) prompt = ann + '\n\n' + actualPromptText;
+        }
+        if (projectDir) ocmuxLib.focusWindowByDir(projectDir);
+      } catch {
+        // tmux focus is best-effort; never fail the prompt because of it
       }
-      if (projectDir) ocmuxLib.focusWindowByDir(projectDir);
-    } catch {
-      // tmux focus is best-effort; never fail the prompt because of it
-    }
 
-    let answer;
-    try {
-      answer = await sendToSession(serverBase, sessionId, prompt);
-    } catch (err) {
-      throw new Error(`Error sending prompt: ${err.message}`);
+      try {
+        answer = await sendToSession(serverBase, sessionId, prompt);
+      } catch (err) {
+        throw new Error(`Error sending prompt: ${err.message}`);
+      }
     }
 
     // Build the message to send to Telegram (QA pair with rulers)
     let tgMessage = answer;
-    if (qaMode) {
+    if (qaMode && broadcastIds) {
+      tgMessage = HUMAN_ROW + actualPromptText + AGENT_ROW + answer;
+      if (!answer.endsWith('\n')) tgMessage += '\n';
+      tgMessage += FINAL_ROW;
+    } else if (qaMode && !broadcastIds) {
       let header = '';
       try { header = await buildSessionHeader(serverBase, sessionId); } catch {}
       tgMessage = header + HUMAN_ROW + actualPromptText + AGENT_ROW + answer;
@@ -1105,4 +1284,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { main, notifyAgentpGateway, readAllStdin, parseDeferredTicket, parseDeferredTicketInput, formatTicket, waitForDeferredResult, waitForDeferredResultForever };
+module.exports = { main, notifyAgentpGateway, readAllStdin, parseDeferredTicket, parseDeferredTicketInput, formatTicket, waitForDeferredResult, waitForDeferredResultForever, runBroadcastSend, buildBroadcastSection, formatBroadcastResults, isBroadcastActive };