agentp 1.14.0 → 2.0.1

package/bin/agentp

@@ -13,9 +13,15 @@ const {
   sendToSessionAsync,
   listSessions,
   createSession,
+  createSessionWithModel,
   getSession,
   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';
 
@@ -163,14 +169,19 @@ 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,
     server: typeof data.server === 'string' ? data.server : null,
     sessionId: typeof data.sessionId === 'string' ? data.sessionId : null,
+    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) {
@@ -187,20 +198,58 @@ 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.
+  fields.cancelled = ticket.cancelled === true;
   return 'agentp_ticket ' + (compact ? JSON.stringify(fields) : JSON.stringify(fields, null, 2));
 }
 
-async function resolveTargetSession(serverBase, sessionName, newSession) {
+// Cancel a deferred ticket: interrupt the session (ESC-equivalent) and discard
+// the ticket. Prints a message and exits 0.
+async function cancelTicket(ticket) {
+  let interrupted = false;
+  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 {}
+  removeQueuedFollowups(ticket.path);
+  process.stdout.write(`\n🚫 Prompt cancelled${interrupted ? '' : ' (or already finished)'}.\n`);
+  process.exit(0);
+}
+
+// Print a deferred ticket (with elapsed) and exit — used for the interrupt path.
+function printTicketAndExit(ticket, onlineTicket) {
+  const elapsed = ticket && ticket.ctime
+    ? Math.max(0, Math.floor((Date.now() - Date.parse(ticket.ctime)) / 1000))
+    : 0;
+  process.stdout.write(formatTicket(ticket, elapsed, onlineTicket) + '\n');
+  process.exit(0);
+}
+
+async function resolveTargetSession(serverBase, sessionName, newSession, opts = {}) {
+  // opts: { directory, preferredSession } — v2 project/session resolution from
+  // the nearest .ocmux.json. `directory` scopes the listing to the project;
+  // `preferredSession` is a stored session ID validated against that listing.
+  const directory = opts.directory || undefined;
+  const preferredSession = opts.preferredSession || null;
+
   let sessions;
   try {
-    sessions = await listSessions(serverBase);
+    sessions = await listSessions(serverBase, directory);
   } catch (err) {
     throw new Error(`Error connecting to server: ${err.message}`);
   }
 
   if (sessionName) {
+    const byId = sessions.find(s => String(s.id) === sessionName);
+    if (byId) return byId.id;
     const matches = sessions.filter(s => {
       const title = s.title || s.slug || s.id;
       return title.toLowerCase() === sessionName.toLowerCase();
@@ -214,7 +263,7 @@ async function resolveTargetSession(serverBase, sessionName, newSession) {
       if (partial.length > 1) throw new Error(`Error: multiple sessions match "${sessionName}"`);
       if (!newSession) throw new Error(`Error: no session found matching "${sessionName}"`);
       try {
-        const session = await createSession(serverBase, sessionName);
+        const session = await createSessionWithModel(serverBase, sessionName, directory, sessions);
         await selectSession(serverBase, session.id);
         return session.id;
       } catch (err) {
@@ -224,19 +273,20 @@ async function resolveTargetSession(serverBase, sessionName, newSession) {
     return matches[0].id;
   }
 
+  // Prefer the session recorded in .ocmux.json when it still exists.
+  if (preferredSession && sessions.some(s => String(s.id) === String(preferredSession))) {
+    return preferredSession;
+  }
+
   if (sessions && sessions.length > 0) {
-    const sorted = sessions
-      .filter(s => s.time && (s.time.updated || s.time.created))
-      .sort((a, b) => {
-        const aTime = (a.time && a.time.updated) || (a.time && a.time.created) || 0;
-        const bTime = (b.time && b.time.updated) || (b.time && b.time.created) || 0;
-        return bTime - aTime;
-      });
+    // 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;
   }
 
   try {
-    const session = await createSession(serverBase, 'agentp');
+    const session = await createSessionWithModel(serverBase, 'agentp', directory, sessions);
     return session.id;
   } catch (err) {
     throw new Error(`Error creating session: ${err.message}`);
@@ -273,6 +323,41 @@ function sleepMs(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// Wait indefinitely for a deferred result. Resolves with `{ result }` once the
+// answer is ready, or `{ interrupted: true }` if SIGINT is received while
+// waiting (any detached child keeps running). The caller decides how to react
+// to the interrupt (normally print a ticket and exit).
+function waitForDeferredResultForever(filePath) {
+  return new Promise((resolve) => {
+    let timer = null;
+    let done = false;
+
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      if (timer) clearTimeout(timer);
+      process.removeListener('SIGINT', onSigint);
+      resolve(value);
+    };
+
+    function onSigint() {
+      finish({ interrupted: true });
+    }
+
+    const poll = () => {
+      const result = readDeferredResult(filePath);
+      if (result !== null) {
+        finish({ result });
+        return;
+      }
+      timer = setTimeout(poll, DEFER_POLL_MS);
+    };
+
+    process.on('SIGINT', onSigint);
+    poll();
+  });
+}
+
 function appendUnusedFollowup(result, followupText) {
   if (!followupText) return result;
   return result + (result.endsWith('\n') ? '' : '\n') + followupText;
@@ -313,10 +398,166 @@ function injectQueuedFollowups(result, followups) {
   return before + (before.endsWith('\n') ? '' : '\n') + addition + after;
 }
 
-function formatDeferredResult(filePath, result, qaMode, unusedFollowupText) {
+function formatDeferredResult(filePath, result, qaMode, unusedFollowupText, header) {
   const followups = qaMode ? readQueuedFollowups(filePath) : [];
   const output = qaMode ? injectQueuedFollowups(result, followups) : result;
-  return appendUnusedFollowup(output, unusedFollowupText);
+  // The stored answer (produced by the detached child) may already carry the
+  // project/session header — don't prepend it a second time on retrieval.
+  const withHeader = qaMode && header && !carriesHeader(output) ? header + output : output;
+  return appendUnusedFollowup(withHeader, unusedFollowupText);
+}
+
+// Does the text already begin with the 📂 / 💬 header lines?
+function carriesHeader(text) {
+  return /^(?:\u{1F4C2}|\u{1F4AC})/u.test(String(text || '').trimStart());
+}
+
+// Output a ready deferred result, clean up its temp files, and exit 0.
+function outputReadyResult(filePath, result, qaMode, unusedFollowupText, header) {
+  try {
+    fs.unlinkSync(filePath);
+  } catch (err) {
+    process.stdout.write(`Error reading deferred file: ${err.message}\n`);
+    process.exit(1);
+  }
+  try { fs.unlinkSync(filePath + '.lock'); } catch {}
+  process.stdout.write(formatDeferredResult(filePath, result, qaMode, unusedFollowupText, header));
+  removeQueuedFollowups(filePath);
+  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) {
+  let title = sessionId;
+  let dir = '';
+  try {
+    const s = await getSession(server, sessionId);
+    if (s && (s.title || s.id)) title = s.title || s.id;
+    if (s && s.location && s.location.directory) dir = s.location.directory;
+  } catch {
+    // keep the plain id form
+  }
+  let out = '';
+  if (dir) out += `📂 ${dir}\n`;
+  out += `💬 ${title} [${sessionId}]\n`;
+  return out;
+}
+
+// Header for deferred-ticket retrieval (ticket carries server + sessionId).
+async function ticketHeader(ticket, qaMode) {
+  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 '';
 }
 
 async function readAllStdin() {
@@ -333,18 +574,79 @@ const HUMAN_ROW = '👤: —————————————————\n'
 const AGENT_ROW = '🤖: —————————————————\n'
 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, targetSessionIds, deferSeconds }) {
+  const tempPath = generateTempFilename();
+  const promptTempPath = tempPath + '.prompt';
+
+  fs.writeFileSync(promptTempPath, promptText);
+  fs.writeFileSync(tempPath, '');
+  lockFile(tempPath);
+
+  const ticket = {
+    ctime: new Date().toISOString(),
+    path: tempPath,
+    defer: deferSeconds || 0,
+    server: serverBase,
+    sessionId: targetSessionId,
+    sessionIds: targetSessionIds,
+    cancelled: false,
+  };
+
+  const childArgs = [
+    __filename,
+    '--defer-child',
+    '--prompt-file', promptTempPath,
+    '--output-file', tempPath,
+  ];
+  if (qaMode) childArgs.push('--qa');
+  if (tgMode === true) childArgs.push('--tg');
+  if (tgMode === false) childArgs.push('--no-tg');
+  if (flushMode) childArgs.push('--flush');
+  if (sessionName) {
+    childArgs.push('--session', sessionName);
+    if (newSession) childArgs.push('--new');
+  }
+  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, {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+
+  return ticket;
+}
+
 async function main() {
   let serverBase = 'http://localhost:4096';
   let qaMode = false;
   let flushMode = false;
   let deferMode = false;
   let deferSeconds = 0;
+  // Project context from the nearest .ocmux.json (v2 model): project directory,
+  // stored session ID, and cached server URL. All null when no state file
+  // applies, in which case agentp keeps its legacy (unscoped) behavior.
+  const ctx = projectState.resolveContext();
+  const projectDir = ctx.directory;
+  const stateSession = ctx.session;
+  // Adopt the project's cached server (from .ocmux.json) unless an explicit
+  // server/port is given later in the argument loop (--getLast runs mid-loop,
+  // so adoption must happen before it).
+  if (ctx.server) serverBase = ctx.server;
   let deferChildMode = false;
   let onlineTicket = false;
   let promptFile = null;
   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;
@@ -373,6 +675,7 @@ async function main() {
       console.error('  --getLast   Retrieve last N assistant answers (or QA pairs with --qa) from session history');
       console.error('  --session   Target a specific session by name (creates it if not found with --new)');
       console.error('  --new       Create a new session with the given title (requires --session)');
+      console.error('  --server    OpenCode server URL (overrides .ocmux.json); e.g. http://host:4096');
       console.error('  --help      Show this help message');
       console.error('');
       console.error('By default, --qa auto-detects tgagentp; standalone mode implies --no-tg.');
@@ -391,8 +694,9 @@ async function main() {
       console.error('');
       console.error('Arguments:');
       console.error('  url        OpenCode server URL or port number (default: 4096)');
-      console.error('             Examples: 4096, http://localhost:4096, http://192.168.1.50:4096');
-      console.error('             Tip: $(ocmux) expands to the URL of the current project\'s server.');
+      console.error('             Example: 4096, http://localhost:4096, http://192.168.1.50:4096');
+      console.error('             Omit it to resolve from the nearest .ocmux.json');
+      console.error('             (its directory selects the project, its session id the target).');
       console.error('');
       console.error('See also: tgagentp -- Telegram bridge (tgagentp --help), ocmux -- manage OpenCode tmux sessions (ocmux --help)');
       console.error('');
@@ -445,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') {
@@ -456,18 +770,12 @@ async function main() {
       }
       const n = parseInt(nStr, 10);
       try {
-        const sessions = await listSessions(serverBase);
+        const sessions = await listSessions(serverBase, projectDir || undefined);
         if (!sessions || sessions.length === 0) {
           console.error('No sessions found.');
           process.exit(1);
         }
-        const sorted = sessions
-          .filter(s => s.time && (s.time.updated || s.time.created))
-          .sort((a, b) => {
-            const aTime = (a.time && a.time.updated) || (a.time && a.time.created) || 0;
-            const bTime = (b.time && b.time.updated) || (b.time && b.time.created) || 0;
-            return bTime - aTime;
-          });
+        const sorted = sortSessionsByRecency(sessions);
         const sessionId = sorted[0].id;
 
         function buildPairsFromMessages(messages) {
@@ -548,6 +856,13 @@ async function main() {
       tgMode = true;
     } else if (args[i] === '--no-tg') {
       tgMode = false;
+    } else if (args[i] === '--server') {
+      i++;
+      if (!args[i]) {
+        console.error("Error: '--server' requires a URL (e.g. http://host:4096)");
+        process.exit(1);
+      }
+      serverBase = args[i].replace(/\/+$/, '');
     } else if (args[i].includes('://')) {
       serverBase = args[i].replace(/\/+$/, '');
     } else if (/^\d+$/.test(args[i])) {
@@ -563,6 +878,8 @@ async function main() {
     }
   }
 
+  const preferredSession = (sessionName || newSession || resolvedSessionId) ? null : stateSession;
+
   // Resolve default: --qa → auto-detect, standalone → disabled
   if (tgMode === null) {
     tgMode = qaMode ? 'auto' : false;
@@ -596,6 +913,10 @@ async function main() {
       // ignored; the ticket's own "defer" timeout is used instead (default 0).
       const deferredPath = ticket.path;
 
+      if (ticket.cancelled) {
+        await cancelTicket(ticket);
+      }
+
       if (!fs.existsSync(deferredPath)) {
         process.stdout.write(`Error: deferred file not found: ${deferredPath}\n`);
         process.exit(1);
@@ -614,7 +935,7 @@ async function main() {
           process.exit(1);
         }
         try { fs.unlinkSync(deferredPath + '.lock'); } catch {}
-        process.stdout.write(formatDeferredResult(deferredPath, result, qaMode, ticket.followupText));
+        process.stdout.write(formatDeferredResult(deferredPath, result, qaMode, ticket.followupText, await ticketHeader(ticket, qaMode)));
         removeQueuedFollowups(deferredPath);
         process.exit(0);
       }
@@ -643,7 +964,7 @@ async function main() {
             process.exit(1);
           }
           try { fs.unlinkSync(deferredPath + '.lock'); } catch {}
-          process.stdout.write(formatDeferredResult(deferredPath, result, qaMode, ''));
+          process.stdout.write(formatDeferredResult(deferredPath, result, qaMode, '', await ticketHeader(ticket, qaMode)));
           removeQueuedFollowups(deferredPath);
           process.exit(0);
         }
@@ -658,70 +979,49 @@ async function main() {
     }
 
     // This is a regular prompt — create deferred execution
-    const tempPath = generateTempFilename();
-    const promptTempPath = tempPath + '.prompt';
-
-    let targetSessionId;
-    try {
-      targetSessionId = await resolveTargetSession(serverBase, sessionName, newSession);
-    } catch (err) {
-      console.error(err.message);
-      process.exit(1);
-    }
-
-    // Write prompt to temp file for child process
-    fs.writeFileSync(promptTempPath, promptText);
-
-    // Create and lock the output file
-    fs.writeFileSync(tempPath, '');
-    lockFile(tempPath);
-
-    const newTicket = {
-      ctime: new Date().toISOString(),
-      path: tempPath,
-      defer: deferSeconds,
-      server: serverBase,
-      sessionId: targetSessionId,
-    };
-
-    // Spawn detached child process
-    const childArgs = [
-      __filename,
-      '--defer-child',
-      '--prompt-file', promptTempPath,
-      '--output-file', tempPath,
-    ];
-
-    // Pass through other flags
-    if (qaMode) childArgs.push('--qa');
-    if (tgMode === true) childArgs.push('--tg');
-    if (tgMode === false) childArgs.push('--no-tg');
-    if (flushMode) childArgs.push('--flush');
-    if (sessionName) {
-      childArgs.push('--session', sessionName);
-      if (newSession) childArgs.push('--new');
+    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);
+      }
     }
-    childArgs.push('--resolved-session-id', targetSessionId);
-    childArgs.push(serverBase);
 
-    const child = child_process.spawn(process.execPath, childArgs, {
-      detached: true,
-      stdio: 'ignore',
+    const newTicket = spawnDeferredChild({
+      promptText,
+      serverBase,
+      sessionName,
+      newSession,
+      qaMode,
+      tgMode,
+      flushMode,
+      targetSessionId,
+      targetSessionIds: broadcastIds,
+      deferSeconds,
     });
-    child.unref();
 
     // If a timeout was given, block until the answer arrives or the timeout
     // expires. Return the response when it arrives; otherwise print a ticket.
     if (deferSeconds > 0) {
-      const result = await waitForDeferredResult(tempPath, deferSeconds * 1000);
+      const result = await waitForDeferredResult(newTicket.path, deferSeconds * 1000);
       if (result !== null) {
         try {
-          fs.unlinkSync(tempPath);
+          fs.unlinkSync(newTicket.path);
         } catch (err) {
           process.stdout.write(`Error reading deferred file: ${err.message}\n`);
           process.exit(1);
         }
-        try { fs.unlinkSync(tempPath + '.lock'); } catch {}
+        try { fs.unlinkSync(newTicket.path + '.lock'); } catch {}
         process.stdout.write(result);
         process.exit(0);
       }
@@ -732,6 +1032,99 @@ async function main() {
     process.exit(0);
   }
 
+  // Normal (non-deferred, non-child) mode: wait for the answer, but run it in a
+  // detached child so a Ctrl+C can hand the in-flight response off as a ticket.
+  if (!deferChildMode) {
+    const ticket = parseDeferredTicketInput(promptText);
+
+    if (ticket) {
+      // Recognize a deferred ticket: wait indefinitely for the answer, and
+      // re-print the ticket only if the user interrupts with Ctrl+C.
+      const deferredPath = ticket.path;
+
+      if (ticket.cancelled) {
+        await cancelTicket(ticket);
+      }
+
+      if (!fs.existsSync(deferredPath)) {
+        process.stdout.write(`Error: deferred file not found: ${deferredPath}\n`);
+        process.exit(1);
+      }
+
+      let unusedFollowup = ticket.followupText || '';
+
+      // If the answer is already ready, return it immediately.
+      let result = ticket.followupText ? readDeferredResult(deferredPath) : null;
+      if (result !== null) {
+        outputReadyResult(deferredPath, result, qaMode, unusedFollowup, await ticketHeader(ticket, qaMode));
+      }
+
+      // Queue any follow-up text to the original session (same as --defer).
+      if (ticket.followupText) {
+        if (!ticket.server || !ticket.sessionId) {
+          process.stdout.write('Error: deferred ticket does not include server/sessionId; cannot queue follow-up text. Re-submit only the ticket to check the result.\n');
+          process.exit(1);
+        }
+        try {
+          await sendToSessionAsync(ticket.server, ticket.sessionId, ticket.followupText);
+          appendQueuedFollowup(deferredPath, ticket.followupText);
+          unusedFollowup = '';  // follow-up already queued; don't echo it again
+        } catch (err) {
+          process.stdout.write(`Error queueing follow-up prompt: ${err.message}\n`);
+          process.exit(1);
+        }
+      }
+
+      const wait = await waitForDeferredResultForever(deferredPath);
+      if (wait.interrupted) printTicketAndExit(ticket, onlineTicket);
+      outputReadyResult(deferredPath, wait.result, qaMode, unusedFollowup, await ticketHeader(ticket, qaMode));
+    }
+
+    // Regular prompt: submit via a detached child and wait for the answer.
+    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({
+      promptText,
+      serverBase,
+      sessionName,
+      newSession,
+      qaMode,
+      tgMode,
+      flushMode,
+      targetSessionId,
+      targetSessionIds: broadcastIds,
+      deferSeconds: 0,
+    });
+
+    const wait = await waitForDeferredResultForever(newTicket.path);
+    if (wait.interrupted) printTicketAndExit(newTicket, onlineTicket);
+
+    // Answer ready — output it and clean up.
+    try {
+      fs.unlinkSync(newTicket.path);
+    } catch (err) {
+      process.stdout.write(`Error reading deferred file: ${err.message}\n`);
+      process.exit(1);
+    }
+    try { fs.unlinkSync(newTicket.path + '.lock'); } catch {}
+    process.stdout.write(wait.result);
+    process.exit(0);
+  }
+
   // Handle --defer-child mode (child process)
   let actualPromptText = promptText;
   if (deferChildMode && promptFile) {
@@ -749,21 +1142,69 @@ 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);
+    // 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;
 
+    let sessionId = null;
     let answer;
-    try {
-      answer = await sendToSession(serverBase, sessionId, actualPromptText);
-    } catch (err) {
-      throw new Error(`Error sending prompt: ${err.message}`);
+    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
+      }
+
+      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;
+      if (!answer.endsWith('\n')) tgMessage += '\n';
+      tgMessage += FINAL_ROW;
     }
 
     // Post-send: notify tgagentp, get recorded context back
@@ -843,4 +1284,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { main, notifyAgentpGateway, readAllStdin, parseDeferredTicket, parseDeferredTicketInput, formatTicket, waitForDeferredResult };
+module.exports = { main, notifyAgentpGateway, readAllStdin, parseDeferredTicket, parseDeferredTicketInput, formatTicket, waitForDeferredResult, waitForDeferredResultForever, runBroadcastSend, buildBroadcastSection, formatBroadcastResults, isBroadcastActive };