@wrongstack/cli 1.0.33 → 1.0.36

package/dist/{acp-EDGUWU7N.js → acp-QLU7T5WX.js}

@@ -10,13 +10,11 @@ import {
 } from "./chunk-NRXWOMK7.js";
 import {
   startCliHqConnection
-} from "./chunk-4UWCMBPG.js";
+} from "./chunk-BJH44J7G.js";
 import "./chunk-SDJCLEK6.js";
 import "./chunk-F5DCFAKI.js";
 
-// src/subcommands/handlers/acp.ts
-import { randomBytes } from "node:crypto";
-import * as path2 from "node:path";
+// src/subcommands/handlers/acp-agents.ts
 import {
   defaultPermissionPolicy,
   EnsembleRegistry,
@@ -27,6 +25,304 @@ import {
   runEnsemble,
   runOneAcpTask
 } from "@wrongstack/acp";
+function acpOverrides(deps) {
+  return deps.config.acp?.agents;
+}
+async function loadLive(deps) {
+  return deps.paths ? loadCachedAcpRegistry(deps.paths) : null;
+}
+async function listACPAgents(deps) {
+  const detected = await new EnsembleRegistry().list();
+  const live = await loadLive(deps);
+  deps.renderer.write(`${formatAcpAgentList({ live, detected })}
+`);
+  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);
+  }
+}
+
+// src/subcommands/handlers/acp-server.ts
+import { randomBytes } from "node:crypto";
+import * as path2 from "node:path";
 import {
   ACPProtocolHandler,
   ACPSessionStore,
@@ -564,122 +860,34 @@ function createAcpConnectionGate(opts) {
   };
   const tokenOk = (supplied) => {
     if (!supplied) return false;
-    const a = Buffer.from(supplied);
-    if (a.length !== expected.length) return false;
-    return timingSafeEqual(a, expected);
-  };
-  return {
-    check(req, liveConnections) {
-      const origin = req.headers.origin;
-      if (origin && origin !== `http://${host}:${port}` && origin !== `ws://${host}:${port}`) {
-        return { ok: false, code: 1008, reason: "cross-origin forbidden" };
-      }
-      if (!isLoopbackHostHeader(req.headers.host ?? "")) {
-        return { ok: false, code: 1008, reason: "untrusted host header" };
-      }
-      if (!tokenOk(tokenFromRequest(req))) {
-        return { ok: false, code: 1008, reason: "unauthorized" };
-      }
-      if (liveConnections >= maxConnections) {
-        return { ok: false, code: 1013, reason: "too many connections" };
-      }
-      return OK;
-    }
-  };
-}
-
-// src/subcommands/handlers/acp.ts
-function pendingLeaderDeliveries(sessionId) {
-  return leaderDeliveryHub.pending(sessionId);
-}
-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];
-  const loginIndex = sub === "auth" ? 0 : (sub === "server" || sub === "serve") && args[1] === "auth" ? 1 : -1;
-  if (loginIndex >= 0) {
-    const { authCmd } = await import("./auth-SUHKFFO4.js");
-    return authCmd(args.slice(loginIndex + 1), deps);
-  }
-  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;
-};
+    const a = Buffer.from(supplied);
+    if (a.length !== expected.length) return false;
+    return timingSafeEqual(a, expected);
+  };
+  return {
+    check(req, liveConnections) {
+      const origin = req.headers.origin;
+      if (origin && origin !== `http://${host}:${port}` && origin !== `ws://${host}:${port}`) {
+        return { ok: false, code: 1008, reason: "cross-origin forbidden" };
+      }
+      if (!isLoopbackHostHeader(req.headers.host ?? "")) {
+        return { ok: false, code: 1008, reason: "untrusted host header" };
+      }
+      if (!tokenOk(tokenFromRequest(req))) {
+        return { ok: false, code: 1008, reason: "unauthorized" };
+      }
+      if (liveConnections >= maxConnections) {
+        return { ok: false, code: 1013, reason: "too many connections" };
+      }
+      return OK;
+    }
+  };
+}
+
+// src/subcommands/handlers/acp-server.ts
+function pendingLeaderDeliveries(sessionId) {
+  return leaderDeliveryHub.pending(sessionId);
+}
 function parseWsPort(flag) {
   if (flag === void 0 || flag === false) return null;
   if (flag === true || flag === "true") return 8889;
@@ -823,370 +1031,166 @@ async function runACPServer(deps) {
     deps.renderer.writeError(
       "No model provider configured. Run `wstack auth` before starting ACP, or use `--echo` for a connectivity test.\n"
     );
-    return 1;
-  }
-  let stdioHqTelemetry;
-  const server = new WrongStackACPServer(
-    echo ? {} : (() => {
-      let agentFor;
-      try {
-        agentFor = buildAcpServerAgentFactory(deps);
-      } catch (err) {
-        if (err instanceof AcpServerConfigError) {
-          deps.renderer.writeError(`${err.message}
-`);
-        }
-        throw err;
-      }
-      stdioHqTelemetry = startAcpHqTelemetry({
-        projectRoot: deps.cwd ?? process.cwd(),
-        projectName: path2.basename(deps.cwd ?? process.cwd()),
-        appConfig: deps.config
-      });
-      const stdioAgentFactory = agentFor;
-      const turn = makeACPServerAgentTurn({
-        agentFor: stdioHqTelemetry.wrapAgentFactory(agentFor),
-        pendingDeliveries: pendingLeaderDeliveries
-      });
-      const store = deps.paths?.projectDir ? new ACPSessionStore({ dir: path2.join(deps.paths.projectDir, "acp-sessions") }) : void 0;
-      return {
-        runTurn: turn,
-        replayFor: turn.replay,
-        seedFor: turn.seed,
-        disposeFor: composeDispose(
-          stdioHqTelemetry.wrapDispose(turn.dispose),
-          stdioAgentFactory
-        ),
-        ...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 {
-        await server.stop();
-      } catch (err) {
-        deps.renderer.writeError(
-          `ACP stop failed: ${err instanceof Error ? err.message : String(err)}
-`
-        );
-      }
-      stdioHqTelemetry?.stop();
-    }
-  }).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 detected = await new EnsembleRegistry().list();
-  const live = await loadLive(deps);
-  deps.renderer.write(`${formatAcpAgentList({ live, detected })}
-`);
-  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} ===
+    return 1;
+  }
+  let stdioHqTelemetry;
+  const server = new WrongStackACPServer(
+    echo ? {} : (() => {
+      let agentFor;
+      try {
+        agentFor = buildAcpServerAgentFactory(deps);
+      } catch (err) {
+        if (err instanceof AcpServerConfigError) {
+          deps.renderer.writeError(`${err.message}
 `);
-      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"}
+        }
+        throw err;
+      }
+      stdioHqTelemetry = startAcpHqTelemetry({
+        projectRoot: deps.cwd ?? process.cwd(),
+        projectName: path2.basename(deps.cwd ?? process.cwd()),
+        appConfig: deps.config
+      });
+      const stdioAgentFactory = agentFor;
+      const turn = makeACPServerAgentTurn({
+        agentFor: stdioHqTelemetry.wrapAgentFactory(agentFor),
+        pendingDeliveries: pendingLeaderDeliveries
+      });
+      const store = deps.paths?.projectDir ? new ACPSessionStore({ dir: path2.join(deps.paths.projectDir, "acp-sessions") }) : void 0;
+      return {
+        runTurn: turn,
+        replayFor: turn.replay,
+        seedFor: turn.seed,
+        disposeFor: composeDispose(
+          stdioHqTelemetry.wrapDispose(turn.dispose),
+          stdioAgentFactory
+        ),
+        ...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.write(`[${r.agentId}] failed  ${r.durationMs}ms
-`);
-      } else {
+    );
+    deps.renderer.writeInfo(
+      "Waiting for an ACP client connection on stdin/stdout. Press Ctrl+C to stop.\n"
+    );
+  }
+  createGracefulShutdown({
+    run: async () => {
+      try {
+        await server.stop();
+      } catch (err) {
         deps.renderer.writeError(
-          `[${r.error?.kind ?? "aborted"}] ${r.error?.message ?? "cancelled"}
+          `ACP stop failed: ${err instanceof Error ? err.message : String(err)}
 `
         );
-        deps.renderer.write(`[${r.agentId}] cancelled  ${r.durationMs}ms
-`);
       }
+      stdioHqTelemetry?.stop();
     }
-    const { succeeded, failed, cancelled, skipped: skip } = result.summary;
-    deps.renderer.write(
-      `
-Parallel summary: ${succeeded} succeeded, ${failed} failed, ${cancelled} cancelled, ${skip} skipped.
+  }).install();
+  try {
+    await server.start();
+  } catch (err) {
+    deps.renderer.writeError(
+      `ACP server error: ${err instanceof Error ? err.message : String(err)}
 `
     );
-    return succeeded > 0 ? 0 : 1;
-  } finally {
-    process.off("SIGINT", onSignal);
-    process.off("SIGTERM", onSignal);
+    return 1;
   }
+  return 0;
 }
-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);
+
+// src/subcommands/handlers/acp.ts
+var acpCmd = async (args, deps) => {
+  const sub = args[0];
+  const loginIndex = sub === "auth" ? 0 : (sub === "server" || sub === "serve") && args[1] === "auth" ? 1 : -1;
+  if (loginIndex >= 0) {
+    const { authCmd } = await import("./auth-AED7RW7D.js");
+    return authCmd(args.slice(loginIndex + 1), deps);
   }
-  if (ids.length === 0) {
-    deps.renderer.writeError("No installed agents to probe.\n");
-    return 1;
+  if (!sub || sub === "server" || sub === "serve") {
+    return runACPServer(deps);
   }
-  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)
+  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;
   }
-  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 (sub === "list") {
+    return listACPAgents(deps);
   }
-  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;
+  if (sub === "sync") {
+    return syncACPRegistry(deps);
   }
-  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);
+  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;
+};
 export {
   acpCmd
 };
-//# sourceMappingURL=acp-EDGUWU7N.js.map
+//# sourceMappingURL=acp-QLU7T5WX.js.map