@wrongstack/cli 0.295.1 → 0.296.3

package/dist/acp-A5OSIU2P.js

@@ -0,0 +1,824 @@
+import {
+  createGracefulShutdown,
+  loadCachedAcpRegistry,
+  refreshAcpRegistry,
+  setupProvider
+} from "./chunk-AZESNNIC.js";
+import "./chunk-TADVX644.js";
+import "./chunk-PJHET45A.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/subcommands/handlers/acp.ts
+import {
+  defaultPermissionPolicy,
+  EnsembleRegistry,
+  probeAcpAgents,
+  renderAcpBenchText,
+  resolveAcpAgentCommand,
+  runAcpBench,
+  runEnsemble,
+  runOneAcpTask
+} from "@wrongstack/acp";
+import {
+  ACPProtocolHandler,
+  ACPSessionStore,
+  makeACPServerAgentTurn,
+  WrongStackACPServer,
+  WsBridgeTransport
+} from "@wrongstack/acp/agent";
+import * as path from "node:path";
+import { WebSocketServer } from "ws";
+
+// src/acp-server-agent.ts
+import { Agent, Context, createDefaultPipelines } from "@wrongstack/core/agent";
+import { AutoApprovePermissionPolicy, ToolCapabilities } from "@wrongstack/core/security";
+import { DefaultLogger } from "@wrongstack/core/infrastructure";
+import { EventBus, TOKENS } from "@wrongstack/core/kernel";
+import { ToolValidationError } from "@wrongstack/core/types";
+import { ToolRegistry } from "@wrongstack/core/registry";
+import { DefaultTokenCounter } from "@wrongstack/core/infrastructure";
+import { ToolExecutor } from "@wrongstack/core/execution";
+import { createDefaultContainer } from "@wrongstack/runtime";
+var AcpServerConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AcpServerConfigError";
+  }
+};
+var SAFE_CAPS = /* @__PURE__ */ new Set([
+  ToolCapabilities.FS_READ,
+  ToolCapabilities.NET_OUTBOUND,
+  ToolCapabilities.COORDINATION_FLEET_READ
+]);
+var ACPClientPermissionPolicy = class {
+  constructor(requestPermission) {
+    this.requestPermission = requestPermission;
+  }
+  requestPermission;
+  async evaluate(tool, input) {
+    const caps = tool.capabilities ?? [];
+    const isSafe = caps.length > 0 && caps.every((c) => SAFE_CAPS.has(c));
+    if (isSafe) {
+      return { permission: "auto", source: "default" };
+    }
+    const title = describeToolCall(tool.name, input);
+    try {
+      const outcome = await this.requestPermission({
+        toolCall: { toolCallId: `tc_${tool.name}_${Date.now()}`, title },
+        options: [
+          { optionId: "allow_once", name: "Allow", kind: "allow_once" },
+          { optionId: "allow_always", name: "Always allow", kind: "allow_always" },
+          { optionId: "reject_once", name: "Reject", kind: "reject_once" }
+        ]
+      });
+      const optionId = outcome.outcome === "selected" ? outcome.optionId : void 0;
+      const allowed = typeof optionId === "string" && optionId.startsWith("allow");
+      return allowed ? { permission: "auto", source: "user" } : { permission: "deny", source: "user", reason: "rejected by ACP client" };
+    } catch {
+      return { permission: "deny", source: "deny", reason: "no permission channel" };
+    }
+  }
+  async trust() {
+  }
+  async deny() {
+  }
+  denyOnce() {
+  }
+  allowOnce() {
+  }
+  async reload() {
+  }
+};
+function describeToolCall(name, input) {
+  if (input && typeof input === "object") {
+    const r = input;
+    const arg = r.path ?? r.file ?? r.command ?? r.pattern;
+    if (typeof arg === "string") return `${name}: ${arg}`;
+  }
+  return name;
+}
+function wireClientBackedTools(tools, api) {
+  const caps = api.clientCapabilities ?? {};
+  const swap = (name, make) => {
+    const base = tools.get(name);
+    if (!base) return;
+    tools.unregister(name);
+    tools.register(make(base));
+  };
+  if (caps.fs?.readTextFile) {
+    swap("read", (base) => makeAcpRead(base, api));
+  }
+  if (caps.fs?.writeTextFile) {
+    swap("write", (base) => makeAcpWrite(base, api));
+    swap("edit", (base) => makeAcpEdit(base, api));
+  }
+  if (caps.terminal) {
+    swap("bash", (base) => makeAcpBash(base, api));
+  }
+}
+function makeAcpRead(base, api) {
+  return {
+    ...base,
+    mutating: false,
+    execute: async (input) => {
+      const i = input ?? {};
+      if (!i.path) throw new ToolValidationError({ message: "read: path is required", field: "path" });
+      const content = await api.readTextFile({
+        path: i.path,
+        ...typeof i.offset === "number" ? { line: i.offset } : {},
+        ...typeof i.limit === "number" ? { limit: i.limit } : {}
+      });
+      const lines = content.split(/\r\n|\r|\n/);
+      const start = Math.max(1, i.offset ?? 1);
+      const width = String(start + lines.length - 1).length;
+      const text = lines.map((l, idx) => `${String(start + idx).padStart(width, " ")}\u2192${l}`).join("\n");
+      return { text, total_lines: lines.length, encoding: "utf8", truncated: false };
+    }
+  };
+}
+function makeAcpWrite(base, api) {
+  return {
+    ...base,
+    execute: async (input) => {
+      const i = input ?? {};
+      if (!i.path) throw new ToolValidationError({ message: "write: path is required", field: "path" });
+      await api.writeTextFile({ path: i.path, content: i.content ?? "" });
+      return { path: i.path, ok: true };
+    }
+  };
+}
+function makeAcpEdit(base, api) {
+  return {
+    ...base,
+    execute: async (input) => {
+      const i = input ?? {};
+      if (!i.path) throw new ToolValidationError({ message: "edit: path is required", field: "path" });
+      if (!i.old_string) throw new ToolValidationError({ message: "edit: old_string is required", field: "old_string" });
+      const before = await api.readTextFile({ path: i.path });
+      const occurrences = before.split(i.old_string).length - 1;
+      if (occurrences === 0) {
+        throw new ToolValidationError({
+          message: `edit: old_string not found in "${i.path}"`,
+          field: "old_string",
+          context: { path: i.path }
+        });
+      }
+      if (occurrences > 1 && !i.replace_all) {
+        throw new ToolValidationError({
+          message: `edit: old_string appears ${occurrences} times in "${i.path}"; pass replace_all or use a more specific string`,
+          field: "old_string",
+          context: { path: i.path, occurrences, replaceAll: false }
+        });
+      }
+      const after = i.replace_all ? before.split(i.old_string).join(i.new_string ?? "") : before.replace(i.old_string, i.new_string ?? "");
+      await api.writeTextFile({ path: i.path, content: after });
+      return { path: i.path, replacements: i.replace_all ? occurrences : 1 };
+    }
+  };
+}
+function makeAcpBash(base, api) {
+  return {
+    ...base,
+    execute: async (input) => {
+      const i = input ?? {};
+      if (!i.command) throw new ToolValidationError({ message: "bash: command is required", field: "command" });
+      const { output, exitCode } = await api.runTerminal({
+        command: "sh",
+        args: ["-c", i.command],
+        ...i.cwd ? { cwd: i.cwd } : {}
+      });
+      return { stdout: output, exit_code: exitCode, command: i.command };
+    }
+  };
+}
+function buildAcpServerAgentFactory(deps, options = {}) {
+  const config = deps.config;
+  if (!config.provider || !config.model) {
+    throw new AcpServerConfigError(
+      "No model provider is configured. Run `wstack auth` to add credentials, or start the server with `wstack acp --echo` for a no-op connectivity test."
+    );
+  }
+  const logger = options.logger ?? new DefaultLogger({ stderr: true });
+  const wpaths = deps.paths;
+  let providerBoot = null;
+  const bootProvider = () => {
+    if (!providerBoot) {
+      providerBoot = setupProvider({ config, modelsRegistry: deps.modelsRegistry, logger });
+    }
+    return providerBoot;
+  };
+  const container = createDefaultContainer({
+    config,
+    wpaths,
+    logger,
+    modelsRegistry: deps.modelsRegistry
+  });
+  return async function agentFor(_sessionId, cwd, api) {
+    await container.resolve(TOKENS.MemoryStore).initialize();
+    const { provider, providerRegistry } = await bootProvider();
+    const events = new EventBus();
+    const source = deps.toolRegistry ?? new ToolRegistry();
+    const tools = new ToolRegistry();
+    for (const t of source.list()) tools.register(t);
+    if (api) {
+      wireClientBackedTools(tools, api);
+    }
+    const permissionPolicy = api?.requestPermission ? new ACPClientPermissionPolicy(api.requestPermission) : new AutoApprovePermissionPolicy();
+    const tokenCounter = new DefaultTokenCounter({
+      registry: deps.modelsRegistry,
+      providerId: config.provider,
+      events
+    });
+    const session = { append: async () => {
+    } };
+    const context = new Context({
+      systemPrompt: [],
+      provider,
+      session,
+      signal: new AbortController().signal,
+      tokenCounter,
+      cwd,
+      projectRoot: cwd,
+      allowOutsideProjectRoot: config.features?.allowOutsideProjectRoot ?? false,
+      model: config.model,
+      tools: [...tools.list()],
+      agentId: "acp-server",
+      agentName: "wrongstack-acp"
+    });
+    const toolExecutor = new ToolExecutor(tools, {
+      permissionPolicy,
+      secretScrubber: container.resolve(TOKENS.SecretScrubber),
+      renderer: void 0,
+      events,
+      confirmAwaiter: void 0,
+      iterationTimeoutMs: config.tools?.iterationTimeoutMs ?? 12e4,
+      maxToolTimeoutMs: config.tools?.maxToolTimeoutMs ?? 3e5,
+      perIterationOutputCapBytes: config.tools?.perIterationOutputCapBytes ?? 1e5,
+      tracer: void 0
+    });
+    return new Agent({
+      container,
+      tools,
+      providers: providerRegistry,
+      events,
+      pipelines: createDefaultPipelines(),
+      context,
+      permissionPolicy,
+      toolExecutor,
+      loopDetection: config.tools?.loopDetection
+    });
+  };
+}
+
+// src/subcommands/handlers/acp.ts
+function acpOverrides(deps) {
+  return deps.config.acp?.agents;
+}
+async function loadLive(deps) {
+  return deps.paths ? loadCachedAcpRegistry(deps.paths) : null;
+}
+var acpCmd = async (args, deps) => {
+  const sub = args[0];
+  if (!sub || sub === "server" || sub === "serve") {
+    return runACPServer(deps);
+  }
+  if (sub === "help") {
+    deps.renderer.write(`wstack acp \u2014 ACP (Agent Client Protocol) integration
+
+Usage:
+  wstack acp              Start WrongStack as an ACP server (blocks)
+  wstack acp server       Same as above
+  wstack acp list         List available ACP agents
+  wstack acp sync         Pull the official agentclientprotocol/registry into cache
+  wstack acp spawn <id> <task>
+                        Spawn an ACP agent as a subagent and wait for result
+  wstack acp parallel <agent-id-csv> <task>
+                        Fan a task out to multiple ACP agents in parallel
+                        and aggregate the results
+  wstack acp probe [agent-id-csv]
+                        Handshake-test agents (bounded concurrency). Defaults
+                        to all installed agents.
+  wstack acp bench [agent-id-csv] [--fs]
+                        End-to-end verify each agent (handshake \u2192 prompt \u2192
+                        marker, optional fs check) and print a graded report.
+                        Defaults to all installed agents.
+  wstack acp help         Show this help
+
+ACP Mode:
+  When run as \`wstack acp\`. WrongStack acts as an ACP-compatible agent driven
+  by your configured model provider. ACP clients (Zed, JetBrains, VS Code)
+  spawn it as a subprocess and communicate over stdio JSON-RPC. Run
+  \`wstack auth\` first to configure a provider, or pass \`--echo\` for a no-op
+  connectivity test that needs no provider. Press Ctrl+C to stop.
+
+  Transports:
+    (default)        stdio JSON-RPC (the usual editor-spawned-subprocess mode)
+    --ws[=port]      serve over WebSocket on 127.0.0.1:<port> (default 8889) \u2014
+                     full-duplex, so updates/permission prompts stream live.
+
+spawn:
+  Spawns a named ACP agent (claude-code, gemini-cli, codex-cli, copilot,
+  cline, goose, openhands, qwen-code, kiro-cli, opencode, mistral-vibe,
+  cursor) with the given task and waits for its result.
+  Example: wstack acp spawn cline "fix the login bug"
+
+parallel:
+  Runs the same task on a comma-separated list of ACP agents concurrently.
+  Example: wstack acp parallel claude-code,gemini-cli,codex-cli "review this diff"
+  Each agent's result is rendered under a clearly-marked header. Returns 0
+  if at least one agent succeeds, 1 if all fail. Agents that aren't
+  installed are skipped with a warning.
+`);
+    return 0;
+  }
+  if (sub === "list") {
+    return listACPAgents(deps);
+  }
+  if (sub === "sync") {
+    return syncACPRegistry(deps);
+  }
+  if (sub === "spawn") {
+    return spawnACPAgent(args.slice(1), deps);
+  }
+  if (sub === "parallel") {
+    return parallelACPAgents(args.slice(1), deps);
+  }
+  if (sub === "probe") {
+    return probeACPAgents(args.slice(1), deps);
+  }
+  if (sub === "bench") {
+    return benchACPAgents(args.slice(1), deps);
+  }
+  deps.renderer.writeError(`Unknown acp subcommand: ${sub}
+`);
+  deps.renderer.write("Run `wstack acp help` for usage.\n");
+  return 1;
+};
+function parseWsPort(flag) {
+  if (flag === void 0 || flag === false) return null;
+  if (flag === true || flag === "true") return 8889;
+  const n = Number(flag);
+  return Number.isInteger(n) && n > 0 && n < 65536 ? n : 8889;
+}
+async function runACPWebSocketServer(deps, port) {
+  const host = "127.0.0.1";
+  const echo = deps.flags?.echo === true || deps.flags?.echo === "true";
+  let turnFactory;
+  let echoTurn;
+  let store;
+  if (echo) {
+    echoTurn = async () => ({ stopReason: "end_turn" });
+  } else {
+    let agentFor;
+    try {
+      agentFor = buildAcpServerAgentFactory(deps);
+    } catch (err) {
+      if (err instanceof AcpServerConfigError) {
+        deps.renderer.writeError(`${err.message}
+`);
+        return 1;
+      }
+      throw err;
+    }
+    turnFactory = () => makeACPServerAgentTurn({ agentFor });
+    store = deps.paths?.projectDir ? new ACPSessionStore({ dir: path.join(deps.paths.projectDir, "acp-sessions") }) : void 0;
+  }
+  const wss = new WebSocketServer({ host, port, maxPayload: 20 * 1024 * 1024 });
+  wss.on("connection", (socket, req) => {
+    const origin = req.headers.origin;
+    if (origin && origin !== `http://${host}:${port}` && origin !== `ws://${host}:${port}`) {
+      socket.close(1008, "cross-origin forbidden");
+      return;
+    }
+    const connectionTurn = turnFactory?.();
+    const transport = new WsBridgeTransport((m) => {
+      const data = JSON.stringify(m);
+      if (socket.bufferedAmount + Buffer.byteLength(data, "utf8") > 32 * 1024 * 1024) {
+        socket.terminate();
+        return;
+      }
+      socket.send(data);
+    });
+    const handler = new ACPProtocolHandler({
+      transport,
+      defaultCwd: deps.cwd ?? process.cwd(),
+      runTurn: connectionTurn ?? echoTurn,
+      ...connectionTurn ? {
+        replayFor: connectionTurn.replay,
+        seedFor: connectionTurn.seed,
+        disposeFor: connectionTurn.dispose
+      } : {},
+      ...store ? { store } : {}
+    });
+    socket.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      transport.receive(msg);
+      void handler.handleMessage(msg);
+    });
+    const teardown = () => {
+      handler.close();
+      transport.close();
+    };
+    socket.on("close", teardown);
+    socket.on("error", teardown);
+  });
+  deps.renderer.writeInfo(
+    echo ? `ACP server (echo, no provider) listening on ws://${host}:${port}. Press Ctrl+C to stop.
+` : `WrongStack ACP server listening on ws://${host}:${port} (${deps.config.provider}/${deps.config.model}). Press Ctrl+C to stop.
+`
+  );
+  await new Promise((resolve) => {
+    const shutdown = () => {
+      deps.renderer.writeWarning("\nShutting down ACP WebSocket server...");
+      wss.close();
+      resolve();
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  });
+  return 0;
+}
+async function runACPServer(deps) {
+  const wsPort = parseWsPort(deps.flags?.ws);
+  if (wsPort !== null) {
+    return runACPWebSocketServer(deps, wsPort);
+  }
+  const echo = deps.flags?.echo === true || deps.flags?.echo === "true";
+  const server = new WrongStackACPServer(
+    echo ? {} : (() => {
+      let agentFor;
+      try {
+        agentFor = buildAcpServerAgentFactory(deps);
+      } catch (err) {
+        if (err instanceof AcpServerConfigError) {
+          deps.renderer.writeError(`${err.message}
+`);
+          return {};
+        }
+        throw err;
+      }
+      const turn = makeACPServerAgentTurn({ agentFor });
+      const store = deps.paths?.projectDir ? new ACPSessionStore({ dir: path.join(deps.paths.projectDir, "acp-sessions") }) : void 0;
+      return {
+        runTurn: turn,
+        replayFor: turn.replay,
+        seedFor: turn.seed,
+        disposeFor: turn.dispose,
+        ...store ? { store } : {}
+      };
+    })()
+  );
+  if (echo) {
+    deps.renderer.writeInfo("ACP server starting in --echo mode (no-op turn; no provider needed).\n");
+  } else {
+    deps.renderer.writeInfo(
+      `Starting WrongStack ACP server (${deps.config.provider}/${deps.config.model})\u2026
+`
+    );
+    deps.renderer.writeInfo("Waiting for an ACP client connection on stdin/stdout. Press Ctrl+C to stop.\n");
+  }
+  createGracefulShutdown({
+    run: async () => {
+      try {
+        server.stop();
+      } catch (err) {
+        deps.renderer.writeError(
+          `ACP stop failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+  }).install();
+  try {
+    await server.start();
+  } catch (err) {
+    deps.renderer.writeError(
+      `ACP server error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return 1;
+  }
+  return 0;
+}
+async function listACPAgents(deps) {
+  const registry = new EnsembleRegistry();
+  const detected = await registry.list();
+  deps.renderer.write("Detected ACP agents:\n\n");
+  const installed = detected.filter((a) => a.installed);
+  const missing = detected.filter((a) => !a.installed);
+  for (const a of installed) {
+    const ver = a.version ? `  (${a.version.split("\n")[0]})` : "";
+    deps.renderer.write(`  \u2713 ${a.id.padEnd(16)} ${a.displayName}${ver}
+`);
+  }
+  for (const a of missing) {
+    deps.renderer.write(`  \u2717 ${a.id.padEnd(16)} ${a.displayName}  (${a.reason ?? "not installed"})
+`);
+  }
+  deps.renderer.write(`
+${installed.length} of ${detected.length} agents available.
+`);
+  const live = await loadLive(deps);
+  if (live && live.agents.length > 0) {
+    deps.renderer.write(
+      `Synced registry: ${live.agents.length} agents available (run \`wstack acp spawn <id> <task>\`).
+`
+    );
+  } else {
+    deps.renderer.write("Run `wstack acp sync` to pull the full official registry (37+ agents).\n");
+  }
+  deps.renderer.write("Use `wstack acp spawn <agent-id> <task>` to delegate a task.\n");
+  return 0;
+}
+async function syncACPRegistry(deps) {
+  if (!deps.paths) {
+    deps.renderer.writeError("Cannot sync: no cache directory available.\n");
+    return 1;
+  }
+  deps.renderer.writeInfo("Fetching the official ACP registry\u2026\n");
+  try {
+    const { count, location } = await refreshAcpRegistry(deps.paths);
+    deps.renderer.write(`Synced ${count} agents from the official ACP registry.
+`);
+    deps.renderer.writeInfo(`Cached at ${location}
+`);
+    return 0;
+  } catch (err) {
+    deps.renderer.writeError(`ACP registry sync failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    deps.renderer.write("The bundled offline catalog is still available via `wstack acp list`.\n");
+    return 1;
+  }
+}
+async function spawnACPAgent(args, deps) {
+  const [subagentId, ...taskParts] = args;
+  if (!subagentId) {
+    deps.renderer.writeError("Usage: wstack acp spawn <agent-id> <task>\n");
+    deps.renderer.write("Run `wstack acp list` to see available agents.\n");
+    return 1;
+  }
+  const task = taskParts.join(" ");
+  if (!task) {
+    deps.renderer.writeError("Usage: wstack acp spawn <agent-id> <task>\n");
+    deps.renderer.write("Task description is required.\n");
+    return 1;
+  }
+  const live = await loadLive(deps);
+  const cmd = resolveAcpAgentCommand(subagentId, acpOverrides(deps), live?.byId);
+  if (!cmd) {
+    deps.renderer.writeError(`Unknown ACP agent: ${subagentId}
+`);
+    deps.renderer.write("Run `wstack acp list` (or `wstack acp sync`) to see available agents.\n");
+    return 1;
+  }
+  deps.renderer.writeInfo(`Spawning ACP agent '${subagentId}'\u2026
+`);
+  const ac = new AbortController();
+  const cleanup = () => ac.abort();
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  try {
+    deps.renderer.writeInfo("Running task\u2026\n");
+    const result = await runOneAcpTask({
+      command: cmd.command,
+      ...cmd.args !== void 0 ? { args: cmd.args } : {},
+      ...cmd.env !== void 0 ? { env: cmd.env } : {},
+      role: subagentId,
+      task,
+      signal: ac.signal,
+      permissionPolicy: defaultPermissionPolicy,
+      onProgress: (event) => {
+        const line = formatProgress(event);
+        if (line) deps.renderer.writeInfo(`  ${line}
+`);
+      }
+    });
+    deps.renderer.write("\n--- Result ---\n");
+    deps.renderer.write(result.result.length > 0 ? result.result : "no result");
+    deps.renderer.write("\n---------------\n");
+    deps.renderer.writeInfo(
+      `Done. iterations=${result.iterations} toolCalls=${result.toolCalls}
+`
+    );
+    return 0;
+  } catch (err) {
+    const e = err;
+    const detail = e.kind ? `[${e.kind}] ` : "";
+    const message = e.message ?? (err instanceof Error ? err.message : String(err));
+    deps.renderer.writeError(`ACP agent error: ${detail}${message}
+`);
+    return 1;
+  } finally {
+    process.off("SIGINT", cleanup);
+    process.off("SIGTERM", cleanup);
+  }
+}
+function formatProgress(event) {
+  switch (event.type) {
+    case "tool_call":
+      return `\u25B8 ${event.toolCall.title} (${event.toolCall.status})`;
+    case "tool_call_update":
+      return event.toolCall.status === "completed" || event.toolCall.status === "failed" ? `  \u21B3 ${event.toolCall.title}: ${event.toolCall.status}` : "";
+    case "diff":
+      return `\u270E ${event.diff.path}${event.diff.oldText === null ? " (new)" : ""}`;
+    case "plan":
+      return `\u2630 plan: ${event.entries.length} step(s)`;
+    default:
+      return "";
+  }
+}
+async function parallelACPAgents(args, deps) {
+  const [csv, ...taskParts] = args;
+  if (!csv) {
+    deps.renderer.writeError("Usage: wstack acp parallel <agent-id-csv> <task>\n");
+    deps.renderer.write('Example: wstack acp parallel claude-code,gemini-cli "review this diff"\n');
+    return 1;
+  }
+  const task = taskParts.join(" ");
+  if (!task) {
+    deps.renderer.writeError("Usage: wstack acp parallel <agent-id-csv> <task>\n");
+    deps.renderer.writeError("Task description is required.\n");
+    return 1;
+  }
+  const ac = new AbortController();
+  const onSignal = () => ac.abort();
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  try {
+    const overrides = acpOverrides(deps);
+    const live = await loadLive(deps);
+    const result = await runEnsemble({
+      agentIds: csv,
+      task,
+      resolveCmd: (id) => resolveAcpAgentCommand(id, overrides, live?.byId),
+      signal: ac.signal,
+      onProgress: (agentId, event) => {
+        const line = formatProgress(event);
+        if (line) deps.renderer.writeInfo(`  [${agentId}] ${line}
+`);
+      }
+    });
+    const skipped = result.results.filter((r) => r.status === "skipped");
+    if (skipped.length > 0) {
+      deps.renderer.writeWarning(
+        `Skipping ${skipped.length} agent(s) not installed: ${skipped.map((s) => `${s.agentId} (${s.reason ?? "not installed"})`).join(", ")}
+`
+      );
+    }
+    if (result.summary.succeeded + result.summary.failed + result.summary.cancelled === 0) {
+      deps.renderer.writeError("No installed agents to run.\n");
+      deps.renderer.write("Run `wstack acp list` to see what is available.\n");
+      return 1;
+    }
+    const fannedOut = result.results.filter((r) => r.status !== "skipped").map((r) => r.agentId).join(", ");
+    deps.renderer.writeInfo(
+      `Fanning out to ${result.summary.succeeded + result.summary.failed + result.summary.cancelled} agent(s): ${fannedOut}
+`
+    );
+    deps.renderer.writeInfo(`Task: ${result.task}
+
+`);
+    for (const r of result.results) {
+      if (r.status === "skipped") continue;
+      deps.renderer.write(`
+=== ${r.agentId} ===
+`);
+      if (r.status === "success") {
+        deps.renderer.write(r.result && r.result.length > 0 ? r.result : "(no result)");
+        deps.renderer.write(
+          `
+[${r.agentId}] success  ${r.durationMs}ms  iterations=${r.iterations} toolCalls=${r.toolCalls}
+`
+        );
+      } else if (r.status === "failed") {
+        deps.renderer.writeError(
+          `[${r.error?.kind ?? "unknown"}] ${r.error?.message ?? "failed"}
+`
+        );
+        deps.renderer.write(
+          `[${r.agentId}] failed  ${r.durationMs}ms
+`
+        );
+      } else {
+        deps.renderer.writeError(
+          `[${r.error?.kind ?? "aborted"}] ${r.error?.message ?? "cancelled"}
+`
+        );
+        deps.renderer.write(
+          `[${r.agentId}] cancelled  ${r.durationMs}ms
+`
+        );
+      }
+    }
+    const { succeeded, failed, cancelled, skipped: skip } = result.summary;
+    deps.renderer.write(
+      `
+Parallel summary: ${succeeded} succeeded, ${failed} failed, ${cancelled} cancelled, ${skip} skipped.
+`
+    );
+    return succeeded > 0 ? 0 : 1;
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+  }
+}
+async function probeACPAgents(args, deps) {
+  const csv = args.join(" ");
+  let ids;
+  if (csv) {
+    ids = csv.split(",").flatMap((s) => s.split(/\s+/)).map((s) => s.trim()).filter(Boolean);
+  } else {
+    const detected = await new EnsembleRegistry().list();
+    ids = detected.filter((a) => a.installed).map((a) => a.id);
+  }
+  if (ids.length === 0) {
+    deps.renderer.writeError("No installed agents to probe.\n");
+    return 1;
+  }
+  const overrides = acpOverrides(deps);
+  const live = await loadLive(deps);
+  deps.renderer.writeInfo(
+    `Probing ${ids.length} agent(s)\u2026 (npx-based agents may download on first run)
+`
+  );
+  const results = await probeAcpAgents({
+    agentIds: ids,
+    resolveCmd: (id) => resolveAcpAgentCommand(id, overrides, live?.byId),
+    projectRoot: deps.cwd ?? process.cwd(),
+    onProgress: (id, r) => deps.renderer.writeInfo(`  ${r.ok ? "\u2713" : "\u2717"} ${id} (${r.ms}ms)
+`)
+  });
+  deps.renderer.write("\nACP handshake probe:\n\n");
+  for (const r of results) {
+    if (r.ok) {
+      const info = r.agentInfo ? ` \u2014 ${r.agentInfo.name} ${r.agentInfo.version}` : "";
+      deps.renderer.write(`  \u2713 ${r.id.padEnd(16)} ok  ${r.ms}ms${info}
+`);
+    } else {
+      deps.renderer.write(`  \u2717 ${r.id.padEnd(16)} ${r.error ?? "failed"}  (${r.ms}ms)
+`);
+    }
+  }
+  const ok = results.filter((r) => r.ok).length;
+  deps.renderer.write(`
+${ok} of ${results.length} agents completed the ACP handshake.
+`);
+  return ok > 0 ? 0 : 1;
+}
+async function benchACPAgents(args, deps) {
+  const checkFs = deps.flags?.fs === true || deps.flags?.fs === "true" || args.includes("--fs");
+  const csv = args.filter((a) => a !== "--fs").join(" ");
+  let ids;
+  if (csv) {
+    ids = csv.split(",").flatMap((s) => s.split(/\s+/)).map((s) => s.trim()).filter(Boolean);
+  } else {
+    const detected = await new EnsembleRegistry().list();
+    ids = detected.filter((a) => a.installed).map((a) => a.id);
+  }
+  if (ids.length === 0) {
+    deps.renderer.writeError("No installed agents to bench.\n");
+    deps.renderer.write("Pass ids explicitly: `wstack acp bench gemini-cli,codex-cli`.\n");
+    return 1;
+  }
+  const ac = new AbortController();
+  const onSignal = () => ac.abort();
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  try {
+    const overrides = acpOverrides(deps);
+    const live = await loadLive(deps);
+    deps.renderer.writeInfo(
+      `Benching ${ids.length} agent(s)${checkFs ? " (with fs check)" : ""}: ${ids.join(", ")}\u2026
+`
+    );
+    const result = await runAcpBench({
+      agentIds: ids,
+      resolveCmd: (id) => resolveAcpAgentCommand(id, overrides, live?.byId),
+      projectRoot: deps.cwd ?? process.cwd(),
+      checkFs,
+      signal: ac.signal,
+      onProgress: (agentId, phase, r) => {
+        if (phase === "start") deps.renderer.writeInfo(`  \u25B8 ${agentId}\u2026
+`);
+        else if (r) deps.renderer.writeInfo(`  \u21B3 ${agentId}: ${r.status}
+`);
+      }
+    });
+    deps.renderer.write(`
+${renderAcpBenchText(result)}
+`);
+    return result.summary.pass > 0 ? 0 : 1;
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+  }
+}
+export {
+  acpCmd
+};
+//# sourceMappingURL=acp-A5OSIU2P.js.map