agentp 2.1.2 → 2.1.3

package/README.md

@@ -114,6 +114,7 @@ Arguments:
 
 - `url`: OpenCode server URL or port number (defaults to `4096`). Examples: `4096`, `http://localhost:4096`, `http://192.168.1.50:4096`
 - Omit it and agentp resolves the project itself: the nearest `.ocmux.json` (upward from the working directory) supplies the server URL, the project directory, and the target session id. `agentp $(ocmux)` still works as an override, but is no longer needed.
+- When a registered TUI pane exists for the project, `agentp` routes it to the session the prompt went to (normal and `--defer`), so the answer streams in view; re-submitting a deferred ticket does the same for the ticket's session. Best-effort and silent when no pane is registered — broadcast prompts are left untouched (no single session to show).
 
 ## Examples
 
@@ -218,6 +219,8 @@ The ticket is `agentp_ticket` followed by a JSON object with these fields:
 - `server` — OpenCode server URL 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`).
+- `sessionName` — the session's current title, display-only: routing always keys on `sessionId`. Refreshed on every ticket print, so a session renamed while a job is running shows its up-to-date name.
+- `sessionNames` — map of session ID → current title for **broadcast** tickets (display-only, refreshed on every print).
 - `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).
@@ -381,6 +384,10 @@ the project found upward from `<directory>` (default: `$PWD`):
   waiting, and the cursor session's marker columns are pinned to the **top-right
   corner of the info panel**. The same markers appear in the project switcher,
   per session and — when folded — aggregated over the project.
+- **live activity**: sessions with a running turn show an **animated spinner**
+  next to their row (and `BUSY` in the info panel). While the picker is open
+  ocmux re-checks activity every second, so the spinner appears when a session
+  starts a turn and disappears when it finishes — no re-opening needed.
 - `A` answers the pending **question(s)** of the selected session (only when it
   shows a ❓ marker). Answer mode
   lists the form's fields and options: `Space`/`Enter` selects (`(•)`), extra

package/bin/agentp

@@ -21,6 +21,7 @@ const {
   getActiveSessions,
 } = require('../lib/opencode');
 const projectState = require('../lib/project-state');
+const ocmuxLib = require('../lib/ocmux');
 
 const TGAGENTP_PORT_FILE = '/tmp/tgagentp-port';
 
@@ -177,9 +178,21 @@ function parseDeferredTicketInput(text) {
     cancelled: data.cancelled === true,
     followupText,
   };
+  // Display-only name(s): carried through for fallback when a refresh fails,
+  // never used for routing (which keys on sessionId/sessionIds).
+  if (typeof data.sessionName === 'string' && data.sessionName) {
+    ticket.sessionName = data.sessionName;
+  }
   if (Array.isArray(data.sessionIds)) {
     ticket.sessionIds = data.sessionIds.filter(x => typeof x === 'string' && x);
   }
+  if (data.sessionNames && typeof data.sessionNames === 'object' && !Array.isArray(data.sessionNames)) {
+    const names = {};
+    for (const [k, v] of Object.entries(data.sessionNames)) {
+      if (typeof v === 'string' && v) names[k] = v;
+    }
+    if (Object.keys(names).length > 0) ticket.sessionNames = names;
+  }
   return ticket;
 }
 
@@ -197,7 +210,15 @@ 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;
+  // Session name(s) are display-only convenience (ids are hard to read for a
+  // human); the actual routing always keys on `sessionId` / `sessionIds`.
+  if (ticket.sessionName) fields.sessionName = ticket.sessionName;
+  if (Array.isArray(ticket.sessionIds) && ticket.sessionIds.length > 0) {
+    fields.sessionIds = ticket.sessionIds;
+    if (ticket.sessionNames && Object.keys(ticket.sessionNames).length > 0) {
+      fields.sessionNames = ticket.sessionNames;
+    }
+  }
   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.
@@ -223,15 +244,76 @@ async function cancelTicket(ticket) {
   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))
