@wrongstack/cli 0.6.7 → 0.7.2

package/dist/index.js

@@ -3,11 +3,11 @@ import * as path23 from 'path';
 import { join } from 'path';
 import * as fsp2 from 'fs/promises';
 import { readdir, readFile } from 'fs/promises';
-import { color, DefaultPathResolver, TOKENS, DefaultSystemPromptBuilder, makeAutonomyPromptContributor, ToolRegistry, createContextManagerTool, EventBus, SlashCommandRegistry, createDelegateTool, FLEET_ROSTER, createMcpControlTool, EternalAutonomyEngine, DefaultLogger, DefaultModelsRegistry, ProviderRegistry, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, loadTodosCheckpoint, attachTodosCheckpoint, loadDirectorState, loadPlan, createDefaultPipelines, AutoCompactionMiddleware, estimateRequestTokens, Agent, loadPlugins, FleetManager, makeDirectorSessionFactory, Director, makeAgentSubagentRunner, NULL_FLEET_BUS, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, atomicWrite, DefaultPluginAPI, AutoApprovePermissionPolicy, formatContextWindowModeList, repairToolUseAdjacency, getContextWindowMode, resolveContextWindowPolicy, formatTodosList, emptyPlan, clearPlan, savePlan, formatPlanTemplates, getPlanTemplate, addPlanItem, formatPlan, deriveTodosFromPlanItem, removePlanItem, setPlanItemStatus, SpecStore, TaskGraphStore, analyzeCriticalPath, getTemplate, listTemplates, templateToMarkdown, SpecParser, renderSpecAnalysis, AISpecBuilder, DefaultTaskStore, TaskTracker, renderProgress, renderTaskGraph, loadGoal, goalFilePath, summarizeUsage, saveGoal, emptyGoal, buildGoalPreamble, formatGoal, InputBuilder, projectHash, defaultOrchestrator, decryptConfigSecrets, encryptConfigSecrets as encryptConfigSecrets$1, SpecVersioning, ParallelEternalEngine, allServers as allServers$1 } from '@wrongstack/core';
+import { color, DefaultPathResolver, TOKENS, DefaultSystemPromptBuilder, makeAutonomyPromptContributor, ToolRegistry, createContextManagerTool, EventBus, SlashCommandRegistry, createDelegateTool, FLEET_ROSTER, createMcpControlTool, EternalAutonomyEngine, DefaultLogger, DefaultModelsRegistry, ProviderRegistry, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, loadTodosCheckpoint, attachTodosCheckpoint, loadDirectorState, loadPlan, createDefaultPipelines, AutoCompactionMiddleware, estimateRequestTokens, Agent, loadPlugins, FleetManager, makeDirectorSessionFactory, Director, AutoApprovePermissionPolicy, makeLLMClassifier, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, atomicWrite, DefaultPluginAPI, makeAgentSubagentRunner, NULL_FLEET_BUS, formatContextWindowModeList, repairToolUseAdjacency, getContextWindowMode, resolveContextWindowPolicy, AGENTS_BY_PHASE, dispatchAgent, formatTodosList, emptyPlan, clearPlan, savePlan, formatPlanTemplates, getPlanTemplate, addPlanItem, formatPlan, deriveTodosFromPlanItem, removePlanItem, setPlanItemStatus, SpecStore, TaskGraphStore, analyzeCriticalPath, getTemplate, listTemplates, templateToMarkdown, SpecParser, renderSpecAnalysis, AISpecBuilder, DefaultTaskStore, TaskTracker, renderProgress, renderTaskGraph, loadGoal, goalFilePath, summarizeUsage, saveGoal, emptyGoal, buildGoalPreamble, formatGoal, InputBuilder, FsError, ERROR_CODES, projectHash, WrongStackError, defaultOrchestrator, decryptConfigSecrets, encryptConfigSecrets as encryptConfigSecrets$1, SpecVersioning, ParallelEternalEngine, allServers as allServers$1 } from '@wrongstack/core';
 import { createRequire } from 'module';
 import * as os6 from 'os';
 import os6__default from 'os';
-import * as crypto from 'crypto';
+import * as crypto2 from 'crypto';
 import { randomUUID } from 'crypto';
 import { DefaultSecretVault as DefaultSecretVault$1, encryptConfigSecrets, decryptConfigSecrets as decryptConfigSecrets$1 } from '@wrongstack/core/security';
 import { WebSocketServer, WebSocket } from 'ws';
@@ -18,6 +18,9 @@ import { builtinToolsPack, rememberTool, forgetTool } from '@wrongstack/tools';
 import * as readline from 'readline';
 import { spawn } from 'child_process';
 import { SkillInstaller } from '@wrongstack/core/skills';
+import { WrongStackACPServer } from '@wrongstack/acp/agent';
+import { ACP_AGENT_COMMANDS, makeACPSubagentRunner, makeACPSubagentRunnerWithStop } from '@wrongstack/acp';
+import { ACP_AGENTS, SubagentBudget } from '@wrongstack/core/coordination';
 import { allServers } from '@wrongstack/core/infrastructure';
 import { createToolVisionAdapters } from '@wrongstack/runtime/vision';
 import { ToolExecutor } from '@wrongstack/core/execution';
@@ -1244,12 +1247,12 @@ ${lines.join("\n")}`
             if (analysis.bottlenecks.length > 0) {
               lines.push("");
               lines.push(`  \u{1F6AB} Bottlenecks (blocking most downstream):`);
-              analysis.bottlenecks.forEach((bt) => {
+              for (const bt of analysis.bottlenecks) {
                 const node = graph.nodes.get(bt.taskId);
                 if (node) {
                   lines.push(`    \u2022 ${node.title} (blocks ${bt.blockedCount} task(s))`);
                 }
-              });
+              }
             }
             if (analysis.parallelGroups.length > 0) {
               lines.push("");
@@ -1262,12 +1265,12 @@ ${lines.join("\n")}`
             if (analysis.readyTasks.length > 0) {
               lines.push("");
               lines.push(`  \u2705 Ready to start now:`);
-              analysis.readyTasks.forEach((taskId) => {
+              for (const taskId of analysis.readyTasks) {
                 const node = graph.nodes.get(taskId);
                 if (node) {
                   lines.push(`    \u2022 ${node.title}`);
                 }
-              });
+              }
             }
             lines.push(`\u2570${"\u2500".repeat(55)}\u256F`);
             return { message: lines.join("\n") };
