premanmcp 1.1.18 → 1.1.19

package/README.md

@@ -83,8 +83,10 @@ account, backend, and workspace:
 /swarm stop <run-id>
 ```
 
-`/swarm help` lists every option. Add `--dry-run` to preview a launch without
-starting attempts. Ctrl+C while watching returns to the conversation and leaves
+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.

package/bin/agent.js

@@ -2086,7 +2086,7 @@ export async function runSwarm(rest, { args, token, workspaceId, say, paint, reg
     }
     await swarmCommand(argv, {
       sessionArgs: args, token, workspaceId, signal: controller.signal,
-      write: say, clearWatch: false,
+      write: say,
     });
     say("\n");
   } catch (error) {

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

@@ -10,6 +10,7 @@
  */
 
 import { setTimeout as wait } from "node:timers/promises";
+import { SwarmProgress, cleanLabel, progressLine } from "./swarm-progress.js";
 
 import {
   backendUrl,
@@ -27,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
@@ -51,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";
@@ -89,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 || "")
@@ -179,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);
@@ -198,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`;
@@ -227,7 +229,9 @@ 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;
 }
@@ -255,9 +259,92 @@ function swarmLink(args, id) {
   return `${frontendUrl(args)}/workbench/swarms/swarms/${encodeURIComponent(id)}`;
 }
 
+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 = [], {
   sessionArgs, token: sessionToken, workspaceId, signal,
-  write = (text) => process.stdout.write(text), clearWatch = true,
+  write = (text) => process.stdout.write(text), pollMs = POLL_MS,
 } = {}) {
   const [sub = "list", ...rest] = commandArgs;
   // A session's credential stays with its backend even when slash-command
@@ -269,9 +356,23 @@ export async function swarmCommand(commandArgs = [], {
   const json = args.has("--json");
   const colour = colourEnabled(args);
   const token = sessionToken || requireToken(args);
-  const request = (method, path, options = {}) => call(args, token, method, path, {
-    ...options, signal, ...(workspaceId ? { headers: { "x-workspace-id": workspaceId } } : {}),
-  });
+  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 request("GET", "/matrix/runs");
@@ -296,6 +397,7 @@ export async function swarmCommand(commandArgs = [], {
     if (!serverRef || !asks.length) {
       throw new Error(`a swarm needs --server and at least one --ask.${SWARM_HELP}`);
     }
+    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 = {
@@ -311,6 +413,7 @@ 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;
+    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 write(`${JSON.stringify(body, null, 2)}\n`);
@@ -318,28 +421,17 @@ export async function swarmCommand(commandArgs = [], {
       write(`Would send ${body.cell_count ?? "?"} attempts (${body.asks_used ?? asks.length} asks, ${body.replicates ?? 1}× each).\n`);
       return;
     }
-    write(`Swarm ${body.id} launched against ${server.name || server.slug}.\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(request, id);
-      if (json) {
-        write(`${JSON.stringify({ run, summary: summarize(cells) }, (k, v) => (v instanceof Map ? Object.fromEntries(v) : v), 2)}\n`);
-      } else {
-        if (clearWatch && process.stdout.isTTY && sub === "watch") write("\u001b[2J\u001b[H");
-        write(renderSwarm(run, cells, { colour }));
-      }
-      if (sub === "show" || args.has("--once") || TERMINAL.has(run.status)) {
-        if (!json) write(`\n${swarmLink(args, id)}\n`);
-        return;
-      }
-      await wait(POLL_MS, undefined, { signal });
-    }
+    await followSwarm(id, { args, request, write, colour, signal, pollMs, json, once: sub === "show" || args.has("--once") || json });
+    return;
   }
 
   if (sub === "stop") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "premanmcp",
-  "version": "1.1.18",
+  "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": {