+// Re-fetch the display name(s) of a ticket's target session(s) right before
+// printing, so a session renamed since the ticket was created shows its
+// current title. Display-only: routing always keys on `sessionId`/`sessionIds`.
+// Failures keep the last known name (carried in the parsed ticket) rather than
+// dropping it.
+async function refreshTicketSessionNames(ticket) {
+  if (!ticket || !ticket.server) return ticket;
+  const out = { ...ticket };
+  if (out.sessionId) {
+    try {
+      const s = await getSession(out.server, out.sessionId);
+      if (s && (s.title || s.id)) out.sessionName = s.title || s.id;
+    } catch { /* keep the last known name */ }
+  }
+  if (Array.isArray(out.sessionIds) && out.sessionIds.length > 0) {
+    const names = {};
+    if (out.sessionNames && typeof out.sessionNames === 'object') {
+      for (const [k, v] of Object.entries(out.sessionNames)) if (v) names[k] = v;
+    }
+    for (const id of out.sessionIds) {
+      try {
+        const s = await getSession(out.server, id);
+        if (s && (s.title || s.id)) names[String(id)] = s.title || s.id;
+      } catch { /* keep the last known name for this id */ }
+    }
+    const kept = {};
+    for (const id of out.sessionIds) {
+      const k = String(id);
+      if (names[k]) kept[k] = names[k];
+    }
+    if (Object.keys(kept).length > 0) out.sessionNames = kept;
+    else delete out.sessionNames;
+  }
+  return out;
+}
+
+// Print a deferred ticket (with refreshed session name and elapsed) and exit —
+// used for the interrupt path.
+async function printTicketAndExit(ticket, onlineTicket) {
+  const fresh = await refreshTicketSessionNames(ticket);
+  const elapsed = fresh && fresh.ctime
+    ? Math.max(0, Math.floor((Date.now() - Date.parse(fresh.ctime)) / 1000))
     : 0;
-  process.stdout.write(formatTicket(ticket, elapsed, onlineTicket) + '\n');
+  process.stdout.write(formatTicket(fresh, elapsed, onlineTicket) + '\n');
   process.exit(0);
 }
 
+// Route a registered TUI (if any) to the session a ticket refers to, so
+// re-sending a ticket brings that session into view while it works. Tickets
+// carry no project directory — it is derived from the session's own location.
+// Best-effort: a missing directory, server hiccup or absent registered pane is
+// silently ignored, and broadcast tickets are skipped (no single session to
+// show).
+async function routeTuiToTicketSession(ticket) {
+  if (!ticket || !ticket.server || !ticket.sessionId) return;
+  let directory = null;
+  try {
+    const s = await getSession(ticket.server, ticket.sessionId);
+    directory = s && s.location && s.location.directory ? s.location.directory : null;
+  } catch {
+    return;
+  }
+  if (!directory) return;
+  try {
+    ocmuxLib.switchTui(directory, ticket.server, ticket.sessionId);
+  } catch {
+    // TUI routing is best-effort; never fail the retrieval because of it.
+  }
+}
+
 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;
@@ -912,6 +994,9 @@ async function main() {
       // ignored; the ticket's own "defer" timeout is used instead (default 0).
       const deferredPath = ticket.path;
 
+      // Bring the ticket's session into view in any registered TUI (best-effort).
+      await routeTuiToTicketSession(ticket);
+
       if (ticket.cancelled) {
         await cancelTicket(ticket);
       }
@@ -970,10 +1055,12 @@ async function main() {
       }
 
       // Answer not available yet — re-print the ticket with updated elapsed
-      const elapsed = ticket.ctime
-        ? Math.max(0, Math.floor((Date.now() - Date.parse(ticket.ctime)) / 1000))
+      // and a freshly resolved session name (it may have been renamed).
+      const freshTicket = await refreshTicketSessionNames(ticket);
+      const elapsed = freshTicket.ctime
+        ? Math.max(0, Math.floor((Date.now() - Date.parse(freshTicket.ctime)) / 1000))
         : 0;
-      process.stdout.write(formatTicket(ticket, elapsed, onlineTicket) + '\n');
+      process.stdout.write(formatTicket(freshTicket, elapsed, onlineTicket) + '\n');
       process.exit(0);
     }
 
@@ -996,6 +1083,13 @@ async function main() {
       }
     }
 
+    // Route the project's registered TUI (if any) to the target session so the
+    // prompt streams in view while the deferred child works. Best-effort and
+    // skipped for broadcasts (no single session to show).
+    try {
+      if (projectDir && targetSessionId) ocmuxLib.switchTui(projectDir, serverBase, targetSessionId);
+    } catch {}
+
     const newTicket = spawnDeferredChild({
       promptText,
       serverBase,
@@ -1026,8 +1120,10 @@ async function main() {
       }
     }
 
-    // Output the deferred ticket
-    process.stdout.write(formatTicket(newTicket, undefined, onlineTicket) + '\n');
+    // Output the deferred ticket with the session name resolved for display
+    // (ids are hard to remember; the name is fetch-and-forget, never routed on).
+    const freshTicket = await refreshTicketSessionNames(newTicket);
+    process.stdout.write(formatTicket(freshTicket, undefined, onlineTicket) + '\n');
     process.exit(0);
   }
 