@@ -1468,7 +1471,10 @@ var init_sdd = __esm({
         return Date.now() - this.phaseStartTime;
       }
       getVersioning() {
-        return this.versioning ?? (this.versioning = new SpecVersioning());
+        if (this.versioning === null) {
+          this.versioning = new SpecVersioning();
+        }
+        return this.versioning;
       }
       clearTaskState() {
         this.taskStore = null;
@@ -1554,7 +1560,7 @@ function currentVersion() {
   return "dev";
 }
 function isNewer(a, b) {
-  const parse = (v) => v.replace(/^v/i, "").split(".").map((p) => parseInt(p, 10) || 0);
+  const parse = (v) => v.replace(/^v/i, "").split(".").map((p) => Number.parseInt(p, 10) || 0);
   const [ap, bp] = [parse(a), parse(b)];
   for (let i = 0; i < Math.max(ap.length, bp.length); i++) {
     const ai = ap[i] ?? 0;
@@ -1663,7 +1669,7 @@ async function runWebUI(opts) {
   const port = opts.port ?? 3457;
   const clients = /* @__PURE__ */ new Map();
   let abortController = null;
-  const authToken = crypto.randomBytes(16).toString("hex");
+  const authToken = crypto2.randomBytes(16).toString("hex");
   const wss = new WebSocketServer({ port, host: "127.0.0.1", maxPayload: 1 * 1024 * 1024 });
   console.log(`[WebUI] WebSocket server starting on ws://127.0.0.1:${port}`);
   const eventUnsubscribers = [];
@@ -2244,6 +2250,35 @@ ${diff}`;
   }
   return "chore: update";
 }
+function makeProviderClassifier(provider, model) {
+  return makeLLMClassifier(async (prompt) => {
+    const ctrl = new AbortController();
+    const timeout = setTimeout(() => ctrl.abort(), 15e3);
+    try {
+      const resp = await provider.complete(
+        {
+          model,
+          system: [
+            {
+              type: "text",
+              text: 'You are an agent router. Choose the single best agent for the task. Reply with ONLY a compact JSON object {"role":"...","reason":"..."}.'
+            }
+          ],
+          messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
+          maxTokens: 120,
+          temperature: 0
+        },
+        { signal: ctrl.signal }
+      );
+      const content = resp.content;
+      return Array.isArray(content) ? content[0]?.text ?? "" : "";
+    } catch {
+      return "";
+    } finally {
+      clearTimeout(timeout);
+    }
+  });
+}
 
 // src/arg-parser.ts
 var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
@@ -2753,7 +2788,16 @@ function entryId(ts) {
   return ts.replace(/[:.]/g, "-").slice(0, 19);
 }
 async function ensureHistoryDir(homeFn = defaultHomeDir) {
-  await fsp2.mkdir(historyDir(homeFn), { recursive: true });
+  try {
+    await fsp2.mkdir(historyDir(homeFn), { recursive: true });
+  } catch (err) {
+    throw new FsError({
+      message: err instanceof Error ? err.message : String(err),
+      code: ERROR_CODES.FS_MKDIR_FAILED,
+      path: historyDir(homeFn),
+      cause: err
+    });
+  }
 }
 async function readIndex(homeFn = defaultHomeDir) {
   try {
@@ -2765,7 +2809,16 @@ async function readIndex(homeFn = defaultHomeDir) {
 }
 async function writeIndex(idx, homeFn = defaultHomeDir) {
   await ensureHistoryDir(homeFn);
-  await atomicWrite(historyIndexPath(homeFn), JSON.stringify(idx, null, 2));
+  try {
+    await atomicWrite(historyIndexPath(homeFn), JSON.stringify(idx, null, 2));
+  } catch (err) {
+    throw new FsError({
+      message: err instanceof Error ? err.message : String(err),
+      code: ERROR_CODES.FS_ATOMIC_WRITE_FAILED,
+      path: historyIndexPath(homeFn),
+      cause: err
+    });
+  }
 }
 async function backupCurrent(homeFn = defaultHomeDir) {
   const cfg = configPath(homeFn);
@@ -2810,11 +2863,20 @@ async function appendHistory(oldCfg, newCfg, description, homeFn = defaultHomeDi
     snapshotMasked: maskConfigSecrets(newCfg),
     diffSummary: diffSummary(oldCfg, newCfg)
   };
-  await fsp2.writeFile(
-    path23.join(historyDir(homeFn), `${id}.json`),
-    JSON.stringify(entry, null, 2),
-    "utf8"
-  );
+  try {
+    await fsp2.writeFile(
+      path23.join(historyDir(homeFn), `${id}.json`),
+      JSON.stringify(entry, null, 2),
+      "utf8"
+    );
+  } catch (err) {
+    throw new FsError({
+      message: err instanceof Error ? err.message : String(err),
+      code: ERROR_CODES.FS_WRITE_FAILED,
+      path: path23.join(historyDir(homeFn), `${id}.json`),
+      cause: err
+    });
+  }
   const idx = await readIndex(homeFn);
   idx.entries.unshift({ id, timestamp, description });
   await writeIndex(idx, homeFn);
@@ -3476,17 +3538,41 @@ function buildClearCommand(opts) {
   };
 }
 async function runGit(args, cwd) {
-  return new Promise((resolve4) => {
-    const child = spawn("git", args, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
+  try {
+    return await new Promise((resolve4, reject) => {
+      const child = spawn("git", args, {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (d) => {
+        stdout += d;
+      });
+      child.stderr?.on("data", (d) => {
+        stderr += d;
+      });
+      child.on("error", (err) => {
+        reject(new WrongStackError({
+          message: `Failed to run git: ${err.message}`,
+          code: ERROR_CODES.TOOL_EXECUTION_FAILED,
+          subsystem: "tool",
+          context: { command: "git", args, cwd },
+          cause: err
+        }));
+      });
+      child.on("close", (code) => resolve4({ stdout, stderr, code: code ?? 0 }));
     });
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.on("data", (d) => stdout += d);
-    child.stderr?.on("data", (d) => stderr += d);
-    child.on("close", (code) => resolve4({ stdout, stderr, code: code ?? 0 }));
-  });
+  } catch (err) {
+    if (err instanceof WrongStackError) throw err;
+    throw new WrongStackError({
+      message: err instanceof Error ? err.message : String(err),
+      code: ERROR_CODES.TOOL_EXECUTION_FAILED,
+      subsystem: "tool",
+      context: { command: "git", args, cwd },
+      cause: err
+    });
+  }
 }
 function detectCommitType(stats) {
   const lines = stats.split("\n");
@@ -3799,6 +3885,17 @@ function buildStatsCommand(opts) {
     }
   };
 }
+var PHASE_ORDER = [
+  { phase: "discovery", label: "1 \xB7 Discovery" },
+  { phase: "planning", label: "2 \xB7 Planning" },
+  { phase: "build", label: "3 \xB7 Build" },
+  { phase: "verify", label: "4 \xB7 Verify" },
+  { phase: "review", label: "5 \xB7 Review" },
+  { phase: "domain", label: "6 \xB7 Domain" },
+  { phase: "knowledge", label: "7 \xB7 Knowledge" },
+  { phase: "delivery", label: "8 \xB7 Delivery & Ops" },
+  { phase: "meta", label: "9 \xB7 Meta" }
+];
 function buildFleetCommand(opts) {
   return {
     name: "fleet",
@@ -3807,12 +3904,15 @@ function buildFleetCommand(opts) {
       "Usage:",
       "  /fleet              Show fleet status (default)",
       "  /fleet status       Same as /fleet (verbose status)",
+      "  /fleet list         List the agent roster grouped by phase",
+      "  /fleet dispatch <task>  Route a task to the best agent and spawn it",
       "  /fleet spawn <role> [count]  Spawn N subagents of a role (default 1)",
       "  /fleet terminate <subagentId>  Stop a specific subagent by id",
       "  /fleet kill         Stop all running subagents",
       "  /fleet usage        Token and cost breakdown across the fleet",
       "  /fleet journal      Show recent journal entries from /goal journal",
       "",
+      "In the TUI, press Ctrl+F to open the graphical fleet monitor.",
       "Works during /autonomy parallel mode and standalone director sessions."
     ].join("\n"),
     async run(args) {
@@ -3846,8 +3946,9 @@ function buildFleetCommand(opts) {
               const id = sa.id?.padEnd(36) ?? "".padEnd(36);
               const name = (sa.name ?? "worker").padEnd(16);
               const statusColor = sa.status === "running" ? color.green(sa.status.padEnd(10)) : sa.status === "idle" ? color.dim(sa.status.padEnd(10)) : color.dim(sa.status.padEnd(10));
+              const ext = sa.extensions && sa.extensions > 0 ? `${color.yellow(`\u26A1\xD7${sa.extensions}`)} ` : "";
               const task = sa.currentTask ?? color.dim("\u2014");
-              lines.push(`  ${id} ${name} ${statusColor} ${task}`);
+              lines.push(`  ${id} ${name} ${statusColor} ${ext}${task}`);
             }
           }
           const msg3 = lines.join("\n");
@@ -3953,29 +4054,28 @@ function buildFleetCommand(opts) {
       if (cmd === "terminate" || cmd === "stop") {
         const targetId = subargs[0];
         if (!targetId) {
-          const msg2 = `${color.amber("\u26A0 /fleet terminate requires a subagentId.")} Use /fleet to see active ids.`;
-          opts.renderer.writeWarning(msg2);
-          return { message: msg2 };
+          const msg3 = `${color.amber("\u26A0 /fleet terminate requires a subagentId.")} Use /fleet to see active ids.`;
+          opts.renderer.writeWarning(msg3);
+          return { message: msg3 };
         }
         if (!opts.onFleetTerminate) {
-          const msg2 = `${color.amber("\u26A0 /fleet terminate is not wired in this session.")}`;
-          opts.renderer.writeWarning(msg2);
-          return { message: msg2 };
+          const msg3 = `${color.amber("\u26A0 /fleet terminate is not wired in this session.")}`;
+          opts.renderer.writeWarning(msg3);
+          return { message: msg3 };
         }
         const ok = opts.onFleetTerminate(targetId);
         if (ok) {
-          const msg2 = `${color.green("\u2713 Terminated")} subagent ${color.bold(targetId)}.`;
-          opts.renderer.write(msg2);
-          return { message: msg2 };
-        } else {
-          const msg2 = `${color.red("\u2717 Failed")} to terminate ${color.bold(targetId)}. Subagent may already be stopped.`;
-          opts.renderer.writeWarning(msg2);
-          return { message: msg2 };
+          const msg3 = `${color.green("\u2713 Terminated")} subagent ${color.bold(targetId)}.`;
+          opts.renderer.write(msg3);
+          return { message: msg3 };
         }
+        const msg2 = `${color.red("\u2717 Failed")} to terminate ${color.bold(targetId)}. Subagent may already be stopped.`;
+        opts.renderer.writeWarning(msg2);
+        return { message: msg2 };
       }
       if (cmd === "spawn" || cmd === "add") {
         const role = subargs[0] ?? "worker";
-        const count = Math.min(16, Math.max(1, parseInt(subargs[1] ?? "1", 10) || 1));
+        const count = Math.min(16, Math.max(1, Number.parseInt(subargs[1] ?? "1", 10) || 1));
         if (!opts.onFleetSpawn) {
           const msg3 = `${color.amber("\u26A0 /fleet spawn is not wired in this session.")}`;
           opts.renderer.writeWarning(msg3);
@@ -4001,11 +4101,64 @@ function buildFleetCommand(opts) {
         }
         return { message: msg2 };
       }
+      if (cmd === "list" || cmd === "roster" || cmd === "agents") {
+        const lines = [`${color.bold("Agent Roster")} ${color.dim("(spawn with /fleet spawn <role>)")}`];
+        for (const { phase, label } of PHASE_ORDER) {
+          const defs = AGENTS_BY_PHASE[phase];
+          if (!defs || defs.length === 0) continue;
+          lines.push("");
+          lines.push(color.cyan(`  Phase ${label}`));
+          for (const def of defs) {
+            const role = (def.config.role ?? "").padEnd(18);
+            lines.push(`    ${color.bold(role)} ${color.dim(def.capability.summary)}`);
+          }
+        }
+        const msg2 = lines.join("\n");
+        opts.renderer.write(msg2);
+        return { message: msg2 };
+      }
+      if (cmd === "dispatch" || cmd === "route") {
+        const task = subargs.join(" ").trim();
+        if (!task) {
+          const msg3 = `Usage: /fleet dispatch <task description> \u2014 routes the task to the best agent.`;
+          opts.renderer.writeWarning(msg3);
+          return { message: msg3 };
+        }
+        const decision = await dispatchAgent(task, { classifier: opts.onDispatchClassify });
+        const pct2 = Math.round(decision.confidence * 100);
+        const lines = [];
+        lines.push(
+          `${color.bold("\u2192 " + decision.role)} ${color.dim(`(${decision.method}, ${pct2}% confidence)`)}`
+        );
+        lines.push(`  ${color.dim(decision.definition.capability.summary)}`);
+        lines.push(`  ${color.dim("why:")} ${decision.reason}`);
+        if (decision.alternatives.length > 0) {
+          const alts = decision.alternatives.slice(0, 3).map((a) => a.role).join(", ");
+          lines.push(`  ${color.dim("alternatives:")} ${alts}`);
+        }
+        if (opts.onFleetSpawn) {
+          try {
+            const id = await opts.onFleetSpawn(decision.role);
+            lines.push(`  ${color.green("\u2713 spawned")} ${color.bold(decision.role)} as ${color.dim(id)}`);
+          } catch (err) {
+            lines.push(
+              `  ${color.amber("\u26A0 spawn failed:")} ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        } else {
+          lines.push(`  ${color.dim("(no fleet active \u2014 run /autonomy parallel or --director to spawn)")}`);
+        }
+        const msg2 = lines.join("\n");
+        opts.renderer.write(msg2);
+        return { message: msg2 };
+      }
       if (cmd === "help" || cmd === "?") {
         const msg2 = [
           `${color.bold("Fleet Commands")}`,
           `  ${color.dim("/fleet")}              Show fleet status (default)`,
           `  ${color.dim("/fleet status")}       Same as /fleet (verbose status)`,
+          `  ${color.dim("/fleet list")}         List the agent roster grouped by phase`,
+          `  ${color.dim("/fleet dispatch <task>")}  Route a task to the best agent and spawn it`,
           `  ${color.dim("/fleet spawn <role> [count]")}  Spawn N subagents of a role (default 1)`,
           `  ${color.dim("/fleet terminate <subagentId>")}  Stop a specific subagent by id`,
           `  ${color.dim("/fleet kill")}         Stop all running subagents`,
@@ -4015,7 +4168,7 @@ function buildFleetCommand(opts) {
         opts.renderer.write(msg2);
         return { message: msg2 };
       }
-      const valid = ["status", "usage", "spawn", "terminate", "kill", "retry", "journal"];
+      const valid = ["status", "list", "dispatch", "usage", "spawn", "terminate", "kill", "retry", "journal"];
       const msg = `Unknown subcommand "${cmd}". Valid subcommands: ${valid.join(", ")}. Run /fleet with no args to see status, or /fleet help for usage.`;
       opts.renderer.writeWarning(msg);
       return { message: msg };
@@ -5424,8 +5577,8 @@ ${list}
 
 Use \`/security report <number>\` to view a specific report.` };
     }
-    const index = parseInt(reportId, 10) - 1;
-    if (!isNaN(index) && reports[index]) {
+    const index = Number.parseInt(reportId, 10) - 1;
+    if (!Number.isNaN(index) && reports[index]) {
       const content = await readFile(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
@@ -5505,8 +5658,17 @@ async function loadStatuslineConfig() {
 }
 async function saveStatuslineConfig(cfg) {
   const p = resolveConfigPath();
-  await fsp2.mkdir(path23.dirname(p), { recursive: true });
-  await atomicWrite(p, JSON.stringify(cfg, null, 2));
+  try {
+    await fsp2.mkdir(path23.dirname(p), { recursive: true });
+    await atomicWrite(p, JSON.stringify(cfg, null, 2));
+  } catch (err) {
+    throw new FsError({
+      message: err instanceof Error ? err.message : String(err),
+      code: err instanceof Error && err.message.includes("mkdir") ? ERROR_CODES.FS_MKDIR_FAILED : ERROR_CODES.FS_ATOMIC_WRITE_FAILED,
+      path: p,
+      cause: err
+    });
+  }
 }
 function buildStatuslineCommand(deps) {
   return {
@@ -6708,6 +6870,7 @@ async function runProjectCheck(opts) {
         const { spawn: spawn3 } = await import('child_process');
         await new Promise((resolve4, reject) => {
           const child = spawn3("git", ["init"], { cwd: projectRoot });
+          child.on("error", reject);
           child.on("close", (code) => code === 0 ? resolve4() : reject(new Error(`git init failed with ${code}`)));
         });
         renderer.write(`  ${color.green("\u2713")} Git repository initialized
@@ -7090,6 +7253,162 @@ function summarize(value, name) {
   }
   return "";
 }
+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 spawn <id> <task>
+                        Spawn an ACP agent as a subagent and wait for result
+  wstack acp help         Show this help
+
+ACP Mode:
+  When run as \`wstack acp\`. WrongStack acts as an ACP-compatible agent.
+  ACP clients (Zed, JetBrains, VS Code) spawn it as a subprocess and
+  communicate over stdio JSON-RPC.
+  Press Ctrl+C to stop.
+
+spawn:
+  Spawns a named ACP agent (cline, gemini-cli, copilot, openhands, goose)
+  with the given task and waits for its result.
+  Example: wstack acp spawn cline "fix the login bug"
+`);
+    return 0;
+  }
+  if (sub === "list") {
+    return listACPAgents(deps);
+  }
+  if (sub === "spawn") {
+    return spawnACPAgent(args.slice(1), deps);
+  }
+  deps.renderer.writeError(`Unknown acp subcommand: ${sub}
+`);
+  deps.renderer.write("Run `wstack acp help` for usage.\n");
+  return 1;
+};
+async function runACPServer(deps) {
+  const toolRegistry = deps.toolRegistry;
+  const tools = toolRegistry?.list() ?? [];
+  deps.renderer.writeInfo("Starting WrongStack ACP server...\n");
+  deps.renderer.writeInfo(`Exposing ${tools.length} tool(s) via ACP protocol.
+`);
+  deps.renderer.writeInfo("Waiting for ACP client connection on stdin/stdout...\n");
+  deps.renderer.writeInfo("Press Ctrl+C to stop.\n");
+  const server = new WrongStackACPServer({ tools });
+  const shutdown = () => {
+    deps.renderer.writeWarning("\nShutting down ACP server...");
+    server.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  try {
+    await server.start();
+  } catch (err) {
+    deps.renderer.writeError(`ACP server error: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+  return 0;
+}
+function listACPAgents(deps) {
+  deps.renderer.write("Available ACP agents:\n\n");
+  for (const a of ACP_AGENTS) {
+    const id = a.id ?? a.role;
+    const name = a.name ?? a.role ?? "";
+    const desc = a.prompt?.slice(0, 50) ?? "";
+    deps.renderer.write(`  ${id.padEnd(16)} ${name.padEnd(20)} ${desc}\u2026
+`);
+  }
+  deps.renderer.write("\nUse `wstack acp spawn <agent> <task>` to delegate a task.\n");
+  return 0;
+}
+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 cmd = ACP_AGENT_COMMANDS[subagentId];
+  if (!cmd) {
+    deps.renderer.writeError(`Unknown ACP agent: ${subagentId}
+`);
+    deps.renderer.write("Run `wstack acp list` to see available agents.\n");
+    return 1;
+  }
+  deps.renderer.writeInfo(`Spawning ACP agent '${subagentId}'\u2026
+`);
+  const cleanup = () => {
+    if (stop) {
+      try {
+        stop();
+      } catch {
+      }
+    }
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  let stop = null;
+  try {
+    const { runner, stop: runStop } = await makeACPSubagentRunnerWithStop(cmd);
+    stop = runStop;
+    const taskId = `acp-${crypto.randomUUID()}`;
+    const budget = new SubagentBudget({
+      timeoutMs: 5 * 60 * 1e3,
+      maxIterations: 2e3,
+      maxToolCalls: 5e3
+    });
+    const ctx = {
+      subagentId,
+      config: {
+        id: subagentId,
+        name: cmd.role ?? subagentId,
+        role: subagentId,
+        provider: "acp",
+        prompt: ""
+      },
+      budget,
+      signal: new AbortController().signal,
+      bridge: null
+    };
+    budget.start();
+    deps.renderer.writeInfo("Running task\u2026\n");
+    const result = await runner(
+      { id: taskId, description: task },
+      ctx
+    );
+    deps.renderer.write("\n--- Result ---\n");
+    deps.renderer.write(String(result.result ?? "no result"));
+    deps.renderer.write("\n---------------\n");
+    deps.renderer.writeInfo(
+      `Done. iterations=${result.iterations} toolCalls=${result.toolCalls}
+`
+    );
+    return 0;
+  } catch (err) {
+    deps.renderer.writeError(`ACP agent error: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  } finally {
+    cleanup();
+    process.off("SIGINT", cleanup);
+    process.off("SIGTERM", cleanup);
+  }
+}
 
 // src/auth-menu.ts
 init_provider_config_utils();
@@ -7786,7 +8105,7 @@ var updateCmd = async (args, deps) => {
   deps.renderer.write(`Updating wrongstack from v${info.current} to v${info.latest}...
 `);
   try {
-    const result = await new Promise((resolve4) => {
+    const result = await new Promise((resolve4, reject) => {
       const child = spawn("npm", ["install", "-g", "wrongstack@latest"], {
         cwd,
         stdio: "pipe"
@@ -7795,6 +8114,7 @@ var updateCmd = async (args, deps) => {
       child.stderr?.on("data", (d) => {
         stderr += d;
       });
+      child.on("error", reject);
       child.on("close", (code) => resolve4({ code: code ?? 0 }));
     });
     if (result.code === 0) {
@@ -8957,8 +9277,8 @@ var rewindCmd = async (args, deps) => {
       deps.renderer.write("Rewinding to session start...\n");
       result = await rewind.rewindToStart(sessionId);
     } else if (flags.last) {
-      const n = parseInt(flags.last, 10);
-      if (isNaN(n) || n < 1) {
+      const n = Number.parseInt(flags.last, 10);
+      if (Number.isNaN(n) || n < 1) {
         deps.renderer.writeError("--last requires a positive number");
         return 1;
       }
@@ -8966,8 +9286,8 @@ var rewindCmd = async (args, deps) => {
 `);
       result = await rewind.rewindLastN(sessionId, n);
     } else if (flags.to) {
-      const idx = parseInt(flags.to, 10);
-      if (isNaN(idx) || idx < 0) {
+      const idx = Number.parseInt(flags.to, 10);
+      if (Number.isNaN(idx) || idx < 0) {
         deps.renderer.writeError("--to requires a non-negative number");
         return 1;
       }
@@ -9088,6 +9408,7 @@ var helpCmd = async (_args, deps) => {
 
 // src/subcommands/index.ts
 var subcommands = {
+  acp: acpCmd,
   init: initCmd,
   auth: authCmd,
   update: updateCmd,
@@ -9130,22 +9451,22 @@ function fmtDuration(ms) {
   const remMin = m - h * 60;
   return `${h}h${remMin}m`;
 }
-function fmtTaskResultLine(r, color38) {
+function fmtTaskResultLine(r, color39) {
   const stats = `${r.iterations}it ${r.toolCalls}tc ${fmtDuration(r.durationMs)}`;
   const errMsg = typeof r.error === "string" ? r.error : r.error?.message;
   const errKind = typeof r.error === "object" ? r.error?.kind : void 0;
   const errTail = errMsg ? ` \u2014 ${errMsg.replace(/\s+/g, " ").slice(0, 80)}${errMsg.length > 80 ? "\u2026" : ""}` : "";
-  const errKindChip = errKind ? color38.dim(` [${errKind}]`) : "";
-  const errSnip = errMsg || errKind ? `${errKindChip}${color38.dim(errTail)}` : "";
+  const errKindChip = errKind ? color39.dim(` [${errKind}]`) : "";
+  const errSnip = errMsg || errKind ? `${errKindChip}${color39.dim(errTail)}` : "";
   switch (r.status) {
     case "success":
-      return { mark: color38.green("\u2713"), stats, tail: "" };
+      return { mark: color39.green("\u2713"), stats, tail: "" };
     case "timeout":
-      return { mark: color38.yellow("\u23F1"), stats: `${color38.yellow("timeout")} ${stats}`, tail: errSnip };
+      return { mark: color39.yellow("\u23F1"), stats: `${color39.yellow("timeout")} ${stats}`, tail: errSnip };
     case "stopped":
-      return { mark: color38.dim("\u2298"), stats: `${color38.dim("stopped")} ${stats}`, tail: errSnip };
+      return { mark: color39.dim("\u2298"), stats: `${color39.dim("stopped")} ${stats}`, tail: errSnip };
     case "failed":
-      return { mark: color38.red("\u2717"), stats: `${color38.red("failed")} ${stats}`, tail: errSnip };
+      return { mark: color39.red("\u2717"), stats: `${color39.red("failed")} ${stats}`, tail: errSnip };
   }
 }
 
@@ -9304,6 +9625,214 @@ async function boot(argv) {
     updateInfo
   };
 }
+function fmtElapsed(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const rem = s % 60;
+  if (m < 60) return `${m}m${rem.toString().padStart(2, "0")}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h${(m % 60).toString().padStart(2, "0")}m`;
+}
+function renderFleetLine(states, now, columns, version) {
+  const all = [...states.values()];
+  if (all.length === 0) return "";
+  const running = all.filter((a) => a.status === "running");
+  const done = all.filter((a) => a.status === "done").length;
+  const failed = all.filter((a) => a.status === "failed").length;
+  const versionChip = version ? `${color.bold("WS")}${color.dim(` v${version}`)} ${color.dim("\u2502")} ` : "";
+  const counts = versionChip + `${color.cyan("\u27F3 fleet")} ${color.yellow(`\u25B6${running.length}`)} ${color.green(`\u2713${done}`)}` + (failed > 0 ? ` ${color.red(`\u2717${failed}`)}` : "");
+  const shown = running.sort((a, b) => a.startedAt - b.startedAt).slice(0, 4).map((a) => {
+    const elapsed = fmtElapsed(Math.max(0, now - a.startedAt));
+    const tool = a.lastTool ? ` ${color.dim(a.lastTool)}` : "";
+    const ext = a.extensions && a.extensions > 0 ? ` ${color.yellow(`\u26A1${a.extensions}`)}` : "";
+    return `${color.bold(a.name)} ${color.yellow("\u25B6")} ${color.dim(elapsed)} ${color.dim(`L${a.iterations}`)} ${color.dim(`${a.toolCalls}t`)}${tool}${ext}`;
+  });
+  let line = shown.length > 0 ? `${counts} ${color.dim("\u2502")} ${shown.join(color.dim("  \xB7  "))}` : counts;
+  const max = Math.max(20, columns - 1);
+  const visible = line.replace(/\x1b\[[0-9;]*m/g, "");
+  if (visible.length > max) {
+    let count = 0;
+    let out = "";
+    let i = 0;
+    while (i < line.length && count < max - 1) {
+      if (line[i] === "\x1B") {
+        const end = line.indexOf("m", i);
+        if (end !== -1) {
+          out += line.slice(i, end + 1);
+          i = end + 1;
+          continue;
+        }
+      }
+      out += line[i];
+      count++;
+      i++;
+    }
+    line = out + "\u2026";
+  }
+  return line;
+}
+var FleetStatusLine = class {
+  events;
+  out;
+  throttleMs;
+  now;
+  version;
+  states = /* @__PURE__ */ new Map();
+  unsubs = [];
+  active = false;
+  rows = 0;
+  repaintTimer = null;
+  tickTimer = null;
+  lastPaint = 0;
+  onResize = () => {
+    if (this.active) {
+      this.rows = this.out.rows ?? 24;
+      this.out.write(`\x1B[1;${this.rows - 1}r`);
+      this.paint(true);
+    }
+  };
+  constructor(opts) {
+    this.events = opts.events;
+    this.out = opts.out ?? process.stdout;
+    this.throttleMs = opts.throttleMs ?? 150;
+    this.now = opts.now ?? Date.now;
+    this.version = opts.version;
+  }
+  /** Subscribe to host fleet events. No terminal output until a subagent spawns. */
+  start() {
+    const ensure = (id, name) => {
+      let s = this.states.get(id);
+      if (!s) {
+        s = {
+          id,
+          name: name ?? id,
+          status: "running",
+          iterations: 0,
+          toolCalls: 0,
+          startedAt: this.now()
+        };
+        this.states.set(id, s);
+      } else if (name && s.name === s.id) {
+        s.name = name;
+      }
+      return s;
+    };
+    this.unsubs.push(
+      this.events.on("subagent.spawned", (e) => {
+        ensure(e.subagentId, e.name);
+        this.activate();
+        this.schedulePaint();
+      }),
+      this.events.on("subagent.task_started", (e) => {
+        const s = ensure(e.subagentId);
+        s.status = "running";
+        this.activate();
+        this.schedulePaint();
+      }),
+      this.events.on("subagent.tool_executed", (e) => {
+        const s = ensure(e.subagentId);
+        s.toolCalls++;
+        s.lastTool = e.name;
+        this.activate();
+        this.schedulePaint();
+      }),
+      this.events.on("subagent.iteration_summary", (e) => {
+        const s = ensure(e.subagentId);
+        s.iterations = e.iteration;
+        if (typeof e.toolCalls === "number") s.toolCalls = e.toolCalls;
+        if (e.currentTool) s.lastTool = e.currentTool;
+        this.schedulePaint();
+      }),
+      this.events.on("subagent.budget_extended", (e) => {
+        const s = ensure(e.subagentId);
+        s.extensions = e.totalExtensions;
+        this.activate();
+        this.schedulePaint();
+      }),
+      this.events.on("subagent.task_completed", (e) => {
+        const s = ensure(e.subagentId);
+        s.status = e.status === "success" ? "done" : "failed";
+        s.iterations = e.iterations;
+        s.toolCalls = e.toolCalls;
+        s.endedAt = this.now();
+        this.schedulePaint();
+        if (![...this.states.values()].some((a) => a.status === "running")) {
+          setTimeout(() => {
+            if (![...this.states.values()].some((a) => a.status === "running")) {
+              this.deactivate();
+            }
+          }, 800);
+        }
+      })
+    );
+  }
+  /** Unsubscribe and restore the terminal. Idempotent. */
+  stop() {
+    for (const u of this.unsubs.splice(0)) u();
+    this.deactivate();
+  }
+  isTty() {
+    return !!this.out.isTTY;
+  }
+  activate() {
+    if (this.active || !this.isTty()) return;
+    this.active = true;
+    this.rows = this.out.rows ?? 24;
+    this.out.write("\n");
+    this.out.write(`\x1B[1;${this.rows - 1}r`);
+    this.out.write(`\x1B[${this.rows - 1};1H`);
+    this.out.on("resize", this.onResize);
+    this.tickTimer = setInterval(() => this.paint(true), 1e3);
+    if (this.tickTimer.unref) this.tickTimer.unref();
+    this.paint(true);
+  }
+  deactivate() {
+    if (!this.active) return;
+    this.active = false;
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    if (this.repaintTimer) {
+      clearTimeout(this.repaintTimer);
+      this.repaintTimer = null;
+    }
+    this.out.off("resize", this.onResize);
+    if (this.isTty()) {
+      this.out.write("\x1B7");
+      this.out.write(`\x1B[${this.rows};1H`);
+      this.out.write("\x1B[2K");
+      this.out.write("\x1B8");
+      this.out.write("\x1B[r");
+    }
+  }
+  schedulePaint() {
+    if (!this.active) return;
+    const since = this.now() - this.lastPaint;
+    if (since >= this.throttleMs) {
+      this.paint(false);
+      return;
+    }
+    if (this.repaintTimer) return;
+    this.repaintTimer = setTimeout(() => {
+      this.repaintTimer = null;
+      this.paint(false);
+    }, this.throttleMs - since);
+    if (this.repaintTimer.unref) this.repaintTimer.unref();
+  }
+  paint(force) {
+    if (!this.active || !this.isTty()) return;
+    if (!force) this.lastPaint = this.now();
+    else this.lastPaint = this.now();
+    const line = renderFleetLine(this.states, this.now(), this.out.columns ?? 80, this.version);
+    this.out.write("\x1B7");
+    this.out.write(`\x1B[${this.rows};1H`);
+    this.out.write("\x1B[2K");
+    this.out.write(line);
+    this.out.write("\x1B8");
+  }
+};
 
 // src/repl.ts
 init_sdd();
@@ -9382,9 +9911,15 @@ async function runRepl(opts) {
         } else {
           const beforeGoal = await loadGoalSafe(opts);
           const beforeIter = beforeGoal?.iterations ?? 0;
+          const coord = engine.getCoordinator();
+          if (coord) {
+            const stats = coord.getStats();
+            opts.renderer.write(
+              color.dim(`  \u250C\u2500 Fleet: ${stats.running} running, ${stats.idle} idle, ${stats.pending} pending, ${stats.completed} done`) + "\n"
+            );
+          }
           opts.renderer.write(
-            color.magenta(`
-  \u21B3 [parallel #${beforeIter + 1}] launching fan-out\u2026
+            color.magenta(`  \u21B3 [parallel #${beforeIter + 1}] launching fan-out\u2026
 `)
           );
           interrupts = 0;
@@ -9392,6 +9927,13 @@ async function runRepl(opts) {
             const ok = await engine.runOneIteration();
             const afterGoal = await loadGoalSafe(opts);
             const last = afterGoal?.journal[afterGoal.journal.length - 1];
+            if (coord) {
+              const stats = coord.getStats();
+              opts.renderer.write(
+                color.dim(`  \u2514\u2500 Fleet: ${stats.running} running, ${stats.idle} idle, ${stats.completed} done
+`)
+              );
+            }
             if (last) {
               const mark = last.status === "success" ? color.green("\u2713") : last.status === "failure" ? color.red("\u2717") : color.amber("\u2298");
               const tail = last.note ? color.dim(` \u2014 ${last.note.slice(0, 80)}`) : "";
@@ -9743,9 +10285,17 @@ async function renderGoalBanner(opts) {
   const goal = await loadGoalSafe(opts);
   if (!goal) return;
   const summary = goal.goal.length > 80 ? `${goal.goal.slice(0, 77)}\u2026` : goal.goal;
+  const stateColor = goal.goalState === "active" ? color.green : goal.goalState === "paused" ? color.amber : goal.goalState === "completed" ? color.green : goal.goalState === "abandoned" ? color.dim : color.dim;
   opts.renderer.write(
-    color.dim("Goal: ") + color.bold(summary) + color.dim(`  (iter ${goal.iterations})`) + "\n"
+    color.dim("Goal: ") + stateColor(summary) + color.dim(` [${goal.goalState}]  (iter ${goal.iterations})`) + "\n"
   );
+  if (goal.journal.length > 0) {
+    const lastEntry = goal.journal[goal.journal.length - 1];
+    const statusIcon2 = lastEntry.status === "success" ? "\u2713" : lastEntry.status === "failure" ? "\u2717" : lastEntry.status === "aborted" ? "\u2298" : lastEntry.status === "skipped" ? "\u229D" : "\xB7";
+    opts.renderer.write(
+      color.dim(`  Last: ${statusIcon2} ${lastEntry.task} (${lastEntry.status})`) + "\n"
+    );
+  }
   if (goal.engineState === "running") {
     opts.renderer.write(
       color.amber("  \u21BA Eternal engine was running when last session ended.") + "\n"
@@ -9770,6 +10320,18 @@ async function renderGoalBanner(opts) {
         color.dim("  Use `/autonomy eternal` to resume.") + "\n"
       );
     }
+  } else if (goal.goalState === "paused") {
+    opts.renderer.write(
+      color.amber("  \u23F8 Goal is paused. Use `/goal resume` to continue.") + "\n"
+    );
+  } else if (goal.goalState === "completed") {
+    opts.renderer.write(
+      color.green("  \u2713 Goal completed! Use `/goal clear` to set a new goal.") + "\n"
+    );
+  } else if (goal.goalState === "abandoned") {
+    opts.renderer.write(
+      color.dim("  Use `/goal clear` to set a new goal.") + "\n"
+    );
   }
   opts.renderer.write("\n");
 }
@@ -9868,6 +10430,7 @@ async function execute(deps) {
     skillLoader
   } = deps;
   let code = 0;
+  let fleetStatusLine = null;
   try {
     const visionAdapters = () => createToolVisionAdapters(agent.tools);
     const supportsVision = async () => {
@@ -9887,6 +10450,11 @@ async function execute(deps) {
     if ((goalFlag || askFlag) && positional.length === 0 && !promptFlag) {
       flags.tui = true;
     }
+    const enteringTui = !(positional.length > 0 || promptFlag) && !!flags.tui && flags["no-tui"] !== true;
+    if (!enteringTui) {
+      fleetStatusLine = new FleetStatusLine({ events, version: CLI_VERSION });
+      fleetStatusLine.start();
+    }
     if (positional.length > 0 || promptFlag) {
       const query = positional.join(" ");
       const ctrl = new AbortController();
@@ -10011,6 +10579,7 @@ async function execute(deps) {
           setStatuslineHiddenItems,
           initialGoal: goalFlag,
           initialAsk: askFlag,
+          projectRoot,
           getSDDContext: () => {
             const { getActiveSDDContext: getActiveSDDContext2 } = (init_sdd(), __toCommonJS(sdd_exports));
             return getActiveSDDContext2();
@@ -10097,6 +10666,7 @@ async function execute(deps) {
       });
     }
   } finally {
+    fleetStatusLine?.stop();
     try {
       stats.render(renderer);
     } catch (err) {
@@ -10156,6 +10726,13 @@ var MultiAgentHost = class {
   getCoordinator() {
     return this.director.coordinator;
   }
+  /** Public accessor for the Director — used by buildRoutingRunner. */
+  getDirector() {
+    return this.director;
+  }
+  async ensureCoordinator(config) {
+    await this.buildDirector();
+  }
   async buildDirector() {
     if (this.director) return;
     const config = this.deps.configStore.get();
@@ -10211,22 +10788,41 @@ var MultiAgentHost = class {
         limit: payload.limit
       });
     });
-    this.getCoordinator().on("task.assigned", ({ task, subagentId }) => {
-      this.deps.events.emit("subagent.task_started", {
-        subagentId,
-        taskId: task.id,
-        description: task.description
+    this.director.fleet.filter("budget.extended", (e) => {
+      const payload = e.payload;
+      this.deps.events.emit("subagent.budget_extended", {
+        subagentId: e.subagentId,
+        kind: payload.kind,
+        newLimit: payload.newLimit,
+        totalExtensions: payload.totalExtensions
       });
     });
-    const runner = this.buildSubagentRunner(config);
+    this.getCoordinator().on(
+      "task.assigned",
+      ({
+        task,
+        subagentId
+      }) => {
+        this.deps.events.emit("subagent.task_started", {
+          subagentId,
+          taskId: task.id,
+          description: task.description
+        });
+      }
+    );
+    const runner = await this.buildSubagentRunner(config);
     this.getCoordinator().setRunner(runner);
   }
   /**
-   * Build the per-subagent runner: agent factory → runner. Extracted so
-   * ensureCoordinator stays focused on orchestration setup.
+   * Build a per-role subagent factory: given a SubagentConfig, construct a
+   * fresh, isolated Agent with the role's filtered tools and (when the config
+   * carries one) the role's persona as an appended system-prompt block. Public
+   * so the autonomy-parallel engine can reuse the exact same agent-construction
+   * path the director/spawn flow uses — each parallel slot then runs as a real,
+   * specialized, concurrency-safe agent instead of sharing the leader's Context.
    */
-  buildSubagentRunner(config) {
-    const factory = async (subCfg) => {
+  makeSubagentFactory(config) {
+    return async (subCfg) => {
       const events = new EventBus();
       const provider = await this.buildSubagentProvider(config, subCfg.provider);
       const baseSystem = await this.deps.systemPromptBuilder.build({
@@ -10241,6 +10837,9 @@ var MultiAgentHost = class {
         // meaningless to a single delegated subtask.
         subagent: true
       });
+      if (subCfg.systemPromptOverride) {
+        baseSystem.push({ type: "text", text: subCfg.systemPromptOverride });
+      }
       let subSession;
       if (this.sessionFactory) {
         const subagentName = subCfg.id ?? subCfg.name ?? `sub_${randomUUID().slice(0, 8)}`;
@@ -10319,7 +10918,22 @@ var MultiAgentHost = class {
       };
       return { agent, events, dispose };
     };
-    return makeAgentSubagentRunner({ factory, fleetBus: this.director?.fleet ?? NULL_FLEET_BUS });
+  }
+  /**
+   * Build the per-subagent runner.
+   *
+   * ACP agents (provider: 'acp') get their own runner via
+   * makeACPSubagentRunner — they run external processes and don't go
+   * through the Agent factory. Regular agents use the standard
+   * makeAgentSubagentRunner path.
+   */
+  async buildSubagentRunner(config) {
+    return buildRoutingRunner(config, this);
+  }
+  async buildACPRunner(subagentId) {
+    const cmd = ACP_AGENT_COMMANDS[subagentId];
+    if (!cmd) throw new Error(`Unknown ACP agent: ${subagentId}`);
+    return makeACPSubagentRunner(cmd);
   }
   /**
    * Build a Provider for a subagent. When `overrideId` is supplied (from
@@ -10341,6 +10955,24 @@ var MultiAgentHost = class {
       type: providerId
     });
   }
+  async spawnACP(subagentId, task, config) {
+    const taskId = randomUUID();
+    await this.ensureCoordinator(config);
+    const coordinator = this.getCoordinator();
+    const acpRunner = await this.buildACPRunner(subagentId);
+    coordinator.setRunner(acpRunner);
+    await coordinator.spawn({
+      id: subagentId,
+      name: subagentId,
+      role: subagentId,
+      provider: "acp"
+    });
+    await coordinator.assign({
+      id: taskId,
+      description: task
+    });
+    return taskId;
+  }
   /** Returns a tool slice for the subagent — full set unless restricted. */
   filterTools(allow) {
     const all = this.deps.toolRegistry.list();
@@ -10350,7 +10982,7 @@ var MultiAgentHost = class {
   }
   subagentToolRegistry(allow) {
     if (!allow || allow.length === 0) return this.deps.toolRegistry;
-    const sub = this.deps.toolRegistry.clone();
+    const sub = new ToolRegistry();
     for (const t of this.filterTools(allow)) sub.register(t);
     return sub;
   }
@@ -10595,6 +11227,20 @@ var MultiAgentHost = class {
     }
   }
 };
+function buildRoutingRunner(config, host) {
+  const standardRunner = makeAgentSubagentRunner({
+    factory: host.makeSubagentFactory(config),
+    fleetBus: host.getDirector()?.fleet ?? NULL_FLEET_BUS
+  });
+  return async (task, ctx) => {
+    const subCfg = ctx.config;
+    if (subCfg.provider === "acp") {
+      const cacheKey = subCfg.role ?? subCfg.name ?? subCfg.id;
+      return host.buildACPRunner(cacheKey).then((r) => r(task, ctx));
+    }
+    return standardRunner(task, ctx);
+  };
+}
 function makePromptDelegate(reader) {
   return async (tool, input, suggestedPattern) => {
     process.stdout.write("\x07");
@@ -12068,7 +12714,11 @@ Restart WrongStack to load or unload plugin code in this session.`;
             projectRoot,
             compactor: container.resolve(TOKENS.Compactor),
             maxContextTokens: effectiveMaxContext > 0 ? effectiveMaxContext : void 0,
-            onIteration: broadcastEternalIteration
+            onIteration: broadcastEternalIteration,
+            // Real per-role factory: each dispatched slot runs as a fresh,
+            // isolated agent with the role's filtered tools + persona prompt
+            // (instead of sharing the leader agent's Context).
+            subagentFactory: multiAgentHost.makeSubagentFactory(config)
           });
         }
         void parallelEngine.prime?.();
@@ -12095,10 +12745,13 @@ Restart WrongStack to load or unload plugin code in this session.`;
     onBeforeExit: async () => {
       const { spawn: spawn3 } = await import('child_process');
       const cwd2 = projectRoot;
-      const statusResult = await new Promise((resolve4) => {
+      const statusResult = await new Promise((resolve4, reject) => {
         const child = spawn3("git", ["status", "--porcelain"], { cwd: cwd2, stdio: ["ignore", "pipe", "pipe"] });
         let stdout = "";
-        child.stdout?.on("data", (d) => stdout += d);
+        child.stdout?.on("data", (d) => {
+          stdout += d;
+        });
+        child.on("error", reject);
         child.on("close", (code) => resolve4({ stdout, code: code ?? 0 }));
       });
       if (statusResult.stdout.trim().length > 0) {
@@ -12143,7 +12796,11 @@ Restart WrongStack to load or unload plugin code in this session.`;
         provider: context.provider,
         model: context.model
       });
-    }
+    },
+    onDispatchClassify: makeProviderClassifier(
+      context.provider,
+      context.model
+    )
   });
   for (const cmd of slashCmds) slashRegistry.register(cmd);
   const eternalFlag = typeof flags["eternal"] === "string" ? flags["eternal"].trim() : "";
@@ -12262,12 +12919,12 @@ if (isMain) {
   main(process.argv.slice(2)).then(
     (c) => {
       process.exitCode = c;
-      setTimeout(() => process.exit(c), 200).unref();
+      setTimeout(() => process.exit(c), 500).unref();
     },
     (err) => {
       process.stderr.write((err instanceof Error ? err.stack : String(err)) + "\n");
       process.exitCode = 1;
-      setTimeout(() => process.exit(1), 200).unref();
+      setTimeout(() => process.exit(1), 500).unref();
     }
   );
 }