premanmcp 1.1.17 → 1.1.19

package/README.md

@@ -53,7 +53,7 @@ preman chat -p "list my endpoints"      # one turn, printed, then exit
 ```
 
 Inside a session: `/help`, `/new`, `/conversations`, `/resume <id>`, `/app`,
-`/eval`, `/clear`, `/exit`. `/eval list` shows what your agent can be measured
+`/swarm`, `/eval`, `/clear`, `/exit`. `/eval list` shows what your agent can be measured
 on, numbered; `/eval on 3 12` or `/eval on sycophancy` switches those on (a
 number, a `3-7` range, `all`, an id, or enough of one to be unambiguous), `/eval
 off` the same in reverse, and `/eval` runs what is on. `/eval defaults` reads
@@ -65,6 +65,32 @@ link underneath opens the PreMan desktop app when it is installed (a build older
 than 0.4.0 comes forward on whatever it was showing rather than on the run), and
 the run's dashboard URL is always printed with it.
 
+Ask the agent to launch a hosted-MCP swarm in plain language, just as in the
+app: “Launch a 12-attempt Codex swarm against my tracker server; ask it to find
+open issues and expect search_issues.” The terminal uses the same conversation
+service and approval rules. A proposed launch shows its summary in the terminal;
+choose “Approve exact action” to launch it, “Decline” to reject it, or Enter to
+leave it unanswered. A swarm result prints its label, status, run ID, and link.
+Piped sessions leave approvals unanswered for review in the app.
+
+For explicit commands inside the session, `/swarm` uses the current session's
+account, backend, and workspace:
+
+```text
+/swarm list
+/swarm launch --server tracker --ask "Find open issues" --expect search_issues --agents codex --size 12 --rivals 0
+/swarm watch <run-id>
+/swarm stop <run-id>
+```
+
+Launch follows automatically, showing queue and running counts, live tool
+actions, and the final result. `/swarm help` lists every option. Add `--dry-run`
+to preview a launch without starting attempts, or `--no-watch` to return
+immediately. `--json` returns one JSON response. Ctrl+C while watching returns to the conversation and leaves
+the swarm running; `/swarm stop <run-id>` cancels it explicitly. The same commands
+work outside a session as `preman swarm list|launch|watch|stop|bank`. These run
+real agents against hosted MCPs; the app's sample swarms remain a separate demo.
+
 A session takes a screen of its own, the way `vim` does: nothing above it is
 scrollable, and leaving hands your shell back exactly as it was with one line
 saying how to resume. Ctrl+C stops the current turn (PreMan keeps working on it)

package/bin/agent.js

@@ -25,6 +25,7 @@ import { basename, join } from "node:path";
 import { createInterface } from "node:readline/promises";
 
 import { createSseParser } from "./runner.js";
+import { SWARM_HELP, swarmCommand } from "./swarm.js";
 import {
   authenticateTerminal,
   backendUrl,
@@ -59,6 +60,10 @@ const SLASH_HELP = `Commands:
   /eval on|off <what>   Switch behaviours on or off, by number or by id
   /eval defaults        Pick a few that suit this project, and switch them on
   /eval doctor          Check this machine can run evals before starting one
+  /swarm list           List your hosted-MCP swarms
+  /swarm launch ...     Launch with the same flags as preman swarm launch
+  /swarm watch <id>     Follow a swarm; Ctrl+C returns to the conversation
+  /swarm help           Show launch, watch, stop and behavior-bank options
   /app                  Open this conversation in the PreMan app
   /clear                Clear the screen
   /exit                 Leave (Ctrl+D does the same)
@@ -212,6 +217,13 @@ export function artifactLine(artifact) {
   if (!artifact || typeof artifact !== "object") return "";
   const type = String(artifact.type || "");
   if (!type || SILENT_ARTIFACTS.has(type)) return "";
+  if (type === "swarm_run" && artifact.run?.id) {
+    const run = artifact.run;
+    const name = truncate(run.release_label || artifact.title || "Swarm", 60);
+    const line = [name, run.status, run.id].filter(Boolean).join(" · ");
+    const url = artifactUrl(artifact);
+    return url ? `${line} — ${url}` : line;
+  }
   const label =
     String(artifact.title || "").trim() || ARTIFACT_LABELS[type] || type.replace(/_/g, " ");
   const url = artifactUrl(artifact);
@@ -757,10 +769,82 @@ async function runTurn({
       ask,
       say,
     });
+    await askActionProposals({
+      args, token, workspaceId, artifacts: done.turn.artifacts, paint, ask, say, register,
+    });
   }
   return done;
 }
 