@@ -1041,6 +1137,9 @@ async function main() {
       // re-print the ticket only if the user interrupts with Ctrl+C.
       const deferredPath = ticket.path;
 
+      // Bring the ticket's session into view in any registered TUI (best-effort).
+      await routeTuiToTicketSession(ticket);
+
       if (ticket.cancelled) {
         await cancelTicket(ticket);
       }
@@ -1075,7 +1174,7 @@ async function main() {
       }
 
       const wait = await waitForDeferredResultForever(deferredPath);
-      if (wait.interrupted) printTicketAndExit(ticket, onlineTicket);
+      if (wait.interrupted) await printTicketAndExit(ticket, onlineTicket);
       outputReadyResult(deferredPath, wait.result, qaMode, unusedFollowup, await ticketHeader(ticket, qaMode));
     }
 
@@ -1096,6 +1195,13 @@ async function main() {
       }
     }
 
+    // Route the project's registered TUI (if any) to the target session so the
+    // answer streams in view. Best-effort and skipped for broadcasts (no single
+    // session to show).
+    try {
+      if (projectDir && targetSessionId) ocmuxLib.switchTui(projectDir, serverBase, targetSessionId);
+    } catch {}
+
     const newTicket = spawnDeferredChild({
       promptText,
       serverBase,
@@ -1110,7 +1216,7 @@ async function main() {
     });
 
     const wait = await waitForDeferredResultForever(newTicket.path);
-    if (wait.interrupted) printTicketAndExit(newTicket, onlineTicket);
+    if (wait.interrupted) await printTicketAndExit(newTicket, onlineTicket);
 
     // Answer ready — output it and clean up.
     try {
@@ -1171,8 +1277,8 @@ async function main() {
         preferredSession,
       });
 
-      // Prepend the session's annotation (if any) to the prompt. TUI routing is
-      // owned by explicit ocmux session switches, not by prompt submission.
+      // Prepend the session's annotation (if any) to the prompt. (The parent
+      // already routed the project's TUI to this session before spawning us.)
       let prompt = actualPromptText;
       try {
         if (ctx && ctx.statefile) {
@@ -1281,4 +1387,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { main, notifyAgentpGateway, readAllStdin, parseDeferredTicket, parseDeferredTicketInput, formatTicket, waitForDeferredResult, waitForDeferredResultForever, runBroadcastSend, buildBroadcastSection, formatBroadcastResults, isBroadcastActive };
+module.exports = { main, notifyAgentpGateway, readAllStdin, parseDeferredTicket, parseDeferredTicketInput, formatTicket, refreshTicketSessionNames, waitForDeferredResult, waitForDeferredResultForever, runBroadcastSend, buildBroadcastSection, formatBroadcastResults, isBroadcastActive };

package/bin/ocmux

@@ -224,6 +224,8 @@ const GLYPH_PERMS = '🔒';    // pending permission request
 const GLYPH_BELL = '🔔';     // status bar: at least one marker in the list
 const CELL_NONE = '  ';      // placeholder reserving one absent marker column
 const PENDING_POLL_MS = 2000; // how often the open picker re-checks pending state
+const RUNNING_POLL_MS = 1000; // how often the open picker re-checks which sessions are running
+const SPIN_INTERVAL_MS = 120; // spinner frame rate while any listed session runs
 
 // The two marker columns for a session/project: ❓ and/or 🔒, each column fixed
 // at 2 columns wide so rows stay aligned whether or not a marker is present.
@@ -577,7 +579,11 @@ function renderList({ title, items, cursor, row, footer, infoLines = [], extraLi
 // permission reply. When provided the picker polls it every PENDING_POLL_MS and
 // renders the ❓/🔒 marker columns; `A` answers the cursor session's questions
 // and `P` its pending permission requests (allow once/always, reject).
-function sessionMenu(sessions, currentSession, annotations, server, { onPick, onRename, onDelete, onReminder, runningIds, modelContext, onBroadcastChange, onInspectSession, dir, notices = [], loadPending, broadcast = null } = {}) {
+// `runningIds` is the caller's snapshot of actively-running session ids (Set);
+// `loadRunning` (optional async () => Set) refreshes it every RUNNING_POLL_MS
+// so every row that is running shows the spinner and the BUSY/IDLE status
+// tracks the session's real activity.
+function sessionMenu(sessions, currentSession, annotations, server, { onPick, onRename, onDelete, onReminder, runningIds, modelContext, onBroadcastChange, onInspectSession, dir, notices = [], loadPending, loadRunning, broadcast = null } = {}) {
   return new Promise((resolve) => {
     if (!process.stdin.isTTY) return resolve(null);
 
@@ -633,6 +639,13 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
     let pendingPerms = new Set();
     let pendingBusy = false;
     let pendingTimer = null;
+    // Which listed sessions are actively running. The caller passes a snapshot
+    // taken at open; `loadRunning` (optional) refreshes it while the picker is
+    // open, so the spinner and BUSY/IDLE status keep up with sessions that start
+    // or finish a turn at any time.
+    let runningSet = runningIds instanceof Set ? runningIds : new Set();
+    let runningBusy = false;
+    let runningTimer = null;
     // Answer mode ('A') state: the pending forms of the cursor session being
     // answered one at a time, the answers chosen so far and the flat item list.
     let answer = null;
@@ -679,6 +692,7 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
       process.stderr.write('\x1b[?1049l');
       if (spinTimer) { clearInterval(spinTimer); spinTimer = null; }
       if (pendingTimer) { clearInterval(pendingTimer); pendingTimer = null; }
+      if (runningTimer) { clearInterval(runningTimer); runningTimer = null; }
       process.stdout.removeListener('resize', draw);
       try { process.stdin.setRawMode(false); } catch {}
       process.stdin.pause();
@@ -789,7 +803,7 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
         const selF = selected && pendingForms.has(String(selected.id));
         const selP = selected && pendingPerms.has(String(selected.id));
         const selPending = (selF || selP) ? pendingCells(selF, selP) : '';
-        infoLines = sessionInfoLines(selected, runningIds, modelContext, cols, selIsCurrent, selPending);
+        infoLines = sessionInfoLines(selected, runningSet, modelContext, cols, selIsCurrent, selPending);
       }
       // 'd'/n/r/R prompts take over the status bar (previously an easy-to-miss
       // line at the bottom of the list) with their essential keys on the right.
@@ -839,7 +853,7 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
           const timeStr = showTime ? padLeft(fmtClock(s.time && s.time.viewed), TIME_W) + '  ' : '';
           const mark = String(s.id) === String(current) ? ' *' : '';
           const hasNote = annotations && annotations[s.id] ? ' ◈' : '';
-          const spin = (runningIds && runningIds.has(s.id)) ? SPINNER[spinIdx % SPINNER.length] + ' ' : '  ';
+          const spin = (runningSet.has(s.id)) ? SPINNER[spinIdx % SPINNER.length] + ' ' : '  ';
           const text = `${sel}${spin}${cellsOf(s.id)}${timeStr}${pad(title, maxLen)}${mark}${hasNote}`;
           // Brown for the session currently selected in the TUI window.
           return String(s.id) === String(current) ? `${BROWN}${text}\x1b[0m` : text;
@@ -927,6 +941,33 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
       }).catch(() => { pendingBusy = false; });
     };
 
+    // ── Live activity polling (spinner + BUSY/IDLE status) ──────────
+    // Re-read `loadRunning` every RUNNING_POLL_MS while the picker is open so a
+    // session that starts or finishes a turn after the menu opened shows it
+    // without re-opening. Errors degrade gracefully: the previous set stays.
+    const refreshRunning = () => {
+      if (!loadRunning || runningBusy) return Promise.resolve();
+      runningBusy = true;
+      return Promise.resolve(loadRunning()).then((ids) => {
+        runningSet = ids instanceof Set ? ids : new Set(ids || []);
+        runningBusy = false;
+        syncSpin();
+      }).catch(() => { runningBusy = false; });
+    };
+    // Keep the spinner animation in sync with the running set: animate while at
+    // least one listed session is active, stop when none is, and paint a fresh
+    // frame so a poll update is visible immediately.
+    const syncSpin = (redraw = true) => {
+      const anyRunning = rows.some((s) => runningSet.has(s.id));
+      if (anyRunning && !spinTimer) {
+        spinTimer = setInterval(() => { spinIdx++; draw(); }, SPIN_INTERVAL_MS);
+      } else if (!anyRunning && spinTimer) {
+        clearInterval(spinTimer);
+        spinTimer = null;
+      }
+      if (redraw && !done) draw();
+    };
+
     // ── Answer mode (A): answer the agent's pending form(s) ─────────
     // Field applicability honours `hidden` and `when` conditions over the
     // answers chosen SO FAR (live re-validation: groups appear/disappear as you
@@ -1765,9 +1806,12 @@ const toggleBroadcast = (idx) => {
     process.stdin.setRawMode(true);
     process.stdin.resume();
     process.stdout.on('resize', draw);
-    // Animate the spinner while any listed session is running.
-    if (rows.some(s => runningIds && runningIds.has(s.id))) {
-      spinTimer = setInterval(() => { spinIdx++; draw(); }, 120);
+    // Animate the spinner while any listed session is running. `loadRunning`
+    // (when provided) polls for activity so the spinner follows sessions that
+    // start or finish a turn after the picker opened.
+    syncSpin(false);
+    if (loadRunning) {
+      runningTimer = setInterval(() => { refreshRunning(); }, RUNNING_POLL_MS);
     }
     // Poll for pending agent questions / permission replies while the picker is
     // open (the ❓/🔒 marker columns and the 'A' entry refresh live).
@@ -2179,6 +2223,9 @@ async function cmdSessionSwitch(targetDir, directRef, allProjects = false) {
           forms: new Set((forms || []).map(f => f.sessionID).filter(Boolean)),
           perms: new Set((perms || []).map(x => x.sessionID).filter(Boolean)),
         })),
+        // Which sessions are actively running, re-polled while the picker is
+        // open so the spinner and BUSY/IDLE status stay accurate.
+        loadRunning: () => getActiveSessions(server),
         onBroadcastChange: (ids) => projectState.writeProjectState(sf, { broadcast: ids }),
         onInspectSession: (id) => refreshTui(dir, server, id),
         onPick: async (row) => {

package/docs/specification_v2.md

@@ -83,7 +83,8 @@ There is no `--global` alias.
 
 ## 4. TUI routing
 
-When `ocmux` selects or inspects a session, it resolves the display in order:
+When `ocmux` selects or inspects a session — or `agentp` sends a prompt or
+re-submits a deferred ticket (section 8) — the display is resolved in order:
 
 1. live TUI dedicated to the target directory;
 2. the one live shared TUI;
@@ -197,6 +198,15 @@ The broadcast info line (`Broadcast to sessions: …`) never wraps: it holds up
 to 480 characters of names (or the terminal width, whichever is smaller), and
 an oversized selection is truncated from the beginning with a leading `...`.
 
+**Live activity.** Every listed session that is currently running (a foreground
+drain, per `GET /api/session/active`) shows an animated spinner in its row, and
+the info panel's status says `BUSY`. The picker's initial `runningIds` is a
+snapshot taken at open; while the picker stays open it re-polls that endpoint
+every second and updates the set, so sessions that start a turn after the menu
+opened begin spinning and sessions that finish stop — the animation timer starts
+and stops to match. Failures of the poll degrade silently: the previous set
+stays and the next poll retries.
+
 **Pending-answer awareness.** While the picker is open it re-polls the project
 every 2 seconds (`GET /api/form` and `GET /api/permission/request`, both
 location-scoped with the `location[directory]=…` deepObject parameter) and
@@ -276,9 +286,17 @@ The old managed-window `kill` and `resurrect` commands do not exist.
 ## 8. `agentp`
 
 `agentp` resolves project/session/server from explicit options and the nearest
-state file, then sends directly to the session API. It does not focus, move, or
-refresh a TUI; TUI routing is an explicit consequence of ocmux session
-selection, not prompt submission.
+state file, then sends directly to the session API. Sending a prompt (normal or
+`--defer`) also routes the project's TUI to the target session, so the answer
+streams in view: the pane is respawned only when it does not already show that
+project/session. Re-submitting a deferred ticket does the same for the ticket's
+session, whose project directory is derived from the session's own location.
+
+Routing is best-effort and never fails the prompt. It resolves like section 4
+(dedicated → shared → headless, silent when no pane is registered), is skipped
+for broadcast prompts (no single session to show) and for the detached
+`--defer-child` worker, and routing always keys on `sessionId`/`sessionIds` —
+the human-readable session name on a ticket is display-only.
 
 ## 9. Failure behavior
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentp",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "Pipe prompts into a running OpenCode TUI session and stream the final answer",
   "bin": {
     "agentp": "bin/agentp",