agentp 2.0.0 → 2.1.0

package/bin/agentp

@@ -18,9 +18,9 @@ const {
   selectSession,
   sortSessionsByRecency,
   interruptSession,
+  getActiveSessions,
 } = require('../lib/opencode');
 const projectState = require('../lib/project-state');
-const ocmuxLib = require('../lib/ocmux');
 
 const TGAGENTP_PORT_FILE = '/tmp/tgagentp-port';
 
@@ -168,7 +168,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 +177,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 +197,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 +209,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 +278,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 +425,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 +553,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 +576,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 +590,7 @@ function spawnDeferredChild({ promptText, serverBase, sessionName, newSession, q
     defer: deferSeconds || 0,
     server: serverBase,
     sessionId: targetSessionId,
+    sessionIds: targetSessionIds,
     cancelled: false,
   };
 
@@ -488,7 +608,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 +645,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 +748,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 +978,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 +1005,7 @@ async function main() {
       tgMode,
       flushMode,
       targetSessionId,
+      targetSessionIds: broadcastIds,
       deferSeconds,
     });
 
@@ -938,15 +1080,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 +1105,7 @@ async function main() {
       tgMode,
       flushMode,
       targetSessionId,
+      targetSessionIds: broadcastIds,
       deferSeconds: 0,
     });
 
@@ -993,34 +1141,62 @@ 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) {
+      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,
+      });
+
+      // Prepend the session's annotation (if any) to the prompt. TUI routing is
+      // owned by explicit ocmux session switches, not by prompt submission.
+      let prompt = actualPromptText;
+      try {
+        if (ctx && ctx.statefile) {
+          const ann = projectState.readAnnotations(ctx.statefile)[sessionId];
+          if (ann) prompt = ann + '\n\n' + actualPromptText;
+        }
+      } catch {
+        // Annotation lookup is best-effort.
       }
-      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 +1281,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 };