+/** Approve only a stored action on this session's backend; no tool-supplied URL is executed. */
+async function askActionProposals({ args, token, workspaceId, artifacts, paint, ask, say, register }) {
+  if (!process.stdin.isTTY) return;
+  const seen = new Set();
+  const proposals = (Array.isArray(artifacts) ? artifacts : []).filter((item) => {
+    const proposal = item?.type === "action_proposal" ? item.proposal : null;
+    const id = proposal?.id;
+    if (typeof id !== "string" || !/^[\w-]{1,128}$/.test(id) || seen.has(id)) return false;
+    if ((proposal.status || "pending") !== "pending") return false;
+    if (proposal.expires_at && Date.parse(proposal.expires_at) <= Date.now()) return false;
+    seen.add(id);
+    return true;
+  });
+  if (!proposals.length) return;
+  const write = say || ((text) => process.stdout.write(text));
+  const borrowed = typeof ask === "function";
+  const rl = borrowed ? null : createInterface({ input: process.stdin, output: process.stdout });
+  const readAnswer = borrowed ? ask : (text) => rl.question(text);
+  try {
+    for (const artifact of proposals.slice(0, 10)) {
+      const proposal = artifact.proposal;
+      const title = truncate(String(proposal.title || artifact.title || "Confirm action"), 240);
+      write(`\n${paint.yellow("PreMan needs a decision")}\n  ${title}\n`);
+      const summary = String(proposal.summary || artifact.summary || "").trim();
+      if (summary) write(`  ${truncate(summary, 1000)}\n`);
+      write(`  1. Approve exact action\n  2. Decline\n${paint.dim("  Enter to skip\n")}`);
+      const answer = String((await readAnswer("  > ")) || "").trim().toLowerCase();
+      const action = ["1", "y", "yes", "approve"].includes(answer) ? "approve"
+        : ["2", "n", "no", "decline"].includes(answer) ? "decline" : null;
+      if (!action) {
+        write(paint.dim("  Left unanswered.\n"));
+        continue;
+      }
+      if (proposal.expires_at && Date.parse(proposal.expires_at) <= Date.now()) {
+        write(paint.dim("  This action expired. Ask PreMan to regenerate it.\n"));
+        continue;
+      }
+      const controller = new AbortController();
+      register?.({ abort: () => controller.abort() });
+      try {
+        const response = await backendCall(args, "POST",
+          `/workbench/action-proposals/${encodeURIComponent(proposal.id)}/${action}`, {
+            token, signal: controller.signal,
+            headers: workspaceId ? { "x-workspace-id": workspaceId } : undefined,
+          });
+        const result = response.result;
+        const status = response.proposal?.status || "unknown";
+        if (result?.ok === false || result?.error) {
+          write(`  ${paint.red(describeFailure(result, "The action did not complete."))}\n`);
+        } else if (status === "completed" || status === "declined") {
+          write(`  ${paint.green("✓")} ${status === "completed" ? "Completed" : "Declined"}: ${title}\n`);
+          if (result?.run?.id) write(`  ${artifactLine({ type: "swarm_run", title, run: result.run, url: result.url })}\n`);
+        } else {
+          write(`  Action ${String(status).replaceAll("_", " ")}. Use /app to check its result.\n`);
+        }
+      } catch (error) {
+        write(controller.signal.aborted
+          ? "  Stopped waiting for the action result. Check /app before trying again.\n"
+          : `  ${paint.red(error?.message || String(error))}\n`);
+      } finally {
+        register?.(null);
+      }
+    }
+    if (proposals.length > 10) write("  More actions are awaiting a decision in /app.\n");
+  } finally {
+    if (rl) rl.close();
+  }
+}
+
 /**
  * Put a permission confirmation to the person at the keyboard.
  *
@@ -1956,6 +2040,64 @@ export async function runEval(rest, { args, token, dock, rl, paint, say, running
   }
 }
 
+/** Quoted flag values for a session command, without shell evaluation. */
+export function swarmArguments(rest) {
+  const words = [];
+  let word = "";
+  let quote = "";
+  let escaped = false;
+  let active = false;
+  for (const character of String(rest || "")) {
+    if (escaped) {
+      word += character;
+      escaped = false;
+    } else if (character === "\\" && quote !== "'") {
+      escaped = true;
+      active = true;
+    } else if (quote) {
+      if (character === quote) quote = "";
+      else word += character;
+    } else if (character === "'" || character === '"') {
+      quote = character;
+      active = true;
+    } else if (/\s/.test(character)) {
+      if (active) words.push(word);
+      word = "";
+      active = false;
+    } else {
+      word += character;
+      active = true;
+    }
+  }
+  if (quote || escaped) throw new Error("Finish the quoted value or escaped character in /swarm.");
+  if (active) words.push(word);
+  return words;
+}
+
+/** Reuse the CLI command inside the current authenticated conversation. */
+export async function runSwarm(rest, { args, token, workspaceId, say, paint, register }) {
+  const controller = new AbortController();
+  register?.({ abort: () => controller.abort() });
+  try {
+    const argv = swarmArguments(rest);
+    if (["help", "--help", "-h"].includes(argv[0])) {
+      say(`${SWARM_HELP}\n`);
+      return;
+    }
+    await swarmCommand(argv, {
+      sessionArgs: args, token, workspaceId, signal: controller.signal,
+      write: say,
+    });
+    say("\n");
+  } catch (error) {
+    say(controller.signal.aborted
+      ? "Stopped waiting. The swarm may still be running; /swarm list to check.\n\n"
+      : `${paint.red(error?.message || String(error))}\n\n`);
+  } finally {
+    register?.(null);
+  }
+}
+
 export async function agentCommand(commandArgs = [], { authenticate = authenticateTerminal } = {}) {
   const args = makeArgs(commandArgs);
   if (args.has("--help") || args.has("-h")) {
@@ -2067,6 +2209,7 @@ export async function agentCommand(commandArgs = [], { authenticate = authentica
     // Only reaches anything when a run is open, and the import is already
     // resolved by then -- the module was loaded to start the run.
     if (evaluating) void import("./eval.js").then(({ cancelEvalRuns }) => cancelEvalRuns());
+    turn?.abort();
   });
   hold.onTeardown(() => process.stdout.off("resize", onResize));
   hold.onTeardown(() => dock.disable());
@@ -2286,6 +2429,13 @@ export async function agentCommand(commandArgs = [], { authenticate = authentica
           });
           continue;
         }
+        if (slash.name === "swarm") {
+          await runSwarm(slash.rest, {
+            args, token, workspaceId: workspace.id, say, paint,
+            register: (handle) => { turn = handle; },
+          });
+          continue;
+        }
         if (slash.name === "app") {
           const url = `${frontendUrl(args)}/workbench/${conversation.id}`;
           openUrl(url);

package/bin/swarm-progress.js

@@ -0,0 +1,127 @@
+import { stripVTControlCharacters } from "node:util";
+
+const FINISHED = new Set(["done", "failed", "cancelled"]);
+const MAX_LINES = 24;
+const MAX_BUFFER = 65536;
+
+// Only action names and outcomes enter the transcript, never tool arguments,
+// results, credentials, or the agent's private reasoning.
+export function cleanLabel(value, limit = 120) {
+  return stripVTControlCharacters(String(value ?? ""))
+    .replace(/[\x00-\x1f\x7f-\x9f]/g, " ")
+    .replace(/(?:pm_live_|sk-)[A-Za-z0-9_-]+/g, "[redacted]")
+    .slice(0, limit);
+}
+
+export class SwarmProgress {
+  constructor({ write, colour = false }) {
+    this.write = write;
+    this.colour = colour;
+    this.cells = new Map();
+    this.lines = [];
+    this.omitted = 0;
+  }
+
+  state(cell) {
+    if (!this.cells.has(cell.id)) {
+      this.cells.set(cell.id, { seen: new Set(), offset: 0, pending: "", tools: new Map() });
+    }
+    return this.cells.get(cell.id);
+  }
+
+  note(cell, key, text, outcome = "") {
+    const state = this.state(cell);
+    if (state.seen.has(key)) return;
+    // Tool logs are untrusted and a single agent can emit indefinitely.
+    if (state.seen.size >= 500) return;
+    state.seen.add(key);
+    const mark = outcome === "failed" ? "✗" : outcome === "done" ? "✓" : "·";
+    const coloured = this.colour && outcome ? `\x1b[${outcome === "failed" ? 31 : 32}m${mark}\x1b[0m` : mark;
+    if (this.lines.length < MAX_LINES) this.lines.push(`  ${coloured} ${cleanLabel(cell.harness, 24)} ${cleanLabel(cell.id, 8)}  ${text}`);
+    else this.omitted += 1;
+  }
+
+  observe(cells, { results = false } = {}) {
+    for (const cell of cells) {
+      const evidence = cell.evidence || {};
+      if (!results) {
+        if (cell.status === "running") this.note(cell, "running", "Agent starting");
+        if (evidence.container_id) this.note(cell, "container", "Container started", "done");
+        if (cell.reached === true) this.note(cell, "connected", "Connected to the MCP", "done");
+        if (evidence.tools_listed === true) this.note(cell, "listed", "Tools loaded", "done");
+        continue;
+      }
+      for (const tool of (evidence.tools_called || []).slice(0, 100)) {
+        this.note(cell, `called:${tool}`, `Called ${cleanLabel(tool)}`, "done");
+      }
+      if (FINISHED.has(cell.status)) {
+        const failed = cell.status !== "done" || cell.selected === false;
+        const result = cell.selected === true ? "Expected tool selected" : cell.selected === false ? "Expected tool not selected" : "Not scored";
+        const reason = cell.verdict_reason ? ` · ${cleanLabel(cell.verdict_reason).replaceAll("_", " ")}` : "";
+        this.note(cell, `finished:${cell.status}`, `${cell.status === "cancelled" ? "Cancelled" : "Finished"} — ${result}${reason}`, failed ? "failed" : "done");
+      }
+    }
+  }
+
+  console(cell, chunk) {
+    const state = this.state(cell);
+    if (chunk.truncated) state.pending = "";
+    state.offset = Number.isFinite(chunk.total) ? chunk.total : state.offset;
+    let text = state.pending + String(chunk.text || "");
+    if (text.length > MAX_BUFFER) {
+      text = text.slice(-MAX_BUFFER);
+      text = text.slice(text.indexOf("\n") + 1);
+    }
+    const lines = text.split("\n");
+    state.pending = lines.pop() || "";
+    if (FINISHED.has(cell.status) && state.pending) {
+      lines.push(state.pending);
+      state.pending = "";
+    }
+    for (const line of lines) {
+      let event;
+      try { event = JSON.parse(line); } catch { continue; }
+      if (!event || typeof event !== "object") continue;
+      const item = event.item;
+      if (item?.type === "mcp_tool_call") {
+        const name = cleanLabel(item.tool || item.name || "MCP tool");
+        const finished = event.type === "item.completed";
+        const failed = Boolean(item.error) || item.status === "failed";
+        this.note(cell, `event:${item.id}:${name}:${event.type}`, `${finished ? failed ? "Tool failed" : "Tool completed" : "Calling"}: ${name}`, finished ? failed ? "failed" : "done" : "");
+        if (finished && !failed && state.seen.size < 500) state.seen.add(`called:${item.tool || item.name}`);
+      } else if (item?.type === "command_execution" && event.type === "item.started") {
+        this.note(cell, `command:${item.id}`, "Running a shell command");
+      }
+      const content = event.message?.content || event.content;
+      if (Array.isArray(content)) for (const block of content) {
+        if (block?.type === "tool_use") {
+          const name = cleanLabel(block.name || "tool");
+          if (state.tools.size < 100) state.tools.set(block.id, name);
+          this.note(cell, `use:${block.id}`, `Calling: ${name}`);
+        } else if (block?.type === "tool_result") {
+          const name = state.tools.get(block.tool_use_id) || "tool";
+          this.note(cell, `result:${block.tool_use_id}`, `Tool ${block.is_error ? "failed" : "completed"}: ${name}`, block.is_error ? "failed" : "done");
+        }
+      }
+      if (event.type === "turn.started") this.note(cell, "turn", "Agent working");
+      if (event.type === "turn.failed") this.note(cell, "turn-failed", "Agent turn failed", "failed");
+    }
+  }
+
+  flush() {
+    if (this.lines.length) this.write(`${this.lines.slice(0, MAX_LINES).join("\n")}\n`);
+    if (this.omitted) this.write(`  … ${this.omitted} more updates; full details in the swarm page.\n`);
+    this.lines = [];
+    this.omitted = 0;
+  }
+}
+
+export function progressLine(run, cells, started) {
+  const counts = {};
+  for (const cell of cells) counts[cell.status] = (counts[cell.status] || 0) + 1;
+  const done = (counts.done || 0) + (counts.failed || 0) + (counts.cancelled || 0);
+  const elapsed = Math.max(0, Math.floor((Date.now() - started) / 1000));
+  const age = elapsed < 60 ? `${elapsed}s` : `${Math.floor(elapsed / 60)}m ${elapsed % 60}s`;
+  const state = run.status === "queued" ? "Waiting for a worker" : FINISHED.has(run.status) ? cleanLabel(run.status) : "Running";
+  return `${state} · ${counts.queued || 0} queued · ${counts.running || 0} running · ${done}/${cells.length} finished · watching ${age}\n`;
+}

package/bin/swarm.js

@@ -9,6 +9,9 @@
  * won when it did not.
  */
 
+import { setTimeout as wait } from "node:timers/promises";
+import { SwarmProgress, cleanLabel, progressLine } from "./swarm-progress.js";
+
 import {
   backendUrl,
   callBackendJson,
@@ -25,8 +28,9 @@ Swarm options:
   preman swarm list                       Recent swarms and what each found
   preman swarm launch --server <slug|id> --ask "<what a developer asks>" [--ask ...]
         [--expect tool,tool] [--agents claude_code,codex,...] [--rivals 0,5]
-        [--size 60] [--name <label>] [--dry-run]
-                                          Start a swarm (--dry-run only counts it)
+        [--size 60] [--name <label>] [--dry-run] [--no-watch]
+                                          Launch and follow live actions until done
+                                          --no-watch queues and returns immediately
   preman swarm watch <id> [--once]        Follow a swarm until it finishes
   preman swarm stop <id>                  Stop a swarm; unfinished agents do not run
   preman swarm bank [--server <slug|id>]  Behaviors PreMan learned and you kept
@@ -49,7 +53,7 @@ const AGENT_NAMES = {
 };
 
 const TERMINAL = new Set(["done", "failed", "cancelled"]);
-const POLL_MS = 5000;
+const POLL_MS = 2000;
 
 function environmentOf(harness) {
   return ENVIRONMENTS.find((env) => env.harnesses.includes(harness))?.id || "other";
@@ -87,7 +91,7 @@ export function positionals(raw) {
   return out;
 }
 
-const BARE_FLAGS = new Set(["--json", "--once", "--dry-run", "--no-color"]);
+const BARE_FLAGS = new Set(["--json", "--once", "--dry-run", "--no-color", "--no-watch"]);
 
 function listOf(value) {
   return String(value || "")
@@ -133,17 +137,21 @@ export function summarize(cells) {
     };
     if (cell.status === "running") agent.running += 1;
     else if (cell.status === "queued") agent.queued += 1;
-    const unseen = cell.evidence?.tool_surfaced_by_search === false && arm === "deferred";
+    const expected = new Set([
+      ...(cell.evidence?.expected?.tools || []),
+      cell.evidence?.expected?.tool,
+      ...(cell.evidence?.expected?.alternates || []),
+    ].filter(Boolean));
+    const called = cell.evidence?.tools_called || [];
+    // Missing search telemetry cannot erase a recorded selection or call to
+    // the expected tool. Codex can call it without emitting a tool search.
+    const sawExpected = cell.selected === true || called.some((tool) => expected.has(tool));
+    const unseen = !sawExpected && cell.evidence?.tool_surfaced_by_search === false && arm === "deferred";
     if ((cell.selected === true || cell.selected === false) && !unseen) {
       agent.scored += 1;
       if (cell.selected) agent.picked += 1;
       else {
-        const expected = new Set([
-          ...(cell.evidence?.expected?.tools || []),
-          cell.evidence?.expected?.tool,
-          ...(cell.evidence?.expected?.alternates || []),
-        ].filter(Boolean));
-        for (const tool of cell.evidence?.tools_called || []) {
+        for (const tool of called) {
           if (!expected.has(tool)) agent.lostTo.set(tool, (agent.lostTo.get(tool) || 0) + 1);
         }
       }
@@ -173,7 +181,7 @@ export function renderSwarm(run, cells, { colour = false } = {}) {
   const done = (cells || []).filter((cell) => cell.status === "done" || cell.status === "failed").length;
   const lines = [];
   lines.push(
-    `${paint.bold(run.release_label || run.id)}  ${paint.dim(run.hosted_mcp_name || run.hosted_mcp_slug || "")}  ${run.status}`
+    `${paint.bold(cleanLabel(run.release_label || run.id))}  ${paint.dim(cleanLabel(run.hosted_mcp_name || run.hosted_mcp_slug || ""))}  ${cleanLabel(run.status)}`
   );
   if (summary.scored) {
     const range = likelyRange(summary.picked, summary.scored);
@@ -192,8 +200,8 @@ export function renderSwarm(run, cells, { colour = false } = {}) {
       const rate = agent.rate === null ? paint.dim("—") : agent.rate >= 0.75 ? paint.green(pct(agent.rate)) : agent.rate >= 0.4 ? paint.yellow(pct(agent.rate)) : paint.red(pct(agent.rate));
       const working = agent.running ? paint.dim(` · ${agent.running} working`) : "";
       const rival = [...agent.lostTo.entries()].sort((a, b) => b[1] - a[1])[0];
-      const lost = rival ? paint.dim(` · lost to ${rival[0]} ×${rival[1]}`) : "";
-      lines.push(`  ${truncate(agent.name, 30).padEnd(30)} ${String(rate).padStart(colour ? 13 : 4)}  ${paint.dim(`${agent.picked}/${agent.scored}`)}${working}${lost}`);
+      const lost = rival ? paint.dim(` · lost to ${cleanLabel(rival[0])} ×${rival[1]}`) : "";
+      lines.push(`  ${truncate(cleanLabel(agent.name), 30).padEnd(30)} ${String(rate).padStart(colour ? 13 : 4)}  ${paint.dim(`${agent.picked}/${agent.scored}`)}${working}${lost}`);
     }
   }
   return `${lines.join("\n")}\n`;
@@ -221,14 +229,16 @@ function requireToken(args) {
 async function call(args, token, method, path, options = {}) {
   const result = await callBackendJson(args, method, path, { token, ...options });
   if (!result.ok) {
-    throw new Error(`${method} ${path} on ${backendUrl(args)}: ${result.status_code} ${describeFailure(result, "request failed")}`);
+    const error = new Error(`${method} ${path} on ${backendUrl(args)}: ${result.status_code} ${describeFailure(result, "request failed")}`);
+    error.status = result.status_code;
+    throw error;
   }
   return result;
 }
 
-async function findServer(args, token, ref) {
+async function findServer(request, ref) {
   if (/^[0-9a-f-]{36}$/i.test(ref)) return { id: ref, name: ref };
-  const result = await call(args, token, "GET", "/hosted-mcps");
+  const result = await request("GET", "/hosted-mcps");
   const servers = result.hosted_mcps || result.list || [];
   const match = servers.find((server) => [server.slug, server.name, server.id].includes(ref));
   if (!match) {
@@ -238,9 +248,9 @@ async function findServer(args, token, ref) {
   return match;
 }
 
-async function readSwarm(args, token, id) {
-  const run = await call(args, token, "GET", `/matrix/runs/${encodeURIComponent(id)}`);
-  const cells = await call(args, token, "GET", `/matrix/runs/${encodeURIComponent(id)}/cells`);
+async function readSwarm(request, id) {
+  const run = await request("GET", `/matrix/runs/${encodeURIComponent(id)}`);
+  const cells = await request("GET", `/matrix/runs/${encodeURIComponent(id)}/cells`);
   const { status_code, ok, ...runBody } = run;
   return { run: runBody, cells: cells.cells || cells.list || [] };
 }
@@ -249,25 +259,131 @@ function swarmLink(args, id) {
   return `${frontendUrl(args)}/workbench/swarms/swarms/${encodeURIComponent(id)}`;
 }
 
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function followSwarm(id, { args, request, write, colour, signal, pollMs, once = false, json = false }) {
+  const controller = new AbortController();
+  const interrupt = () => controller.abort();
+  if (signal?.aborted) controller.abort();
+  signal?.addEventListener("abort", interrupt, { once: true });
+  if (!signal) process.on("SIGINT", interrupt);
+  const read = (method, path, options) => request(method, path, { ...options, signal: controller.signal });
+  const resume = `${cliInvocation()} swarm watch ${id}`;
+  const progress = new SwarmProgress({ write, colour });
+  const started = Date.now();
+  let cursor = 0;
+  let failures = 0;
+  let consoleWarned = false;
+  if (!once && !json) write("Following live actions. Ctrl+C stops watching; the swarm keeps running.\n");
+  try {
+    for (;;) {
+      let snapshot;
+      try {
+        snapshot = await readSwarm(read, id);
+        failures = 0;
+      } catch (error) {
+        if (controller.signal.aborted) throw error;
+        failures += 1;
+        const retryable = !error.status || error.status === 429 || error.status >= 500;
+        if (once || json || !retryable || failures >= 3) throw error;
+        write(`Connection interrupted; retrying status (${failures}/3). Swarm ${id} remains on the server.\n`);
+        await wait(pollMs, undefined, { signal: controller.signal });
+        continue;
+      }
+      const { run, cells } = snapshot;
+      if (json) {
+        write(`${JSON.stringify({ run, summary: summarize(cells) }, (k, v) => (v instanceof Map ? Object.fromEntries(v) : v), 2)}\n`);
+        return;
+      }
+      if (once) {
+        write(renderSwarm(run, cells, { colour }));
+        write(`\n${swarmLink(args, id)}\n`);
+        return;
+      }
+      write(progressLine(run, cells, started));
+      progress.observe(cells);
+      // At most four console reads per poll, rotated across larger swarms.
+      // Keep finished cells eligible for their final output after status changes.
+      const available = cells.filter((cell) => cell.id && cell.status !== "queued" && !progress.state(cell).consoleFinished);
+      const selected = available.length ? Array.from({ length: Math.min(4, available.length) }, (_, i) => available[(cursor + i) % available.length]) : [];
+      cursor += selected.length;
+      const logs = await Promise.allSettled(selected.map((cell) => read("GET", `/matrix/cells/${encodeURIComponent(cell.id)}/console`, { query: { after: progress.state(cell).offset } })));
+      for (let i = 0; i < logs.length; i += 1) {
+        const log = logs[i];
+        if (log.status === "fulfilled") {
+          progress.console(selected[i], log.value);
+          if (TERMINAL.has(selected[i].status)) progress.state(selected[i]).consoleFinished = true;
+        } else if (!controller.signal.aborted && !consoleWarned) {
+          write("  Live action output is unavailable; continuing to follow run status.\n");
+          consoleWarned = true;
+        }
+      }
+      if (controller.signal.aborted) throw new Error("Interrupted");
+      progress.observe(cells, { results: true });
+      progress.flush();
+      if (once || TERMINAL.has(run.status)) {
+        const eligible = cells.filter((cell) => cell.id && cell.status !== "queued");
+        const shown = eligible.filter((cell) => progress.state(cell).consoleFinished).length;
+        if (shown < eligible.length) write(`Action logs shown for ${shown} of ${eligible.length} attempts; open the swarm page for all logs.\n`);
+        write(renderSwarm(run, cells, { colour }));
+        if (run.stop_reason) write(`Stopped: ${cleanLabel(run.stop_reason)}\n`);
+        write(`\n${swarmLink(args, id)}\n`);
+        return;
+      }
+      await wait(pollMs, undefined, { signal: controller.signal });
+    }
+  } catch (error) {
+    if (controller.signal.aborted) {
+      write(`\nStopped watching. The swarm was not cancelled.\nResume: ${resume}\n`);
+      return;
+    }
+    throw new Error(`Could not follow swarm ${id}: ${cleanLabel(error.message, 240)}\nResume: ${resume}`);
+  } finally {
+    signal?.removeEventListener("abort", interrupt);
+    if (!signal) process.off("SIGINT", interrupt);
+  }
+}
 
-export async function swarmCommand(commandArgs = []) {
+export async function swarmCommand(commandArgs = [], {
+  sessionArgs, token: sessionToken, workspaceId, signal,
+  write = (text) => process.stdout.write(text), pollMs = POLL_MS,
+} = {}) {
   const [sub = "list", ...rest] = commandArgs;
-  const args = makeArgs(rest);
+  // A session's credential stays with its backend even when slash-command
+  // arguments contain transport overrides. First occurrence wins in makeArgs.
+  const args = makeArgs(sessionArgs ? [
+    "--backend", backendUrl(sessionArgs), "--frontend", frontendUrl(sessionArgs),
+    ...(sessionArgs.has("--no-color") || sessionArgs.has("--no-colour") ? ["--no-color"] : []), ...rest,
+  ] : rest);
   const json = args.has("--json");
   const colour = colourEnabled(args);
-  const token = requireToken(args);
+  const token = sessionToken || requireToken(args);
+  const request = async (method, path, options = {}) => {
+    const parent = options.signal || signal;
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    if (parent?.aborted) abort();
+    parent?.addEventListener("abort", abort, { once: true });
+    const timeout = setTimeout(abort, 15000);
+    try {
+      return await call(args, token, method, path, {
+        ...options, signal: controller.signal,
+        ...(workspaceId ? { headers: { "x-workspace-id": workspaceId } } : {}),
+      });
+    } finally {
+      clearTimeout(timeout);
+      parent?.removeEventListener("abort", abort);
+    }
+  };
 
   if (sub === "list") {
-    const result = await call(args, token, "GET", "/matrix/runs");
+    const result = await request("GET", "/matrix/runs");
     const runs = result.runs || result.list || [];
-    if (json) return void process.stdout.write(`${JSON.stringify(runs, null, 2)}\n`);
+    if (json) return void write(`${JSON.stringify(runs, null, 2)}\n`);
     if (!runs.length) {
-      process.stdout.write(`No swarms yet. Start one with \`${cliInvocation()} swarm launch\`.\n`);
+      write(`No swarms yet. Start one with \`${cliInvocation()} swarm launch\`.\n`);
       return;
     }
     for (const run of runs.slice(0, 20)) {
-      process.stdout.write(
+      write(
         `${String(run.id).slice(0, 8)}  ${truncate(run.release_label || "", 32).padEnd(32)}  ` +
           `${truncate(run.hosted_mcp_name || run.hosted_mcp_slug || "", 20).padEnd(20)}  ${String(run.status).padEnd(9)}  ${headlineFromRollup(run)}\n`
       );
@@ -281,7 +397,8 @@ export async function swarmCommand(commandArgs = []) {
     if (!serverRef || !asks.length) {
       throw new Error(`a swarm needs --server and at least one --ask.${SWARM_HELP}`);
     }
-    const server = await findServer(args, token, serverRef);
+    if (!json && !args.has("--dry-run")) write(`Resolving ${cleanLabel(serverRef)}…\n`);
+    const server = await findServer(request, serverRef);
     const expect = listOf(args.value("--expect"));
     const payload = {
       hosted_mcp_id: server.id,
@@ -296,60 +413,50 @@ export async function swarmCommand(commandArgs = []) {
     const agents = listOf(args.value("--agents"));
     if (agents.length) payload.harnesses = agents;
     if (args.has("--dry-run")) payload.dry_run = true;
-    const result = await call(args, token, "POST", "/matrix/runs", { json: payload });
+    if (!json && !payload.dry_run) write("Queueing swarm…\n");
+    const result = await request("POST", "/matrix/runs", { json: payload });
     const { status_code, ok, ...body } = result;
-    if (json) return void process.stdout.write(`${JSON.stringify(body, null, 2)}\n`);
+    if (json) return void write(`${JSON.stringify(body, null, 2)}\n`);
     if (payload.dry_run) {
-      process.stdout.write(`Would send ${body.cell_count ?? "?"} attempts (${body.asks_used ?? asks.length} asks, ${body.replicates ?? 1}× each).\n`);
+      write(`Would send ${body.cell_count ?? "?"} attempts (${body.asks_used ?? asks.length} asks, ${body.replicates ?? 1}× each).\n`);
       return;
     }
-    process.stdout.write(`Swarm ${body.id} launched against ${server.name || server.slug}.\n`);
-    process.stdout.write(`  Watch:  ${cliInvocation()} swarm watch ${body.id}\n  Open:   ${swarmLink(args, body.id)}\n`);
+    write(`Swarm ${cleanLabel(body.id)} launched against ${cleanLabel(server.name || server.slug)}.\n`);
+    write(`  Watch:  ${cliInvocation()} swarm watch ${body.id}\n  Open:   ${swarmLink(args, body.id)}\n`);
+    if (!args.has("--no-watch")) await followSwarm(body.id, { args, request, write, colour, signal, pollMs });
     return;
   }
 
   if (sub === "watch" || sub === "show") {
     const [id] = positionals(rest);
     if (!id) throw new Error(`which swarm? ${cliInvocation()} swarm watch <id>`);
-    for (;;) {
-      const { run, cells } = await readSwarm(args, token, id);
-      if (json) {
-        process.stdout.write(`${JSON.stringify({ run, summary: summarize(cells) }, (k, v) => (v instanceof Map ? Object.fromEntries(v) : v), 2)}\n`);
-      } else {
-        if (process.stdout.isTTY && sub === "watch") process.stdout.write("\u001b[2J\u001b[H");
-        process.stdout.write(renderSwarm(run, cells, { colour }));
-      }
-      if (sub === "show" || args.has("--once") || TERMINAL.has(run.status)) {
-        if (!json) process.stdout.write(`\n${swarmLink(args, id)}\n`);
-        return;
-      }
-      await sleep(POLL_MS);
-    }
+    await followSwarm(id, { args, request, write, colour, signal, pollMs, json, once: sub === "show" || args.has("--once") || json });
+    return;
   }
 
   if (sub === "stop") {
     const [id] = positionals(rest);
     if (!id) throw new Error(`which swarm? ${cliInvocation()} swarm stop <id>`);
-    await call(args, token, "POST", `/matrix/runs/${encodeURIComponent(id)}/cancel`);
-    process.stdout.write(`Stopped ${id}. Agents that had not finished will not run.\n`);
+    await request("POST", `/matrix/runs/${encodeURIComponent(id)}/cancel`);
+    write(`Stopped ${id}. Agents that had not finished will not run.\n`);
     return;
   }
 
   if (sub === "bank") {
     const serverRef = args.value("--server");
-    const server = serverRef ? await findServer(args, token, serverRef) : null;
-    const result = await call(args, token, "GET", "/swarms/behaviors", {
+    const server = serverRef ? await findServer(request, serverRef) : null;
+    const result = await request("GET", "/swarms/behaviors", {
       query: server ? { hosted_mcp_id: server.id } : undefined,
     });
     const kept = (result.behaviors || []).filter((row) => row.status === "kept");
-    if (json) return void process.stdout.write(`${JSON.stringify(kept, null, 2)}\n`);
+    if (json) return void write(`${JSON.stringify(kept, null, 2)}\n`);
     if (!kept.length) {
-      process.stdout.write("Nothing kept yet. After a swarm, keep the patterns PreMan finds in its misses.\n");
+      write("Nothing kept yet. After a swarm, keep the patterns PreMan finds in its misses.\n");
       return;
     }
     for (const row of kept) {
-      process.stdout.write(`${row.hosted_mcp_name || ""}  ${row.title}  (${row.evidence?.count || 0} attempts)\n`);
-      for (const ask of (row.seed?.asks || []).slice(0, 3)) process.stdout.write(`    “${truncate(ask.prompt, 70)}”\n`);
+      write(`${row.hosted_mcp_name || ""}  ${row.title}  (${row.evidence?.count || 0} attempts)\n`);
+      for (const ask of (row.seed?.asks || []).slice(0, 3)) write(`    “${truncate(ask.prompt, 70)}”\n`);
     }
     return;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "premanmcp",
-  "version": "1.1.17",
+  "version": "1.1.19",
   "description": "PreMan CLI and stdio proxy for PreMan's hosted MCP server",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test:proxy": "node --test scripts/smoke-proxy.mjs",
     "test:connect": "node scripts/smoke-connect.mjs",
     "test:connect-heartbeat": "node scripts/smoke-connect-heartbeat.mjs",
-    "test:node": "node --test --test-timeout=90000 scripts/smoke-account.mjs scripts/smoke-agent-session.mjs scripts/smoke-agent-dock.mjs scripts/smoke-terminal-lifecycle.mjs scripts/smoke-cli-entrypoint.mjs scripts/smoke-cli-update.mjs scripts/smoke-launcher-config.mjs scripts/smoke-runner.mjs scripts/smoke-eval.mjs scripts/smoke-eval-start.mjs scripts/smoke-eval-run-watch.mjs scripts/smoke-eval-behaviors.mjs scripts/smoke-eval-runtime.mjs scripts/smoke-eval-entry.mjs scripts/smoke-eval-entry-placeholder.mjs scripts/smoke-eval-discover.mjs scripts/smoke-eval-templates.mjs scripts/smoke-eval-decorated-capture.mjs scripts/smoke-eval-decorate-approval.mjs scripts/smoke-eval-approval-record.mjs scripts/smoke-repo-config.mjs scripts/smoke-onboard.mjs scripts/smoke-onboard-opening.mjs scripts/smoke-local-detect.mjs scripts/smoke-agent-target.mjs scripts/smoke-prepush-hook.mjs scripts/smoke-cli-identity.mjs scripts/smoke-runner-heartbeat.mjs scripts/smoke-verify-prepush.mjs scripts/smoke-push-diff.mjs scripts/smoke-progress-reporter.mjs scripts/smoke-verify-plan.mjs scripts/smoke-install-desktop.mjs scripts/smoke-desktop-session.mjs scripts/smoke-api-tools.mjs scripts/smoke-tests-workbench.mjs scripts/smoke-bin-scope.mjs scripts/smoke-shared-errors.mjs scripts/smoke-prompts.mjs scripts/smoke-process-title.mjs scripts/smoke-predict.mjs scripts/smoke-swarm.mjs",
+    "test:node": "node --test --test-timeout=90000 scripts/smoke-account.mjs scripts/smoke-agent-session.mjs scripts/smoke-agent-dock.mjs scripts/smoke-terminal-lifecycle.mjs scripts/smoke-cli-entrypoint.mjs scripts/smoke-cli-update.mjs scripts/smoke-launcher-config.mjs scripts/smoke-runner.mjs scripts/smoke-eval.mjs scripts/smoke-eval-start.mjs scripts/smoke-eval-run-watch.mjs scripts/smoke-eval-behaviors.mjs scripts/smoke-eval-runtime.mjs scripts/smoke-eval-entry.mjs scripts/smoke-eval-entry-placeholder.mjs scripts/smoke-eval-discover.mjs scripts/smoke-eval-templates.mjs scripts/smoke-eval-decorated-capture.mjs scripts/smoke-eval-decorate-approval.mjs scripts/smoke-eval-approval-record.mjs scripts/smoke-repo-config.mjs scripts/smoke-onboard.mjs scripts/smoke-onboard-opening.mjs scripts/smoke-local-detect.mjs scripts/smoke-agent-target.mjs scripts/smoke-prepush-hook.mjs scripts/smoke-cli-identity.mjs scripts/smoke-runner-heartbeat.mjs scripts/smoke-verify-prepush.mjs scripts/smoke-push-diff.mjs scripts/smoke-progress-reporter.mjs scripts/smoke-verify-plan.mjs scripts/smoke-install-desktop.mjs scripts/smoke-desktop-session.mjs scripts/smoke-api-tools.mjs scripts/smoke-tests-workbench.mjs scripts/smoke-bin-scope.mjs scripts/smoke-shared-errors.mjs scripts/smoke-prompts.mjs scripts/smoke-process-title.mjs scripts/smoke-predict.mjs scripts/smoke-swarm.mjs scripts/smoke-swarm-follow.mjs",
     "test:dmg": "node --test --test-timeout=300000 scripts/smoke-install-desktop-volume.mjs"
   },
   "devDependencies": {