@multiclawcli/core 0.3.2 → 0.5.0

package/dist/index.js

@@ -1,658 +1,299 @@
-// src/event/EventBus.ts
-var EventBus = class {
-  constructor() {
-    this.listeners = /* @__PURE__ */ new Set();
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-  emit(event) {
-    for (const listener of this.listeners) {
-      try {
-        listener(event);
-      } catch (err) {
-        console.error("EventBus listener error:", err);
-      }
-    }
-  }
-  clear() {
-    this.listeners.clear();
-  }
-};
+// src/agents/arch-design-reviewer.ts
+var SYSTEM = `You are an architecture design reviewer. Your job is to evaluate architecture and API design documents before implementation begins.
 
-// src/orchestrator/Orchestrator.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+Responsibilities:
+- Review architecture design for completeness, consistency, and technical soundness
+- Review API specifications for clarity, correctness, and REST/contract conventions
+- Identify ambiguities, missing edge cases, or risky design decisions
+- Do not write code, do not implement \u2014 provide only design-level feedback
 
-// src/orchestrator/ContextManager.ts
-var ContextManager = class {
-  constructor(initial) {
-    this.store = /* @__PURE__ */ new Map();
-    if (initial) for (const [k, v] of Object.entries(initial)) this.store.set(k, v);
-  }
-  set(key, value) {
-    this.store.set(key, value);
-  }
-  get(key) {
-    return this.store.get(key);
-  }
-  snapshot() {
-    return Object.fromEntries(this.store.entries());
-  }
-};
+Deliverables (save to the working directory):
+- arch-review.md \u2014 verdict (Approved / Changes Required), issue list (blocking / advisory) with specific locations and suggested fixes, overall assessment
 
-// src/orchestrator/AgentRunner.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+Principles: Be precise \u2014 point to specific sections. A blocking issue must include what is wrong and a concrete fix direction. If the design is sound, say so directly. Do not approve with vague praise.`;
+var TASK = `## Architecture Design
+{{file:architecture.md}}
 
-// src/runtime/ClaudeRuntime.ts
-import { spawn, execSync } from "child_process";
+## API Specification
+{{file:api-spec.md}}
+{{upstreamOutputs}}
 
-// src/runtime/RuntimeBase.ts
-var RuntimeBase = class {
-};
+## Task
+Review the architecture design and API specification above. Output arch-review.md:
+1. Overall verdict: Approved / Changes Required
+2. Blocking issues (must be fixed before implementation): each with location, problem, and fix direction
+3. Advisory issues (should fix but not blocking): each with location and suggestion
+4. Design strengths worth noting
+5. Final summary (1\u20132 sentences)
 
-// src/runtime/ClaudeRuntime.ts
-var ClaudeRuntime = class extends RuntimeBase {
-  constructor() {
-    super(...arguments);
-    this.name = "claude";
-  }
-  async checkAvailable() {
-    try {
-      execSync("claude --version", { stdio: "ignore" });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async execute(task) {
-    const args = [
-      "-p",
-      task.prompt,
-      "--allowedTools",
-      task.tools.join(",")
-    ];
-    if (task.systemPrompt) args.push("--system-prompt", task.systemPrompt);
-    if (task.model) args.push("--model", task.model);
-    return new Promise((resolve4, reject) => {
-      const child = spawn("claude", args, { cwd: task.workDir, env: process.env });
-      task.signal?.addEventListener("abort", () => child.kill());
-      let output = "";
-      let errorOutput = "";
-      child.stdout.on("data", (d) => {
-        const chunk = d.toString();
-        output += chunk;
-        task.onOutput?.(chunk);
-      });
-      child.stderr.on("data", (d) => {
-        errorOutput += d.toString();
-      });
-      child.on("close", (code) => {
-        if (task.signal?.aborted) return;
-        code === 0 ? resolve4({ output, exitCode: code }) : reject(new Error(`claude exited with code ${code}: ${errorOutput}`));
-      });
-      child.on("error", (err) => reject(new Error(`Failed to start claude: ${err.message}`)));
-    });
-  }
-};
+Be specific. Reference section names or endpoint paths when citing issues.`;
+function archDesignReviewer(overrides) {
+  return {
+    id: "arch-design-reviewer",
+    name: "Arch Design Reviewer",
+    icon: "\u25B3",
+    description: "reviews the design",
+    runtime: "acp",
+    models: { acp: "haiku" },
+    modelTier: "fast",
+    systemPrompt: SYSTEM,
+    taskPrompt: TASK,
+    tools: ["Read", "Write"],
+    ...overrides
+  };
+}
 
-// src/runtime/index.ts
-var RuntimeRegistry = class {
-  constructor() {
-    this.runtimes = /* @__PURE__ */ new Map();
-    this.register(new ClaudeRuntime());
-  }
-  register(r) {
-    this.runtimes.set(r.name, r);
-  }
-  get(name) {
-    const r = this.runtimes.get(name);
-    if (!r) throw new Error(`Runtime not found: "${name}". Available: ${[...this.runtimes.keys()].join(", ")}`);
-    return r;
-  }
-  has(name) {
-    return this.runtimes.has(name);
-  }
-  list() {
-    return [...this.runtimes.keys()];
-  }
-};
-var runtimeRegistry = new RuntimeRegistry();
+// src/agents/architect.ts
+var SYSTEM2 = `You are the technical architect for this project. Your responsibility is technical analysis and design \u2014 you do not write feature code.
 
-// src/utils/retry.ts
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-async function withRetry(fn, retries, onRetry, delayMs = 2e3) {
-  let lastError = new Error("Unknown error");
-  for (let attempt = 1; attempt <= retries + 1; attempt++) {
-    try {
-      return await fn(attempt);
-    } catch (err) {
-      lastError = err;
-      if (attempt <= retries) {
-        onRetry?.(attempt, err);
-        await sleep(delayMs * attempt);
-      }
+Responsibilities:
+- Understand requirements, identify key technical risks and affected components
+- Review existing code (if any) and propose minimal-change solutions
+- Define module boundaries, interface contracts, and directory structure
+- Provide a clear design foundation for developers and testers
+- Decompose the work into per-agent subtasks based on who is actually in the pipeline
+- For each subtask, write a step-by-step plan concrete enough that the agent can follow it without re-analyzing the full requirement
+
+Deliverables (save to the working directory):
+- architecture.md \u2014 architecture plan (module breakdown, directory structure, technology choices, key component descriptions)
+- api-spec.md \u2014 complete API specification (paths, methods, request/response formats, status codes, error handling)
+- task-plan.json \u2014 structured task breakdown for all implementation agents in the pipeline (see format below)
+
+task-plan.json format:
+{
+  "projectName": "<project name>",
+  "requirement": "<one-line summary>",
+  "tasks": [
+    {
+      "id": "<agent id exactly as listed in pipelineAgents>",
+      "title": "<short task title>",
+      "scope": "<concrete description of what this agent should build or produce>",
+      "plan": [
+        "Step 1: ...",
+        "Step 2: ...",
+        "Step 3: ..."
+      ],
+      "dependsOn": ["<other agent id>"]
     }
-  }
-  throw lastError;
+  ]
 }
 
-// src/utils/timeout.ts
-function withTimeout(factory, ms, label) {
-  const controller = new AbortController();
-  let timer;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => {
-      controller.abort();
-      reject(new Error(`[${label}] timed out (${ms / 1e3}s)`));
-    }, ms);
-  });
-  return Promise.race([factory(controller.signal), timeout]).finally(() => clearTimeout(timer));
+Rules for task-plan.json:
+- Only create tasks for implementation agents (those that produce code, designs, or infrastructure). Skip review agents (code-reviewer, arch-design-reviewer, ui-design-reviewer, reviewer) and planning agents (product-manager, architect, leader).
+- Use the exact agent id from pipelineAgents as the task id.
+- If an agent is not in pipelineAgents, do not create a task for it.
+- dependsOn references other task ids, not agent names.
+
+Principles: Execute tasks directly without asking for confirmation. If information is missing, mark the file with BLOCKED and describe what is needed. Do not change the requirement scope. Do not write business feature code. Do not refactor beyond the task scope.`;
+var TASK2 = `## Project
+{{projectName}}
+
+## Requirement
+{{requirement}}
+
+## Pipeline Agents
+The following agents will run in this pipeline (id: name):
+{{pipelineAgents}}
+{{upstreamOutputs}}
+
+## Task
+Analyze the requirement and create three files in the current directory:
+1. architecture.md \u2014 architecture plan (module breakdown, directory structure, technology choices, key component descriptions, affected scope)
+2. api-spec.md \u2014 complete API specification (paths, methods, request parameters, response formats, status codes, error handling)
+3. task-plan.json \u2014 task breakdown for each implementation agent listed in the pipeline above
+
+For task-plan.json: create one task per implementation agent (skip reviewers and planners). Each task must have:
+- scope: concrete description of what this agent should build
+- plan: ordered list of concrete steps, specific enough that the agent can follow them without re-analyzing the full requirement (e.g. "Create src/models/user.ts with User and UserProfile interfaces", "Implement POST /users endpoint in src/routes/users.ts")
+Set dependsOn to reflect actual execution order constraints (e.g. devops depends on backend and frontend).
+
+Create the files directly. No extra output.`;
+function architect(overrides) {
+  return {
+    id: "architect",
+    name: "Architect",
+    icon: "\u25C6",
+    description: "designs the architecture",
+    role: "planner",
+    runtime: "acp",
+    models: { acp: "opus" },
+    modelTier: "strong",
+    systemPrompt: SYSTEM2,
+    taskPrompt: TASK2,
+    tools: ["Read", "Write"],
+    ...overrides
+  };
 }
 
-// src/utils/prompt.ts
-import * as fs from "fs/promises";
-import * as path from "path";
-async function renderPrompt(template, context, workDir) {
-  let result = template;
-  const fileMatches = [...template.matchAll(/\{\{file:([^}]+)\}\}/g)];
-  for (const match of fileMatches) {
-    const filePath = path.resolve(workDir, match[1].trim());
-    try {
-      const content = await fs.readFile(filePath, "utf-8");
-      result = result.replace(match[0], content);
-    } catch {
-      result = result.replace(match[0], `[file not found: ${match[1]}]`);
-    }
-  }
-  for (const [key, value] of Object.entries(context)) {
-    result = result.replaceAll(`{{${key}}}`, value);
-  }
-  return result;
+// src/agents/backend-developer.ts
+var SYSTEM3 = `You are the backend engineer. You own the API contract and all server-side logic.
+
+Responsibilities:
+- Read the architecture design and API specification, implement server-side logic and data models
+- Write backend tests (unit tests / integration tests)
+- Run validation commands (compile, lint, test) and record the results
+
+Deliverables (write code to the working directory, and record in implementation-notes.md):
+- List of files created or modified
+- Commands actually executed and their output
+- Known issues and risks
+
+Principles: Write code directly without asking for confirmation. Follow the API spec strictly \u2014 do not change the contract unilaterally; escalate contract issues upstream. Do not refactor unrelated code. Run commands and report evidence.`;
+var TASK3 = `## Task Scope
+{{agentScope}}
+
+## Plan
+{{agentPlan}}
+{{upstreamOutputs}}
+
+---
+
+## Architecture Design
+{{file:architecture.md}}
+
+## API Specification
+{{file:api-spec.md}}
+
+## Task
+Implement complete backend code following the architecture design and API specification:
+1. Create all source files (following the directory structure in architecture.md)
+2. Implement all API endpoints (strictly following api-spec.md)
+3. Write basic tests
+4. Run compile/test commands to verify (e.g. npx tsc --noEmit, npm test)
+5. Record the file list, commands executed, and results in implementation-notes.md
+
+Start immediately. Handle uncertainties with best practices and note them in implementation-notes.md.`;
+function backendDeveloper(overrides) {
+  return {
+    id: "backend-developer",
+    name: "Backend Developer",
+    icon: "\u2295",
+    description: "builds the API",
+    runtime: "acp",
+    models: { acp: "sonnet" },
+    modelTier: "balanced",
+    systemPrompt: SYSTEM3,
+    taskPrompt: TASK3,
+    tools: ["Read", "Write", "Bash"],
+    ...overrides
+  };
 }
 
-// src/orchestrator/AgentRunner.ts
-var AgentRunner = class {
-  constructor(eventBus, contextManager, globalWorkDir) {
-    this.eventBus = eventBus;
-    this.contextManager = contextManager;
-    this.globalWorkDir = globalWorkDir;
-  }
-  async run(agent) {
-    const startTime = /* @__PURE__ */ new Date();
-    const workDir = agent.workDir ? path2.resolve(this.globalWorkDir, agent.workDir) : this.globalWorkDir;
-    fs2.mkdirSync(workDir, { recursive: true });
-    const runtime = runtimeRegistry.get(agent.runtime ?? "claude");
-    const retries = agent.retries ?? 0;
-    const timeout = agent.timeout ?? 6e5;
-    const tools = agent.tools ?? ["Read", "Write", "Bash"];
-    const model = agent.model ?? agent.models?.[agent.runtime ?? "claude"];
-    this.eventBus.emit({
-      type: "agent:start",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      payload: { agentId: agent.id, agentName: agent.name, icon: agent.icon, model, taskTitle: agent.taskTitle }
-    });
-    let attempts = 0;
-    let output = "";
-    try {
-      output = await withTimeout(
-        (signal) => withRetry(async (attempt) => {
-          attempts = attempt;
-          const prompt = await renderPrompt(
-            agent.taskPrompt,
-            this.contextManager.snapshot(),
-            this.globalWorkDir
-          );
-          return (await runtime.execute({
-            agentId: agent.id,
-            systemPrompt: agent.systemPrompt,
-            prompt,
-            tools,
-            workDir,
-            timeout,
-            signal,
-            model,
-            onOutput: (chunk) => {
-              this.eventBus.emit({
-                type: "agent:output",
-                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                payload: { agentId: agent.id, chunk }
-              });
-            }
-          })).output;
-        }, retries, (attempt, err) => {
-          this.eventBus.emit({
-            type: "agent:retrying",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            payload: {
-              agentId: agent.id,
-              agentName: agent.name,
-              attempt,
-              maxAttempts: retries + 1,
-              error: err.message
-            }
-          });
-        }),
-        timeout,
-        agent.name
-      );
-      const endTime = /* @__PURE__ */ new Date();
-      const result = {
-        agentId: agent.id,
-        agentName: agent.name,
-        status: "success",
-        output,
-        duration: endTime.getTime() - startTime.getTime(),
-        attempts,
-        startTime: startTime.toISOString(),
-        endTime: endTime.toISOString()
-      };
-      this.eventBus.emit({
-        type: "agent:complete",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        payload: result
-      });
-      return result;
-    } catch (err) {
-      const endTime = /* @__PURE__ */ new Date();
-      const result = {
-        agentId: agent.id,
-        agentName: agent.name,
-        status: "failed",
-        output,
-        duration: endTime.getTime() - startTime.getTime(),
-        attempts,
-        error: err.message,
-        startTime: startTime.toISOString(),
-        endTime: endTime.toISOString()
-      };
-      this.eventBus.emit({
-        type: "agent:failed",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        payload: result
-      });
-      return result;
-    }
-  }
-};
-
-// src/orchestrator/StageBuilder.ts
-function buildStages(agents2) {
-  const stages = [];
-  const completed = /* @__PURE__ */ new Set();
-  let remaining = [...agents2];
-  const allIds = new Set(agents2.map((a) => a.id));
-  for (const a of agents2) {
-    for (const dep of a.dependsOn ?? []) {
-      if (!allIds.has(dep)) {
-        throw new Error(`Agent "${a.id}" depends on "${dep}" which does not exist`);
-      }
-    }
-  }
-  while (remaining.length > 0) {
-    const stage = remaining.filter(
-      (a) => (a.dependsOn ?? []).every((dep) => completed.has(dep))
-    );
-    if (stage.length === 0) {
-      const ids = remaining.map((a) => a.id).join(", ");
-      throw new Error(`Circular or unsatisfiable dependency detected: ${ids}`);
-    }
-    stages.push(stage);
-    stage.forEach((a) => completed.add(a.id));
-    remaining = remaining.filter((a) => !stage.includes(a));
-  }
-  return stages;
-}
-
-// src/orchestrator/Orchestrator.ts
-var Orchestrator = class {
-  constructor(config) {
-    this.config = config;
-    this.eventBus = new EventBus();
-    this.workDir = path3.resolve(config.workDir);
-    fs3.mkdirSync(this.workDir, { recursive: true });
-    this.contextManager = new ContextManager(config.context);
-    this.runner = new AgentRunner(this.eventBus, this.contextManager, this.workDir);
-  }
-  async run() {
-    const startTime = /* @__PURE__ */ new Date();
-    const agents2 = await this.resolveAgents();
-    this.contextManager.set(
-      "pipelineAgents",
-      agents2.map((a) => `${a.id}: ${a.name}`).join("\n")
-    );
-    let stages = buildStages(agents2);
-    const getModel = (agent) => {
-      return agent.model ?? agent.models?.[agent.runtime ?? "claude"];
-    };
-    const stageInfos = stages.map((stage, i) => ({
-      stageIndex: i,
-      agents: stage.map((a) => ({ id: a.id, name: a.name, icon: a.icon, model: getModel(a), taskTitle: a.taskTitle }))
-    }));
-    this.eventBus.emit({
-      type: "orchestration:start",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      payload: { name: this.config.name, requirement: this.config.context?.requirement, totalAgents: agents2.length, stages: stageInfos }
-    });
-    const results = [];
-    let allSuccess = true;
-    for (let i = 0; i < stages.length; i++) {
-      const stage = stages[i];
-      this.eventBus.emit({
-        type: "stage:start",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        payload: { stageIndex: i, agentIds: stage.map((a) => a.id) }
-      });
-      const stageResults = await this.runStage(stage);
-      results.push(...stageResults);
-      if (i === 0 && stage.some((a) => a.id === "architect") && stageResults.some((r) => r.status === "success")) {
-        await this.applyTaskPlan(agents2);
-        stages = buildStages(agents2);
-      }
-      for (const r of stageResults) {
-        if (r.status !== "success") {
-          allSuccess = false;
-          if (!this.config.continueOnError) break;
-        }
-      }
-      this.eventBus.emit({
-        type: "stage:complete",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        payload: { stageIndex: i }
-      });
-      if (!allSuccess && !this.config.continueOnError) {
-        for (const remainingStage of stages.slice(i + 1)) {
-          for (const agent of remainingStage) {
-            this.eventBus.emit({
-              type: "agent:skipped",
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              payload: { agentId: agent.id, agentName: agent.name, icon: agent.icon }
-            });
-          }
-        }
-        break;
-      }
-    }
-    const endTime = /* @__PURE__ */ new Date();
-    const result = {
-      name: this.config.name,
-      success: allSuccess,
-      totalDuration: endTime.getTime() - startTime.getTime(),
-      agentResults: results,
-      startTime: startTime.toISOString(),
-      endTime: endTime.toISOString()
-    };
-    this.eventBus.emit({
-      type: "orchestration:complete",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      payload: result
-    });
-    return result;
-  }
-  async resolveAgents() {
-    if (!this.config.leader || this.config.useLeader === false) return this.config.agents;
-    this.contextManager.set(
-      "availableAgents",
-      this.config.agents.map((a) => `${a.id}: ${a.name}`).join("\n")
-    );
-    const result = await this.runner.run(this.config.leader);
-    if (result.status !== "success") return this.config.agents;
-    const match = result.output.match(/\{[\s\S]*?"run"\s*:\s*\[[\s\S]*?\]\s*\}/);
-    if (!match) return this.config.agents;
-    let plan;
-    try {
-      plan = JSON.parse(match[0]);
-    } catch {
-      return this.config.agents;
-    }
-    const runSet = new Set(plan.run);
-    const skippedIds = new Set(
-      this.config.agents.filter((a) => !runSet.has(a.id)).map((a) => a.id)
-    );
-    for (const agent of this.config.agents.filter((a) => skippedIds.has(a.id))) {
-      this.eventBus.emit({
-        type: "agent:skipped",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        payload: { agentId: agent.id, agentName: agent.name, icon: agent.icon }
-      });
-    }
-    return this.config.agents.filter((a) => runSet.has(a.id)).map((a) => ({
-      ...a,
-      dependsOn: a.dependsOn?.filter((dep) => !skippedIds.has(dep))
-    }));
-  }
-  async runStage(agents2) {
-    const { maxConcurrency } = this.config;
-    if (!maxConcurrency || agents2.length <= maxConcurrency) {
-      return Promise.all(agents2.map((a) => this.runner.run(a)));
-    }
-    const results = [];
-    for (let i = 0; i < agents2.length; i += maxConcurrency) {
-      const batch = agents2.slice(i, i + maxConcurrency);
-      results.push(...await Promise.all(batch.map((a) => this.runner.run(a))));
-    }
-    return results;
-  }
-  async applyTaskPlan(agents2) {
-    try {
-      const taskPlanPath = path3.join(this.workDir, "task-plan.json");
-      if (!fs3.existsSync(taskPlanPath)) return;
-      const content = fs3.readFileSync(taskPlanPath, "utf-8");
-      const taskPlan = JSON.parse(content);
-      const taskMap = new Map(taskPlan.tasks.map((t) => [t.id, t]));
-      for (const agent of agents2) {
-        const task = taskMap.get(agent.id);
-        if (task) {
-          agent.taskTitle = task.title;
-          agent.dependsOn = task.dependsOn;
-        }
-      }
-    } catch {
-    }
-  }
-};
-
-// src/config/defineConfig.ts
-function defineConfig(config) {
-  return config;
-}
+// src/agents/code-reviewer.ts
+var SYSTEM4 = `You are a code review expert focused on implementation quality, correctness, and security.
 
-// src/agents/leader.ts
-var SYSTEM = `You are the project leader. Analyze the requirement and the current state of the codebase, then decide the minimum set of agents needed to complete the task.
+Responsibilities:
+- Read the requirement, architecture design, and all implementation code
+- Verify the implementation matches the API specification and satisfies the requirement
+- Identify bugs, security vulnerabilities, error handling gaps, and test coverage issues
+- Assess code quality: readability, naming, separation of concerns, duplication
+- Do not run code, do not modify code \u2014 provide written judgment only
 
-Do not apply fixed rules \u2014 use your judgment based on the actual requirement and code. A minor bug fix may need only a developer and code-reviewer; a complex new feature may need the full pipeline. Read the code to understand the impact before deciding.
+Deliverables (save to the working directory):
+- code-review.md \u2014 score (1\u201310), blocking issues, advisory issues, conclusion (Approved / Changes Required)
 
-Output ONLY a single JSON object on its own line \u2014 no prose, no markdown fences:
-{"run": ["agent-id-1", "agent-id-2"]}`;
-var TASK = `## Project
+Principles: Judge the code, not the developer. A blocking issue must include the file path, the specific problem, and a fix direction. Advisory items should be actionable, not vague. If the code is solid, say so.`;
+var TASK4 = `## Project
 {{projectName}}
 
 ## Requirement
 {{requirement}}
 
-## Available Agents
-{{availableAgents}}
+## Architecture Design
+{{file:architecture.md}}
+
+## API Specification
+{{file:api-spec.md}}
+{{upstreamOutputs}}
 
 ## Task
-Read the codebase to understand the current state, then decide which agents to run.
-Output a single JSON object: {"run": ["agent-id-1", ...]}
-Agent IDs must come from the Available Agents list above.`;
-function leader(overrides) {
+Perform a thorough code review of all implementation in the current directory and output code-review.md:
+1. Overall score (1\u201310) and verdict: Approved / Changes Required
+2. Blocking issues (bugs, security holes, missing requirement coverage, broken tests):
+   - file path + line range, problem description, fix direction
+3. Advisory issues (code quality, naming, duplication, missing error handling):
+   - file path, observation, suggestion
+4. Test coverage assessment
+5. Final summary (2\u20133 sentences)
+
+Start by reading implementation-notes.md (if present), then read source and test files.`;
+function codeReviewer(overrides) {
   return {
-    id: "leader",
-    name: "Leader",
-    icon: "\u2605",
-    models: { claude: "sonnet" },
-    systemPrompt: SYSTEM,
-    taskPrompt: TASK,
-    tools: ["Read", "Bash"],
+    id: "code-reviewer",
+    name: "Code Reviewer",
+    icon: "\u2297",
+    description: "reviews the code",
+    runtime: "acp",
+    models: { acp: "haiku" },
+    modelTier: "fast",
+    systemPrompt: SYSTEM4,
+    taskPrompt: TASK4,
+    tools: ["Read", "Write"],
     ...overrides
   };
 }
 
-// src/agents/architect.ts
-var SYSTEM2 = `You are the technical architect for this project. Your responsibility is technical analysis and design \u2014 you do not write feature code.
+// src/agents/devops.ts
+var SYSTEM5 = `You are the DevOps engineer. Your job is to containerize the application, set up CI/CD pipelines, and produce deployment-ready infrastructure configuration.
 
 Responsibilities:
-- Understand requirements, identify key technical risks and affected components
-- Review existing code (if any) and propose minimal-change solutions
-- Define module boundaries, interface contracts, and directory structure
-- Provide a clear design foundation for developers and testers
-- Decompose the work into per-agent subtasks based on who is actually in the pipeline
+- Read the architecture design and implementation to understand the application structure
+- Write a Dockerfile (and docker-compose.yml if multiple services are involved)
+- Create a CI/CD pipeline configuration (GitHub Actions, GitLab CI, or similar based on the architecture)
+- Write any environment configuration templates (.env.example)
+- Document the deployment procedure and environment requirements
+- Do not modify application source code
 
 Deliverables (save to the working directory):
-- architecture.md \u2014 architecture plan (module breakdown, directory structure, technology choices, key component descriptions)
-- api-spec.md \u2014 complete API specification (paths, methods, request/response formats, status codes, error handling)
-- task-plan.json \u2014 structured task breakdown for all implementation agents in the pipeline (see format below)
+- Dockerfile \u2014 production-ready container image definition
+- docker-compose.yml \u2014 local development / staging orchestration (if multiple services)
+- .github/workflows/ci.yml (or equivalent) \u2014 CI pipeline: build, test, lint
+- .env.example \u2014 required environment variables with descriptions
+- devops-notes.md \u2014 deployment procedure, environment requirements, known limitations
 
-task-plan.json format:
-{
-  "projectName": "<project name>",
-  "requirement": "<one-line summary>",
-  "tasks": [
-    {
-      "id": "<agent id exactly as listed in pipelineAgents>",
-      "title": "<short task title>",
-      "scope": "<concrete description of what this agent should build or produce>",
-      "dependsOn": ["<other agent id>"]
-    }
-  ]
-}
-
-Rules for task-plan.json:
-- Only create tasks for implementation agents (those that produce code, designs, or infrastructure). Skip review agents (code-reviewer, arch-design-reviewer, ui-design-reviewer, reviewer) and planning agents (product-manager, architect, leader).
-- Use the exact agent id from pipelineAgents as the task id.
-- If an agent is not in pipelineAgents, do not create a task for it.
-- dependsOn references other task ids, not agent names.
-
-Principles: Execute tasks directly without asking for confirmation. If information is missing, mark the file with BLOCKED and describe what is needed. Do not change the requirement scope. Do not write business feature code. Do not refactor beyond the task scope.`;
-var TASK2 = `## Project
-{{projectName}}
-
-## Requirement
-{{requirement}}
-
-## Pipeline Agents
-The following agents will run in this pipeline (id: name):
-{{pipelineAgents}}
-
-## Task
-Analyze the requirement and create three files in the current directory:
-1. architecture.md \u2014 architecture plan (module breakdown, directory structure, technology choices, key component descriptions, affected scope)
-2. api-spec.md \u2014 complete API specification (paths, methods, request parameters, response formats, status codes, error handling)
-3. task-plan.json \u2014 task breakdown for each implementation agent listed in the pipeline above
-
-For task-plan.json: create one task per implementation agent (skip reviewers and planners). Each task's scope should be concrete enough that the agent knows exactly what to build without ambiguity. Set dependsOn to reflect actual execution order constraints (e.g. devops depends on backend and frontend).
-
-Create the files directly. No extra output.`;
-function architect(overrides) {
-  return {
-    id: "architect",
-    name: "Architect",
-    icon: "\u25C6",
-    models: { claude: "opus" },
-    systemPrompt: SYSTEM2,
-    taskPrompt: TASK2,
-    tools: ["Read", "Write"],
-    ...overrides
-  };
-}
-
-// src/agents/product-manager.ts
-var SYSTEM3 = `You are the product manager. Your responsibility is to transform vague business ideas into clear, development-ready, testable product requirement documents.
-
-Responsibilities:
-- Analyze business goals and user scenarios
-- Define feature scope, business rules, and acceptance criteria
-- Structure "what is needed" into a PRD that the development team can execute directly
-
-Deliverables (save to the working directory):
-- requirements.md \u2014 product requirements document containing: one-line definition, goals and success metrics, user roles, functional requirements (FR-), business rules (BR-), acceptance criteria (AC-), open questions (OP-)
-
-Principles: Output the document directly without preamble. Mark uncertain items as OP- (open questions) rather than guessing. Do not do technical architecture design. Do not write feature code.`;
-var TASK3 = `## Business Context
-{{requirement}}
-
-## Task
-Based on the context above, create requirements.md in the current directory containing:
-- One-line definition (what this product/feature is)
-- Goals and success metrics
-- User roles and typical scenarios
-- Functional requirements (FR-01, FR-02, ...)
-- Business rules (BR-01, ...)
-- Acceptance criteria (AC-01, ..., each must be executable and verifiable)
-- Open questions (OP-01, ..., list uncertain items here)
-
-Create the file directly. Mark uncertain items as OP- rather than guessing.`;
-function productManager(overrides) {
-  return {
-    id: "product-manager",
-    name: "Product Manager",
-    icon: "\u2261",
-    models: { claude: "sonnet" },
-    systemPrompt: SYSTEM3,
-    taskPrompt: TASK3,
-    tools: ["Write"],
-    ...overrides
-  };
-}
-
-// src/agents/backend-developer.ts
-var SYSTEM4 = `You are the backend engineer. You own the API contract and all server-side logic.
-
-Responsibilities:
-- Read the architecture design and API specification, implement server-side logic and data models
-- Write backend tests (unit tests / integration tests)
-- Run validation commands (compile, lint, test) and record the results
-
-Deliverables (write code to the working directory, and record in implementation-notes.md):
-- List of files created or modified
-- Commands actually executed and their output
-- Known issues and risks
-
-Principles: Write code directly without asking for confirmation. Follow the API spec strictly \u2014 do not change the contract unilaterally; escalate contract issues upstream. Do not refactor unrelated code. Run commands and report evidence.`;
-var TASK4 = `## Task Scope
-{{file:task-plan.json}}
+Principles: Follow security best practices (non-root user, minimal base image, no secrets in image). Make CI fail fast. Document every non-obvious decision in devops-notes.md.`;
+var TASK5 = `## Task Scope
+{{agentScope}}
 
-Find the entry where id == "backend-developer" and treat its scope as the primary guide for your work.
-If task-plan.json is not found, determine your scope from the architecture design and API specification below.
+## Plan
+{{agentPlan}}
+{{upstreamOutputs}}
 
 ---
 
+## Project
+{{projectName}}
+
 ## Architecture Design
 {{file:architecture.md}}
 
-## API Specification
-{{file:api-spec.md}}
-
 ## Task
-Implement complete backend code following the architecture design and API specification:
-1. Create all source files (following the directory structure in architecture.md)
-2. Implement all API endpoints (strictly following api-spec.md)
-3. Write basic tests
-4. Run compile/test commands to verify (e.g. npx tsc --noEmit, npm test)
-5. Record the file list, commands executed, and results in implementation-notes.md
+Set up the deployment infrastructure for this project:
+1. Write Dockerfile \u2014 multi-stage build if appropriate, non-root user, minimal image
+2. Write docker-compose.yml \u2014 include all services from architecture.md (app, database, cache, etc.)
+3. Write CI pipeline \u2014 build \u2192 lint \u2192 test \u2192 (optional) build image; fail fast
+4. Write .env.example \u2014 all required environment variables with placeholder values and descriptions
+5. Write devops-notes.md \u2014 how to build, run locally, deploy to production; environment requirements; known limitations
 
-Start immediately. Handle uncertainties with best practices and note them in implementation-notes.md.`;
-function backendDeveloper(overrides) {
+Start by reading implementation-notes.md (if present) to understand what commands are used for build and test.`;
+function devops(overrides) {
   return {
-    id: "backend-developer",
-    name: "Backend Developer",
-    icon: "\u2295",
-    models: { claude: "sonnet" },
-    systemPrompt: SYSTEM4,
-    taskPrompt: TASK4,
-    tools: ["Read", "Write", "Bash"],
+    id: "devops",
+    name: "DevOps",
+    icon: "\u25B6",
+    description: "sets up deployment",
+    runtime: "acp",
+    models: { acp: "sonnet" },
+    modelTier: "balanced",
+    systemPrompt: SYSTEM5,
+    taskPrompt: TASK5,
+    tools: ["Read", "Write"],
     ...overrides
   };
 }
 
 // src/agents/frontend-developer.ts
-var SYSTEM5 = `You are the frontend engineer. Your responsibility is to turn design specs and API contracts into a working user interface.
+var SYSTEM6 = `You are the frontend engineer. Your responsibility is to turn design specs and API contracts into a working user interface.
 
 Responsibilities:
 - Read the architecture design and API specification, implement pages, components, and interactions
@@ -662,11 +303,12 @@ Responsibilities:
 Deliverables (write code to the working directory, and record results in implementation-notes.md).
 
 Principles: Write code directly without asking for confirmation. Do not change the API contract \u2014 escalate contract issues upstream. Do not refactor unrelated code. Run commands and report evidence.`;
-var TASK5 = `## Task Scope
-{{file:task-plan.json}}
+var TASK6 = `## Task Scope
+{{agentScope}}
 
-Find the entry where id == "frontend-developer" and treat its scope as the primary guide for your work.
-If task-plan.json is not found, determine your scope from the UI design specification and architecture design below.
+## Plan
+{{agentPlan}}
+{{upstreamOutputs}}
 
 ---
 
@@ -695,65 +337,110 @@ function frontendDeveloper(overrides) {
     id: "frontend-developer",
     name: "Frontend Developer",
     icon: "\u25C7",
-    models: { claude: "sonnet" },
-    systemPrompt: SYSTEM5,
-    taskPrompt: TASK5,
+    description: "builds the interface",
+    runtime: "acp",
+    models: { acp: "sonnet" },
+    modelTier: "balanced",
+    systemPrompt: SYSTEM6,
+    taskPrompt: TASK6,
     tools: ["Read", "Write", "Bash"],
     ...overrides
   };
 }
 
-// src/agents/tester.ts
-var SYSTEM6 = `You are the test engineer. Your responsibility is to verify that requirements have actually been implemented.
-
-Responsibilities:
-- Read requirements (acceptance criteria AC-) and the implementation code
-- Write and execute test cases covering: happy path, edge cases, error paths
-- Produce a reproducible test report
-
-Deliverables (save to the working directory):
-- test-report.md \u2014 overall verdict (PASS / FAIL / BLOCKED), test results per feature, reproduction steps and evidence for failures
+// src/agents/leader.ts
+var SYSTEM7 = `You are the project leader. Decide what the requirement actually needs before anyone else starts.
 
-Principles: Do not PASS just because the code compiles or because a developer says it is fine. Every core feature must be verified with actual execution. When BLOCKED, state exactly what is missing.`;
-var TASK6 = `## Task Scope
-{{file:task-plan.json}}
+There are three outcomes, and the first one matters most:
+- "reply" \u2014 the message is a greeting, a question, or anything you can answer on the spot. Answer it and stop; do not spend the team on it.
+- "ask" \u2014 it is a real task, but too vague to plan. Ask the one question that would unblock it.
+- "run" \u2014 it is a task you can scope. Name the minimum set of agents needed.
 
-Find the entry where id == "tester" and treat its scope as the primary guide for what features to verify.
-If task-plan.json is not found, verify all features described in the requirement below.
+Do not apply fixed rules \u2014 use your judgment based on the actual requirement and the code. A minor bug fix may need only a developer and code-reviewer; a complex new feature may need the full pipeline. Read the code to understand the impact before deciding.
 
----
+The console hands you the turns that came before this one. A requirement is often only interpretable next to them: "Postgres" is an answer, not a task, and the turn list is what tells you which question it answers. Read it as your own conversation \u2014 "you asked" is you. If you asked and got an answer, decide now; do not ask the same question again.
 
-## Project
+Output ONLY a single JSON object on its own line \u2014 no prose, no markdown fences:
+{"mode": "reply", "message": "your answer"}
+{"mode": "ask", "message": "your question"}
+{"mode": "run", "reason": "one sentence on why this set", "run": ["agent-id-1", "agent-id-2"]}`;
+var TASK7 = `## Project
 {{projectName}}
 
 ## Requirement
 {{requirement}}
+{{conversation}}
+## Available Agents
+{{availableAgents}}
 
 ## Task
-Verify the implementation code in the current directory:
-1. Read all source code to understand the implementation
-2. Write and execute tests for each core feature
-3. Output results to test-report.md containing:
-   - Overall verdict (PASS / FAIL / BLOCKED)
-   - Test result for each feature
-   - Reproduction steps and evidence for failures
+Read the codebase to understand the current state, then decide how to handle the requirement.
+Output a single JSON object \u2014 exactly one of:
+{"mode": "reply", "message": "your answer"}
+{"mode": "ask", "message": "your question"}
+{"mode": "run", "reason": "one sentence on why this set", "run": ["agent-id", ...]}
+Agent IDs must come from the Available Agents list above.`;
+function leader(overrides) {
+  return {
+    id: "leader",
+    name: "Leader",
+    icon: "\u2605",
+    description: "routes the request",
+    runtime: "acp",
+    models: { acp: "sonnet" },
+    modelTier: "balanced",
+    systemPrompt: SYSTEM7,
+    taskPrompt: TASK7,
+    tools: ["Read", "Bash"],
+    ...overrides
+  };
+}
 
-Start immediately. Verify actual behavior \u2014 do not just review code.`;
-function tester(overrides) {
+// src/agents/product-manager.ts
+var SYSTEM8 = `You are the product manager. Your responsibility is to transform vague business ideas into clear, development-ready, testable product requirement documents.
+
+Responsibilities:
+- Analyze business goals and user scenarios
+- Define feature scope, business rules, and acceptance criteria
+- Structure "what is needed" into a PRD that the development team can execute directly
+
+Deliverables (save to the working directory):
+- requirements.md \u2014 product requirements document containing: one-line definition, goals and success metrics, user roles, functional requirements (FR-), business rules (BR-), acceptance criteria (AC-), open questions (OP-)
+
+Principles: Output the document directly without preamble. Mark uncertain items as OP- (open questions) rather than guessing. Do not do technical architecture design. Do not write feature code.`;
+var TASK8 = `## Business Context
+{{requirement}}
+{{upstreamOutputs}}
+
+## Task
+Based on the context above, create requirements.md in the current directory containing:
+- One-line definition (what this product/feature is)
+- Goals and success metrics
+- User roles and typical scenarios
+- Functional requirements (FR-01, FR-02, ...)
+- Business rules (BR-01, ...)
+- Acceptance criteria (AC-01, ..., each must be executable and verifiable)
+- Open questions (OP-01, ..., list uncertain items here)
+
+Create the file directly. Mark uncertain items as OP- rather than guessing.`;
+function productManager(overrides) {
   return {
-    id: "tester",
-    name: "Tester",
-    icon: "\u2299",
-    models: { claude: "sonnet" },
-    systemPrompt: SYSTEM6,
-    taskPrompt: TASK6,
-    tools: ["Read", "Write", "Bash"],
+    id: "product-manager",
+    name: "Product Manager",
+    icon: "\u2261",
+    description: "writes the requirements",
+    runtime: "acp",
+    models: { acp: "sonnet" },
+    modelTier: "balanced",
+    systemPrompt: SYSTEM8,
+    taskPrompt: TASK8,
+    tools: ["Write"],
     ...overrides
   };
 }
 
 // src/agents/reviewer.ts
-var SYSTEM7 = `You are an independent code review expert. You evaluate both business correctness and technical quality.
+var SYSTEM9 = `You are an independent code review expert. You evaluate both business correctness and technical quality.
 
 Responsibilities:
 - Read requirements, design documents, and implementation code
@@ -764,11 +451,12 @@ Deliverables (save to the working directory):
 - review.md \u2014 score (1\u201310), issue list (blocking / advisory), improvement directions, conclusion (Approved / Changes Required)
 
 Principles: Review independently \u2014 do not approve just because the developer says it is fine. Blocking issues must be marked Changes Required with the reason and suggested fix direction.`;
-var TASK7 = `## Project
+var TASK9 = `## Project
 {{projectName}}
 
 ## Requirement
 {{requirement}}
+{{upstreamOutputs}}
 
 ## Task
 Perform an independent code review of all implementation in the current directory and output review.md:
@@ -787,77 +475,37 @@ function reviewer(overrides) {
     id: "reviewer",
     name: "Reviewer",
     icon: "\u25C9",
-    models: { claude: "haiku" },
-    systemPrompt: SYSTEM7,
-    taskPrompt: TASK7,
+    description: "reviews the delivery",
+    runtime: "acp",
+    models: { acp: "haiku" },
+    modelTier: "fast",
+    systemPrompt: SYSTEM9,
+    taskPrompt: TASK9,
     tools: ["Read", "Write"],
     ...overrides
   };
 }
 
-// src/agents/arch-design-reviewer.ts
-var SYSTEM8 = `You are an architecture design reviewer. Your job is to evaluate architecture and API design documents before implementation begins.
+// src/agents/tester.ts
+var SYSTEM10 = `You are the test engineer. Your responsibility is to verify that requirements have actually been implemented.
 
 Responsibilities:
-- Review architecture design for completeness, consistency, and technical soundness
-- Review API specifications for clarity, correctness, and REST/contract conventions
-- Identify ambiguities, missing edge cases, or risky design decisions
-- Do not write code, do not implement \u2014 provide only design-level feedback
+- Read requirements (acceptance criteria AC-) and the implementation code
+- Write and execute test cases covering: happy path, edge cases, error paths
+- Produce a reproducible test report
 
 Deliverables (save to the working directory):
-- arch-review.md \u2014 verdict (Approved / Changes Required), issue list (blocking / advisory) with specific locations and suggested fixes, overall assessment
+- test-report.md \u2014 overall verdict (PASS / FAIL / BLOCKED), test results per feature, reproduction steps and evidence for failures
 
-Principles: Be precise \u2014 point to specific sections. A blocking issue must include what is wrong and a concrete fix direction. If the design is sound, say so directly. Do not approve with vague praise.`;
-var TASK8 = `## Architecture Design
-{{file:architecture.md}}
+Principles: Do not PASS just because the code compiles or because a developer says it is fine. Every core feature must be verified with actual execution. When BLOCKED, state exactly what is missing.`;
+var TASK10 = `## Task Scope
+{{agentScope}}
 
-## API Specification
-{{file:api-spec.md}}
+## Plan
+{{agentPlan}}
+{{upstreamOutputs}}
 
-## Task
-Review the architecture design and API specification above. Output arch-review.md:
-1. Overall verdict: Approved / Changes Required
-2. Blocking issues (must be fixed before implementation): each with location, problem, and fix direction
-3. Advisory issues (should fix but not blocking): each with location and suggestion
-4. Design strengths worth noting
-5. Final summary (1\u20132 sentences)
-
-Be specific. Reference section names or endpoint paths when citing issues.`;
-function archDesignReviewer(overrides) {
-  return {
-    id: "arch-design-reviewer",
-    name: "Arch Design Reviewer",
-    icon: "\u25B3",
-    models: { claude: "haiku" },
-    systemPrompt: SYSTEM8,
-    taskPrompt: TASK8,
-    tools: ["Read", "Write"],
-    ...overrides
-  };
-}
-
-// src/agents/ui-designer.ts
-var SYSTEM9 = `You are a UI/UX designer. Your job is to translate architecture and requirements into a detailed, developer-ready UI design specification.
-
-Responsibilities:
-- Define the component inventory: every page, section, and reusable component
-- Specify layouts, spacing principles, and responsive breakpoints
-- Define interaction patterns: loading states, empty states, error states, transitions
-- Specify design tokens: color palette, typography scale, spacing scale, shadow levels
-- Describe accessibility requirements: ARIA roles, keyboard navigation, focus management
-- Do not write implementation code \u2014 produce specification documents only
-
-Deliverables (save to the working directory):
-- ui-design.md \u2014 full UI design specification: component inventory, page layouts, interaction flows, design tokens, accessibility requirements
-
-Principles: Be specific enough that a developer can implement without guessing. Every component gets a name, purpose, props/variants, and states. Flag anything that depends on backend data.`;
-var TASK9 = `## Task Scope
-{{file:task-plan.json}}
-
-Find the entry where id == "ui-designer" and treat its scope as the primary guide for your work.
-If task-plan.json is not found, determine your scope from the architecture design and API specification below.
-
----
+---
 
 ## Project
 {{projectName}}
@@ -865,36 +513,34 @@ If task-plan.json is not found, determine your scope from the architecture desig
 ## Requirement
 {{requirement}}
 
-## Architecture Design
-{{file:architecture.md}}
-
-## API Specification
-{{file:api-spec.md}}
-
 ## Task
-Create ui-design.md covering:
-1. **Component Inventory** \u2014 list every page and reusable component; for each: name, purpose, variants/states, props
-2. **Page Layouts** \u2014 describe the visual structure of each page (header, main, sidebar, footer zones); include responsive behaviour
-3. **Interaction Flows** \u2014 key user flows with step-by-step state transitions (loading \u2192 success \u2192 error)
-4. **Design Tokens** \u2014 color palette (primary, neutral, semantic), typography scale, spacing scale
-5. **Accessibility** \u2014 ARIA roles/labels for interactive components, keyboard nav, focus order
+Verify the implementation code in the current directory:
+1. Read all source code to understand the implementation
+2. Write and execute tests for each core feature
+3. Output results to test-report.md containing:
+   - Overall verdict (PASS / FAIL / BLOCKED)
+   - Test result for each feature
+   - Reproduction steps and evidence for failures
 
-Be concrete. Reference API endpoints where components bind to data. Flag any UX decision that needs product clarification.`;
-function uiDesigner(overrides) {
+Start immediately. Verify actual behavior \u2014 do not just review code.`;
+function tester(overrides) {
   return {
-    id: "ui-designer",
-    name: "UI Designer",
-    icon: "\u25A3",
-    models: { claude: "sonnet" },
-    systemPrompt: SYSTEM9,
-    taskPrompt: TASK9,
-    tools: ["Read", "Write"],
+    id: "tester",
+    name: "Tester",
+    icon: "\u2299",
+    description: "verifies the behaviour",
+    runtime: "acp",
+    models: { acp: "sonnet" },
+    modelTier: "balanced",
+    systemPrompt: SYSTEM10,
+    taskPrompt: TASK10,
+    tools: ["Read", "Write", "Bash"],
     ...overrides
   };
 }
 
 // src/agents/ui-design-reviewer.ts
-var SYSTEM10 = `You are a UI/UX design reviewer. Your job is to evaluate a UI design specification before implementation begins.
+var SYSTEM11 = `You are a UI/UX design reviewer. Your job is to evaluate a UI design specification before implementation begins.
 
 Responsibilities:
 - Review the design specification for completeness, consistency, and feasibility
@@ -907,11 +553,12 @@ Deliverables (save to the working directory):
 - ui-review.md \u2014 verdict (Approved / Changes Required), issue list (blocking / advisory) with component names and fix directions
 
 Principles: Be specific \u2014 reference component names or section titles in ui-design.md. A blocking issue must include what is missing or wrong and a fix direction. If the design is thorough and implementable, say so directly.`;
-var TASK10 = `## Requirement
+var TASK11 = `## Requirement
 {{requirement}}
 
 ## UI Design Specification
 {{file:ui-design.md}}
+{{upstreamOutputs}}
 
 ## Task
 Review the UI design specification above and output ui-review.md:
@@ -929,57 +576,10 @@ function uiDesignReviewer(overrides) {
     id: "ui-design-reviewer",
     name: "UI Design Reviewer",
     icon: "\u25CE",
-    models: { claude: "haiku" },
-    systemPrompt: SYSTEM10,
-    taskPrompt: TASK10,
-    tools: ["Read", "Write"],
-    ...overrides
-  };
-}
-
-// src/agents/code-reviewer.ts
-var SYSTEM11 = `You are a code review expert focused on implementation quality, correctness, and security.
-
-Responsibilities:
-- Read the requirement, architecture design, and all implementation code
-- Verify the implementation matches the API specification and satisfies the requirement
-- Identify bugs, security vulnerabilities, error handling gaps, and test coverage issues
-- Assess code quality: readability, naming, separation of concerns, duplication
-- Do not run code, do not modify code \u2014 provide written judgment only
-
-Deliverables (save to the working directory):
-- code-review.md \u2014 score (1\u201310), blocking issues, advisory issues, conclusion (Approved / Changes Required)
-
-Principles: Judge the code, not the developer. A blocking issue must include the file path, the specific problem, and a fix direction. Advisory items should be actionable, not vague. If the code is solid, say so.`;
-var TASK11 = `## Project
-{{projectName}}
-
-## Requirement
-{{requirement}}
-
-## Architecture Design
-{{file:architecture.md}}
-
-## API Specification
-{{file:api-spec.md}}
-
-## Task
-Perform a thorough code review of all implementation in the current directory and output code-review.md:
-1. Overall score (1\u201310) and verdict: Approved / Changes Required
-2. Blocking issues (bugs, security holes, missing requirement coverage, broken tests):
-   - file path + line range, problem description, fix direction
-3. Advisory issues (code quality, naming, duplication, missing error handling):
-   - file path, observation, suggestion
-4. Test coverage assessment
-5. Final summary (2\u20133 sentences)
-
-Start by reading implementation-notes.md (if present), then read source and test files.`;
-function codeReviewer(overrides) {
-  return {
-    id: "code-reviewer",
-    name: "Code Reviewer",
-    icon: "\u2297",
-    models: { claude: "haiku" },
+    description: "reviews the UI design",
+    runtime: "acp",
+    models: { acp: "haiku" },
+    modelTier: "fast",
     systemPrompt: SYSTEM11,
     taskPrompt: TASK11,
     tools: ["Read", "Write"],
@@ -987,54 +587,60 @@ function codeReviewer(overrides) {
   };
 }
 
-// src/agents/devops.ts
-var SYSTEM12 = `You are the DevOps engineer. Your job is to containerize the application, set up CI/CD pipelines, and produce deployment-ready infrastructure configuration.
+// src/agents/ui-designer.ts
+var SYSTEM12 = `You are a UI/UX designer. Your job is to translate architecture and requirements into a detailed, developer-ready UI design specification.
 
 Responsibilities:
-- Read the architecture design and implementation to understand the application structure
-- Write a Dockerfile (and docker-compose.yml if multiple services are involved)
-- Create a CI/CD pipeline configuration (GitHub Actions, GitLab CI, or similar based on the architecture)
-- Write any environment configuration templates (.env.example)
-- Document the deployment procedure and environment requirements
-- Do not modify application source code
+- Define the component inventory: every page, section, and reusable component
+- Specify layouts, spacing principles, and responsive breakpoints
+- Define interaction patterns: loading states, empty states, error states, transitions
+- Specify design tokens: color palette, typography scale, spacing scale, shadow levels
+- Describe accessibility requirements: ARIA roles, keyboard navigation, focus management
+- Do not write implementation code \u2014 produce specification documents only
 
 Deliverables (save to the working directory):
-- Dockerfile \u2014 production-ready container image definition
-- docker-compose.yml \u2014 local development / staging orchestration (if multiple services)
-- .github/workflows/ci.yml (or equivalent) \u2014 CI pipeline: build, test, lint
-- .env.example \u2014 required environment variables with descriptions
-- devops-notes.md \u2014 deployment procedure, environment requirements, known limitations
+- ui-design.md \u2014 full UI design specification: component inventory, page layouts, interaction flows, design tokens, accessibility requirements
 
-Principles: Follow security best practices (non-root user, minimal base image, no secrets in image). Make CI fail fast. Document every non-obvious decision in devops-notes.md.`;
+Principles: Be specific enough that a developer can implement without guessing. Every component gets a name, purpose, props/variants, and states. Flag anything that depends on backend data.`;
 var TASK12 = `## Task Scope
-{{file:task-plan.json}}
+{{agentScope}}
 
-Find the entry where id == "devops" and treat its scope as the primary guide for your work.
-If task-plan.json is not found, determine your scope from the architecture design below.
+## Plan
+{{agentPlan}}
+{{upstreamOutputs}}
 
 ---
 
 ## Project
 {{projectName}}
 
+## Requirement
+{{requirement}}
+
 ## Architecture Design
 {{file:architecture.md}}
 
+## API Specification
+{{file:api-spec.md}}
+
 ## Task
-Set up the deployment infrastructure for this project:
-1. Write Dockerfile \u2014 multi-stage build if appropriate, non-root user, minimal image
-2. Write docker-compose.yml \u2014 include all services from architecture.md (app, database, cache, etc.)
-3. Write CI pipeline \u2014 build \u2192 lint \u2192 test \u2192 (optional) build image; fail fast
-4. Write .env.example \u2014 all required environment variables with placeholder values and descriptions
-5. Write devops-notes.md \u2014 how to build, run locally, deploy to production; environment requirements; known limitations
+Create ui-design.md covering:
+1. **Component Inventory** \u2014 list every page and reusable component; for each: name, purpose, variants/states, props
+2. **Page Layouts** \u2014 describe the visual structure of each page (header, main, sidebar, footer zones); include responsive behaviour
+3. **Interaction Flows** \u2014 key user flows with step-by-step state transitions (loading \u2192 success \u2192 error)
+4. **Design Tokens** \u2014 color palette (primary, neutral, semantic), typography scale, spacing scale
+5. **Accessibility** \u2014 ARIA roles/labels for interactive components, keyboard nav, focus order
 
-Start by reading implementation-notes.md (if present) to understand what commands are used for build and test.`;
-function devops(overrides) {
+Be concrete. Reference API endpoints where components bind to data. Flag any UX decision that needs product clarification.`;
+function uiDesigner(overrides) {
   return {
-    id: "devops",
-    name: "DevOps",
-    icon: "\u25B6",
-    models: { claude: "sonnet" },
+    id: "ui-designer",
+    name: "UI Designer",
+    icon: "\u25A3",
+    description: "specs the interface",
+    runtime: "acp",
+    models: { acp: "sonnet" },
+    modelTier: "balanced",
     systemPrompt: SYSTEM12,
     taskPrompt: TASK12,
     tools: ["Read", "Write"],
@@ -1057,13 +663,1803 @@ var agents = {
   codeReviewer,
   devops
 };
+
+// src/config/defineConfig.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/event/EventBus.ts
+var EventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.error("EventBus listener error:", err);
+      }
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/orchestrator/Orchestrator.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+
+// src/providers/catalog.ts
+import * as path from "path";
+function normalizeCommandKey(command) {
+  return path.basename(command).toLowerCase().replace(/\.(cmd|exe|bat)$/i, "");
+}
+var PROVIDERS = [
+  {
+    id: "opencode",
+    label: "OpenCode",
+    command: "opencode",
+    args: ["acp"],
+    tools: false,
+    modelSelection: "config-option",
+    models: [
+      { id: "opencode/big-pickle", label: "Big Pickle", tier: "balanced", defaultForTier: true },
+      { id: "opencode/exo-free", label: "Exo", tier: "strong", defaultForTier: true },
+      { id: "opencode/ling-3.0-flash-fin-free", label: "Ling 3.0 Flash", tier: "fast" },
+      {
+        id: "opencode/ling-3.1-flash-free",
+        label: "Ling 3.1 Flash",
+        tier: "fast",
+        defaultForTier: true
+      },
+      { id: "opencode/longcat-2.5-preview-free", label: "Longcat 2.5 Preview", tier: "balanced" },
+      { id: "opencode/mimo-v2.6-flash-free", label: "Mimo 2.6 Flash", tier: "fast" },
+      { id: "opencode/muse-spark-1.3-contributor-free", label: "Muse Spark 1.3", tier: "fast" },
+      { id: "opencode/nemotron-3-ultra-free", label: "Nemotron 3 Ultra", tier: "strong" },
+      { id: "opencode/nemotron-3.5-lightning-free", label: "Nemotron 3.5 Lightning", tier: "fast" },
+      { id: "opencode/space-bunny-free", label: "Space Bunny", tier: "fast" },
+      { id: "opencode/step-5-preview-free", label: "Step 5 Preview", tier: "strong" }
+    ],
+    defaultModel: "opencode/big-pickle",
+    install: { hint: "npm install -g opencode" },
+    auth: { kind: "none", hint: "" }
+  },
+  {
+    id: "claude",
+    label: "Claude",
+    command: "claude-agent-acp",
+    args: [],
+    tools: true,
+    modelSelection: "config-option",
+    meta: (task) => {
+      const meta = {};
+      if (task.systemPrompt) meta.systemPrompt = task.systemPrompt;
+      meta.claudeCode = { options: { tools: task.tools } };
+      return meta;
+    },
+    models: [
+      { id: "default", label: "Default", tier: "balanced" },
+      { id: "opus", label: "Opus", tier: "strong", defaultForTier: true },
+      { id: "fable", label: "Fable", tier: "balanced" },
+      { id: "sonnet", label: "Sonnet", tier: "balanced", defaultForTier: true },
+      { id: "haiku", label: "Haiku", tier: "fast", defaultForTier: true }
+    ],
+    defaultModel: "sonnet",
+    install: {
+      hint: "multiclaw bundles the ACP bridge \u2014 install the Claude Code CLI (`claude`) and run `claude` to log in"
+    },
+    auth: { kind: "ambient", hint: "run `claude` to log in" }
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    command: "codex-acp",
+    args: [],
+    tools: false,
+    modelSelection: "config-option",
+    meta: (task) => task.systemPrompt ? { jetbrains: { air: { customInstructions: task.systemPrompt } } } : void 0,
+    // Placeholders — real ids require auth to enumerate.
+    models: [
+      { id: "gpt-5-codex", label: "GPT-5 Codex", tier: "strong", defaultForTier: true },
+      { id: "gpt-5", label: "GPT-5", tier: "balanced", defaultForTier: true },
+      { id: "gpt-5-mini", label: "GPT-5 Mini", tier: "fast", defaultForTier: true }
+    ],
+    defaultModel: "gpt-5",
+    install: {
+      hint: "multiclaw bundles the ACP bridge \u2014 install the Codex CLI (`codex`) and run `codex login`"
+    },
+    auth: { kind: "api-key", hint: "set OPENAI_API_KEY or run `codex login`" }
+  },
+  {
+    id: "cursor",
+    label: "Cursor",
+    command: "cursor-agent",
+    aliases: ["agent"],
+    args: ["acp"],
+    tools: false,
+    modelSelection: "config-option",
+    // _meta support unverified — falls back to prompt prefix until confirmed.
+    meta: void 0,
+    // Placeholders — real ids require Cursor CLI + auth to enumerate.
+    models: [
+      { id: "cursor-pro", label: "Cursor Pro", tier: "strong", defaultForTier: true },
+      { id: "cursor-fast", label: "Cursor Fast", tier: "fast", defaultForTier: true }
+    ],
+    defaultModel: "cursor-pro",
+    install: {
+      hint: "curl https://cursor.com/install | bash",
+      url: "https://cursor.com/docs/cli/acp"
+    },
+    auth: { kind: "login", hint: "run `agent login` first (or set CURSOR_API_KEY)" },
+    confirm: (v) => /cursor/i.test(v)
+  }
+];
+var byProviderId = /* @__PURE__ */ new Map();
+var byCommand = /* @__PURE__ */ new Map();
+for (const spec of PROVIDERS) {
+  byProviderId.set(spec.id, spec);
+  byCommand.set(normalizeCommandKey(spec.command), spec);
+  if (spec.aliases) {
+    for (const alias of spec.aliases) {
+      byCommand.set(normalizeCommandKey(alias), spec);
+    }
+  }
+}
+function specForProvider(id) {
+  return byProviderId.get(id);
+}
+function specForCommand(command) {
+  return byCommand.get(normalizeCommandKey(command));
+}
+function providerIds() {
+  return [...byProviderId.keys()];
+}
+function providerCommands() {
+  return [...byCommand.keys()];
+}
+function tierModel(spec, tier) {
+  const m = spec.models.find((m2) => m2.tier === tier && m2.defaultForTier);
+  return m?.id ?? spec.models.find((m2) => m2.tier === tier)?.id;
+}
+
+// src/providers/resolve.ts
+var DEFAULT_COMMAND = "opencode";
+var DEFAULT_PROVIDER = "opencode";
+function resolveProvider(agent, config) {
+  return agent.provider ?? specForCommand(agent.command ?? "")?.id ?? config.defaults?.provider ?? specForCommand(DEFAULT_COMMAND)?.id ?? DEFAULT_PROVIDER;
+}
+function resolveCommand(agent, config) {
+  return agent.command ?? config.defaults?.command ?? specForProvider(resolveProvider(agent, config))?.command ?? DEFAULT_COMMAND;
+}
+function resolveArgs(agent, config) {
+  if (agent.args) return agent.args;
+  const command = agent.command ?? config.defaults?.command;
+  if (command) return specForCommand(command)?.args;
+  return specForProvider(resolveProvider(agent, config))?.args;
+}
+function resolveModel(agent, config) {
+  if (agent.model) return agent.model;
+  const provider = resolveProvider(agent, config);
+  const spec = specForProvider(provider);
+  const fromModels = agent.models?.[provider] ?? agent.models?.acp;
+  if (fromModels) return fromModels;
+  if (agent.modelTier && spec) {
+    const fromTier = tierModel(spec, agent.modelTier);
+    if (fromTier) return fromTier;
+  }
+  if (config.defaults?.model) return config.defaults.model;
+  if (spec) return spec.defaultModel;
+  return void 0;
+}
+function resolveAgentRuntime(agent, config) {
+  const provider = resolveProvider(agent, config);
+  const spec = specForProvider(provider);
+  return {
+    provider,
+    command: resolveCommand(agent, config),
+    model: resolveModel(agent, config),
+    spec
+  };
+}
+
+// src/utils/conversation.ts
+var MAX_CONVERSATION_TURNS = 6;
+var MAX_CONVERSATION_CHARS = 4e3;
+var MAX_ENTRY_CHARS = 600;
+var ELLIPSIS = "\u2026";
+function clip(text, max) {
+  const trimmed = text.trim();
+  if (trimmed.length <= max) return trimmed;
+  return `${trimmed.slice(0, Math.max(0, max - 1)).trimEnd()}${ELLIPSIS}`;
+}
+function entry(turn, index) {
+  const lines = [`${index}. user: ${clip(turn.requirement, MAX_ENTRY_CHARS)}`];
+  if (turn.reply) {
+    const verb = turn.reply.mode === "ask" ? "asked" : "answered";
+    lines.push(`   you ${verb}: ${clip(turn.reply.message, MAX_ENTRY_CHARS)}`);
+  }
+  return lines.join("\n");
+}
+function renderConversation(history) {
+  if (!history || history.length === 0) return "";
+  const recent = history.slice(-MAX_CONVERSATION_TURNS);
+  const first = history.length - recent.length;
+  const entries = recent.map((turn, i) => entry(turn, first + i + 1));
+  while (entries.length > 1 && entries.join("\n").length > MAX_CONVERSATION_CHARS) {
+    entries.shift();
+  }
+  const body = clip(entries.join("\n"), MAX_CONVERSATION_CHARS);
+  return `
+## Conversation so far
+
+Earlier turns of this session, oldest first:
+
+${body}
+`;
+}
+
+// src/utils/json.ts
+function extractJsonObjects(text) {
+  const objects = [];
+  let searchFrom = 0;
+  while (searchFrom < text.length) {
+    const start = text.indexOf("{", searchFrom);
+    if (start === -1) break;
+    const end = findMatchingBrace(text, start);
+    if (end !== -1) {
+      try {
+        objects.push(JSON.parse(text.slice(start, end + 1)));
+        searchFrom = end + 1;
+        continue;
+      } catch {
+      }
+    }
+    searchFrom = start + 1;
+  }
+  return objects;
+}
+function findMatchingBrace(text, start) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+// src/utils/leaderDecision.ts
+function parseLeaderDecision(text) {
+  for (const value of extractJsonObjects(text)) {
+    const decision = asDecision(value);
+    if (decision) return decision;
+  }
+  return void 0;
+}
+function asDecision(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  const mode = record.mode;
+  if (mode === "reply" || mode === "ask") {
+    const message = typeof record.message === "string" ? record.message.trim() : "";
+    return message ? { mode, message } : void 0;
+  }
+  if (mode === "run" || mode === void 0) {
+    const run = record.run;
+    if (!Array.isArray(run) || !run.every((id) => typeof id === "string")) return void 0;
+    const reason = typeof record.reason === "string" ? record.reason.trim() : "";
+    return reason ? { mode: "run", run, reason } : { mode: "run", run };
+  }
+  return void 0;
+}
+
+// src/utils/upstream.ts
+var MAX_UPSTREAM_ENTRY_CHARS = 600;
+var MAX_UPSTREAM_CHARS = 4e3;
+var ELLIPSIS2 = "\u2026";
+var HEADER = "\n## What upstream produced\n\n";
+var TRAILER = "\n";
+function block(entries) {
+  return `${HEADER}${entries.join("\n")}${TRAILER}`;
+}
+function compact(text, max) {
+  const trimmed = text.trim();
+  if (trimmed.length <= max) return trimmed;
+  const marker = (count) => `${ELLIPSIS2} (${count} characters elided) ${ELLIPSIS2}`;
+  const reserved = marker(trimmed.length).length;
+  const keep = Math.max(0, max - reserved);
+  const head = Math.ceil(keep / 2);
+  const tail = keep - head;
+  const elided = trimmed.length - keep;
+  return `${trimmed.slice(0, head)}${marker(elided)}${trimmed.slice(trimmed.length - tail)}`;
+}
+function entry2(output) {
+  const label = `- ${output.name} (${output.agentId}):
+  `;
+  const budget = MAX_UPSTREAM_ENTRY_CHARS - label.length;
+  let body = compact(output.output, budget);
+  const newlines = body.length - body.replace(/\n/g, "").length;
+  if (label.length + body.length + 2 * newlines > MAX_UPSTREAM_ENTRY_CHARS) {
+    body = compact(output.output, budget - 2 * newlines);
+  }
+  return `${label}${body.replace(/\n/g, "\n  ")}`;
+}
+function renderUpstreamOutputs(outputs) {
+  if (outputs.length === 0) return "";
+  const entries = outputs.map(entry2);
+  while (entries.length > 1 && block(entries).length > MAX_UPSTREAM_CHARS) {
+    entries.shift();
+  }
+  return block(entries);
+}
+
+// src/orchestrator/AgentRunner.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+
+// src/runtime/AcpRuntime.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { Readable, Writable } from "stream";
+import { StringDecoder } from "string_decoder";
+
+// src/providers/bridge.ts
+import * as fs from "fs";
+import { createRequire } from "module";
+import * as path2 from "path";
+var BRIDGE_PACKAGES = {
+  "claude-agent-acp": "@agentclientprotocol/claude-agent-acp",
+  "codex-acp": "@agentclientprotocol/codex-acp"
+};
+function resolvesOnPath(command) {
+  const dirs = (process.env.PATH ?? "").split(path2.delimiter).filter(Boolean);
+  const exts = (process.env.PATHEXT ?? "").split(";").filter(Boolean);
+  const suffixes = exts.length > 0 ? exts : [""];
+  for (const dir of dirs) {
+    for (const ext of suffixes) {
+      try {
+        fs.accessSync(path2.join(dir, command + ext), fs.constants.X_OK);
+        return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function resolveBridgeBinary(command) {
+  const pkg = BRIDGE_PACKAGES[command];
+  if (!pkg) return null;
+  try {
+    const req = createRequire(import.meta.url);
+    const pkgJsonPath = req.resolve(`${pkg}/package.json`);
+    const bin = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8")).bin;
+    const binRel = typeof bin === "string" ? bin : bin?.[command] ?? Object.values(bin)[0];
+    if (!binRel) return null;
+    return path2.join(path2.dirname(pkgJsonPath), binRel);
+  } catch {
+    return null;
+  }
+}
+function resolveExecutable(command) {
+  if (resolvesOnPath(command)) return command;
+  return resolveBridgeBinary(command);
+}
+
+// src/utils/abort.ts
+var ABORT_ERROR_NAME = "AbortError";
+function abortError(message = "Operation aborted") {
+  const err = new Error(message);
+  err.name = ABORT_ERROR_NAME;
+  return err;
+}
+function isAbortError(err) {
+  return err instanceof Error && err.name === ABORT_ERROR_NAME;
+}
+
+// src/utils/errors.ts
+var PermanentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PermanentError";
+  }
+};
+function isPermanent(err) {
+  return err instanceof PermanentError;
+}
+
+// src/runtime/RuntimeBase.ts
+var RuntimeBase = class {
+};
+
+// src/runtime/AcpRuntime.ts
+var discoveredModels = /* @__PURE__ */ new Map();
+var KILL_ESCALATION_MS = 3e3;
+var CANCEL_GRACE_MS = 2e3;
+var DEFAULT_COMMAND2 = "opencode";
+var DEFAULT_ARGS = ["acp"];
+var BASE_CAPABILITIES = {
+  streaming: true,
+  sessions: true,
+  resume: true,
+  permissions: true,
+  tools: true,
+  models: false,
+  images: false,
+  usage: true,
+  cost: true,
+  sandbox: false
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textOf(content) {
+  if (isRecord(content) && content.type === "text" && typeof content.text === "string") {
+    return content.text;
+  }
+  return void 0;
+}
+function stringifyOutput(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0 || value === null) return "";
+  return JSON.stringify(value);
+}
+function mapStopReason(reason) {
+  switch (reason) {
+    case "end_turn":
+      return "success";
+    case "cancelled":
+      return "cancelled";
+    case "max_tokens":
+    case "max_turn_requests":
+      return "max_turns";
+    default:
+      return "error";
+  }
+}
+var KIND_TO_TOOLS = {
+  read: ["Read"],
+  edit: ["Edit", "Write"],
+  execute: ["Bash"],
+  search: ["Grep", "Glob"],
+  fetch: ["WebFetch"]
+};
+function decidePermission(params, tools, sessionId) {
+  if (sessionId !== void 0 && params.sessionId !== sessionId) {
+    return { response: { outcome: { outcome: "cancelled" } } };
+  }
+  const allowed = new Set(tools.map((tool) => tool.toLowerCase()));
+  const name = params.toolCall.name ?? void 0;
+  const kind = params.toolCall.kind ?? void 0;
+  const approved = name !== void 0 ? allowed.has(name.toLowerCase()) : (KIND_TO_TOOLS[kind ?? ""] ?? []).some((candidate) => allowed.has(candidate.toLowerCase()));
+  const option = approved ? params.options.find((o) => o.kind === "allow_always") ?? params.options.find((o) => o.kind === "allow_once") : params.options.find((o) => o.kind === "reject_always") ?? params.options.find((o) => o.kind === "reject_once");
+  const response = option ? { outcome: { outcome: "selected", optionId: option.optionId } } : { outcome: { outcome: "cancelled" } };
+  if (approved) return { response };
+  return {
+    response,
+    rejected: {
+      toolCallId: params.toolCall.toolCallId,
+      name,
+      kind,
+      title: params.toolCall.title ?? void 0
+    }
+  };
+}
+function withAuthHint(acp, err) {
+  const error = err instanceof Error ? err : new Error(String(err));
+  if (error instanceof acp.RequestError && error.code === acp.RequestError.authRequired().code) {
+    return new Error(`${error.message} \u2014 run \`claude\` to log in`);
+  }
+  return error;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var AcpRuntime = class extends RuntimeBase {
+  constructor() {
+    super(...arguments);
+    this.name = "acp";
+  }
+  async describe(options) {
+    const command = options?.command ?? DEFAULT_COMMAND2;
+    return {
+      name: this.name,
+      available: resolveExecutable(command) !== null,
+      // `tools` is the one capability that depends on the bridge: only some of
+      // them read an allowlist out of `_meta`, and none negotiates it. Claiming
+      // it for a bridge that ignores `task.tools` would let a caller believe a
+      // restriction landed when the agent is running unrestricted.
+      capabilities: {
+        ...BASE_CAPABILITIES,
+        tools: specForCommand(command)?.tools ?? false,
+        models: specForCommand(command)?.modelSelection === "config-option"
+      }
+    };
+  }
+  async execute(task) {
+    const acp = await import("@agentclientprotocol/sdk");
+    const command = task.command ?? DEFAULT_COMMAND2;
+    const args = task.args ?? DEFAULT_ARGS;
+    const exe = resolveExecutable(command) ?? command;
+    const spec = specForCommand(command);
+    const meta = spec?.meta?.(task);
+    const promptText = meta === void 0 && task.systemPrompt ? `${task.systemPrompt}
+
+---
+
+${task.prompt}` : task.prompt;
+    return new Promise((resolve4, reject) => {
+      const child = spawn(exe, args, {
+        cwd: task.workDir,
+        env: process.env,
+        // Own process group, so a kill reaches whatever the agent spawned too.
+        detached: true
+      });
+      const signalChild = (signal) => {
+        try {
+          child.kill(signal);
+        } catch {
+        }
+      };
+      const killTree = (signal) => {
+        if (child.pid === void 0) {
+          signalChild(signal);
+          return;
+        }
+        try {
+          process.kill(-child.pid, signal);
+        } catch {
+          signalChild(signal);
+        }
+      };
+      let stopped = false;
+      let escalation;
+      const stop = (signal) => {
+        if (stopped) return;
+        stopped = true;
+        killTree(signal);
+        escalation = setTimeout(() => killTree("SIGKILL"), KILL_ESCALATION_MS);
+        escalation.unref();
+      };
+      let timedOut = false;
+      const timer = task.timeout === void 0 ? void 0 : setTimeout(() => {
+        timedOut = true;
+        stop("SIGTERM");
+      }, task.timeout);
+      let cancelGrace;
+      const clearTimers = () => {
+        if (timer) clearTimeout(timer);
+        if (escalation) clearTimeout(escalation);
+        if (cancelGrace) clearTimeout(cancelGrace);
+      };
+      const runId = randomUUID();
+      let seq = 0;
+      const emit = (event) => {
+        task.onEvent?.({ ...event, runId, agentId: task.agentId, seq: seq++ });
+      };
+      const warn = (message) => {
+        if (task.onWarning) {
+          task.onWarning(message);
+          return;
+        }
+        process.stderr.write(`[multiclaw] Warning: ${message}
+`);
+      };
+      let sessionId;
+      let agentText = "";
+      let errorOutput = "";
+      let connectionError;
+      let settled = false;
+      let lastUsage;
+      let lastCost;
+      const settleResolve = (output) => {
+        if (settled) return;
+        settled = true;
+        clearTimers();
+        resolve4(output);
+      };
+      const settleReject = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimers();
+        reject(error);
+      };
+      const handleUpdate = (notification) => {
+        if (sessionId && notification.sessionId !== sessionId) return;
+        const update = notification.update;
+        switch (update.sessionUpdate) {
+          case "agent_message_chunk": {
+            const text = textOf(update.content);
+            if (text === void 0) {
+              emit({ type: "raw", vendor: "acp", payload: update });
+              break;
+            }
+            agentText += text;
+            emit({ type: "message_delta", role: "agent", text });
+            break;
+          }
+          case "user_message_chunk": {
+            const text = textOf(update.content);
+            if (text === void 0) {
+              emit({ type: "raw", vendor: "acp", payload: update });
+              break;
+            }
+            emit({ type: "message_delta", role: "user", text });
+            break;
+          }
+          case "agent_thought_chunk": {
+            const text = textOf(update.content);
+            if (text === void 0) {
+              emit({ type: "raw", vendor: "acp", payload: update });
+              break;
+            }
+            emit({ type: "message_delta", role: "thought", text });
+            break;
+          }
+          case "tool_call": {
+            emit({
+              type: "tool_call",
+              id: update.toolCallId,
+              name: update.name ?? update.title,
+              input: update.rawInput
+            });
+            break;
+          }
+          case "tool_call_update": {
+            emit({
+              type: "tool_result",
+              id: update.toolCallId,
+              output: stringifyOutput(update.rawOutput ?? update.content),
+              isError: update.status === "failed"
+            });
+            break;
+          }
+          case "plan": {
+            emit({ type: "plan", entries: update.entries.map((entry3) => entry3.content) });
+            break;
+          }
+          case "usage_update": {
+            const contextTokens = typeof update.used === "number" ? update.used : void 0;
+            const contextSize = typeof update.size === "number" ? update.size : void 0;
+            if (contextTokens !== void 0 && contextSize !== void 0) {
+              lastUsage = { contextTokens, contextSize };
+              emit({ type: "usage", contextTokens, contextSize });
+            }
+            const cost = isRecord(update.cost) ? update.cost : void 0;
+            const amount = typeof cost?.amount === "number" ? cost.amount : void 0;
+            const currency = typeof cost?.currency === "string" ? cost.currency : void 0;
+            if (amount !== void 0 && currency !== void 0) {
+              lastCost = { amount, currency };
+              const costUsd = currency.toLowerCase() === "usd" ? amount : void 0;
+              emit({
+                type: "cost",
+                amount,
+                currency,
+                ...costUsd !== void 0 ? { costUsd } : {}
+              });
+            }
+            break;
+          }
+          default:
+            emit({ type: "raw", vendor: "acp", payload: update });
+        }
+      };
+      const app = acp.client({ name: "multiclaw" });
+      app.onNotification(acp.methods.client.session.update, (nctx) => {
+        handleUpdate(nctx.params);
+      });
+      app.onRequest(acp.methods.client.session.requestPermission, (rctx) => {
+        const { response, rejected } = decidePermission(rctx.params, task.tools, sessionId);
+        if (rejected) {
+          emit({
+            type: "raw",
+            vendor: "acp",
+            payload: { type: "permission_rejected", ...rejected }
+          });
+        }
+        return response;
+      });
+      const stderrDecoder = new StringDecoder("utf8");
+      child.stderr.on("data", (d) => {
+        errorOutput += stderrDecoder.write(d);
+      });
+      const stream = acp.ndJsonStream(
+        Writable.toWeb(child.stdin),
+        Readable.toWeb(child.stdout)
+      );
+      const connection = app.connect(stream);
+      const ctx = connection.agent;
+      const teardown = () => {
+        try {
+          connection.close();
+        } catch {
+        }
+        stop("SIGTERM");
+      };
+      task.signal?.addEventListener(
+        "abort",
+        () => {
+          if (sessionId) {
+            void ctx.notify(acp.methods.agent.session.cancel, { sessionId }).catch(() => {
+            });
+          }
+          cancelGrace = setTimeout(() => stop("SIGTERM"), CANCEL_GRACE_MS);
+          cancelGrace.unref();
+        },
+        { once: true }
+      );
+      child.on("close", (code) => {
+        errorOutput += stderrDecoder.end();
+        if (settled) return;
+        if (task.signal?.aborted) {
+          settleReject(abortError());
+          return;
+        }
+        if (timedOut) {
+          settleReject(new Error(`acp timed out (${task.timeout}ms)`));
+          return;
+        }
+        if (connectionError) {
+          settleReject(connectionError);
+          return;
+        }
+        settleReject(new Error(`${command} exited with code ${code}: ${errorOutput}`));
+      });
+      child.on("error", (err) => {
+        settleReject(new PermanentError(`Failed to start ${command}: ${err.message}`));
+      });
+      const run = async () => {
+        const init = await ctx.request(acp.methods.agent.initialize, {
+          protocolVersion: acp.PROTOCOL_VERSION
+        });
+        emit({ type: "run_started", model: task.model });
+        if (task.sessionId) {
+          if (init.agentCapabilities?.loadSession !== true) {
+            throw new PermanentError(
+              `Agent does not support session/load (loadSession=false); cannot resume session ${task.sessionId}`
+            );
+          }
+          await ctx.request(acp.methods.agent.session.load, {
+            sessionId: task.sessionId,
+            cwd: task.workDir,
+            mcpServers: [],
+            // Both session-defining requests carry `_meta`: the bridge's own
+            // session fingerprint includes it, so a changed prompt rebuilds the
+            // session on resume.
+            ...meta ? { _meta: meta } : {}
+          });
+          sessionId = task.sessionId;
+        } else {
+          const created = await ctx.request(acp.methods.agent.session.new, {
+            cwd: task.workDir,
+            mcpServers: [],
+            ...meta ? { _meta: meta } : {}
+          });
+          sessionId = created.sessionId;
+          const modelOpt = created.configOptions?.find(
+            (o) => o.category === "model" || o.id === "model"
+          );
+          if (modelOpt && "options" in modelOpt && Array.isArray(modelOpt.options)) {
+            const ids = (modelOpt.options ?? []).map(
+              (o) => o.value ?? String(o)
+            );
+            discoveredModels.set(command, ids);
+          }
+        }
+        if (task.model && spec?.modelSelection === "config-option" && sessionId) {
+          const known = discoveredModels.get(command);
+          if (known && !known.includes(task.model)) {
+            warn(
+              `model "${task.model}" is not offered by ${command}; running with the provider's default.`
+            );
+          } else {
+            try {
+              await ctx.request(acp.methods.agent.session.setConfigOption, {
+                sessionId,
+                configId: "model",
+                value: task.model
+              });
+            } catch (err) {
+              warn(
+                `Could not set model "${task.model}" on ${command}; running with the provider's default (${errorMessage(err)}).`
+              );
+            }
+          }
+        }
+        const response = await ctx.request(acp.methods.agent.session.prompt, {
+          sessionId,
+          prompt: [{ type: "text", text: promptText }]
+        });
+        if (task.signal?.aborted) {
+          settleReject(abortError());
+          teardown();
+          return;
+        }
+        const stopReason = mapStopReason(response.stopReason);
+        emit({ type: "run_finished", stopReason });
+        settleResolve({
+          output: agentText,
+          exitCode: 0,
+          sessionId,
+          stopReason,
+          ...lastUsage ? { usage: lastUsage } : {},
+          ...lastCost?.currency.toLowerCase() === "usd" ? { costUsd: lastCost.amount } : {}
+        });
+        teardown();
+      };
+      void run().catch((err) => {
+        connectionError = withAuthHint(acp, err);
+        settleReject(connectionError);
+        teardown();
+      });
+    });
+  }
+};
+
+// src/runtime/index.ts
+var RuntimeRegistry = class {
+  constructor() {
+    this.runtimes = /* @__PURE__ */ new Map();
+    this.register(new AcpRuntime());
+  }
+  register(r) {
+    this.runtimes.set(r.name, r);
+  }
+  get(name) {
+    const r = this.runtimes.get(name);
+    if (!r)
+      throw new Error(
+        `Runtime not found: "${name}". Available: ${[...this.runtimes.keys()].join(", ")}`
+      );
+    return r;
+  }
+  has(name) {
+    return this.runtimes.has(name);
+  }
+  list() {
+    return [...this.runtimes.keys()];
+  }
+};
+var runtimeRegistry = new RuntimeRegistry();
+
+// src/utils/prompt.ts
+import * as fs2 from "fs/promises";
+import * as path3 from "path";
+function resolveInWorkspace(workDir, reference) {
+  const root = path3.resolve(workDir);
+  const resolved = path3.resolve(root, reference);
+  if (resolved !== root && !resolved.startsWith(root + path3.sep)) return void 0;
+  return resolved;
+}
+async function renderPrompt(template, context, workDir) {
+  let result = template;
+  const fileMatches = [...template.matchAll(/\{\{file:([^}]+)\}\}/g)];
+  for (const match of fileMatches) {
+    const filePath = resolveInWorkspace(workDir, match[1].trim());
+    if (!filePath) {
+      result = result.replace(match[0], () => `[file outside workspace: ${match[1].trim()}]`);
+      continue;
+    }
+    try {
+      const content = await fs2.readFile(filePath, "utf-8");
+      result = result.replace(match[0], () => content);
+    } catch {
+      result = result.replace(match[0], () => `[file not found: ${match[1]}]`);
+    }
+  }
+  for (const [key, value] of Object.entries(context)) {
+    result = result.replaceAll(`{{${key}}}`, () => value);
+  }
+  return result;
+}
+
+// src/utils/retry.ts
+var DEFAULT_RETRY_DELAY_MS = 2e3;
+function sleep(ms, signal) {
+  if (signal?.aborted) return Promise.reject(abortError());
+  return new Promise((resolve4, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError());
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve4();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function withRetry(fn, retries, onRetry, delayMs = DEFAULT_RETRY_DELAY_MS, signal, shouldRetry) {
+  let lastError = new Error("Unknown error");
+  for (let attempt = 1; attempt <= retries + 1; attempt++) {
+    if (signal?.aborted) throw abortError();
+    try {
+      return await fn(attempt);
+    } catch (err) {
+      lastError = err;
+      if (signal?.aborted) throw lastError;
+      if (shouldRetry && !shouldRetry(err, attempt)) throw lastError;
+      if (attempt <= retries) {
+        onRetry?.(attempt, err);
+        await sleep(delayMs * attempt, signal);
+      }
+    }
+  }
+  throw lastError;
+}
+function retryBudgetMs(perAttemptMs, retries, delayMs = DEFAULT_RETRY_DELAY_MS) {
+  return perAttemptMs * (retries + 1) + delayMs * retries * (retries + 1) / 2;
+}
+
+// src/utils/timeout.ts
+function withTimeout(factory, ms, label, signal) {
+  if (signal?.aborted) return Promise.reject(abortError());
+  const controller = new AbortController();
+  const forward = () => controller.abort();
+  signal?.addEventListener("abort", forward, { once: true });
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`[${label}] timed out (${ms / 1e3}s)`));
+    }, ms);
+  });
+  let onCancel;
+  const cancelled = new Promise((_, reject) => {
+    if (!signal) return;
+    onCancel = () => reject(abortError());
+    signal.addEventListener("abort", onCancel, { once: true });
+  });
+  return Promise.race([factory(controller.signal), timeout, cancelled]).finally(() => {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", forward);
+    if (onCancel) signal?.removeEventListener("abort", onCancel);
+  });
+}
+
+// src/utils/toolSummary.ts
+var MAX_SUMMARY_COLUMNS = 120;
+function stringifySafe(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0 || value === null) return "";
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return String(value);
+  }
+}
+function firstLineTruncated(value) {
+  const text = stringifySafe(value);
+  const newline = text.indexOf("\n");
+  const firstLine = newline === -1 ? text : text.slice(0, newline);
+  if (firstLine.length <= MAX_SUMMARY_COLUMNS) return firstLine;
+  return `${firstLine.slice(0, MAX_SUMMARY_COLUMNS - 1)}\u2026`;
+}
+function summarizeToolInput(input) {
+  return firstLineTruncated(input);
+}
+function summarizeToolOutput(output) {
+  return firstLineTruncated(output);
+}
+
+// src/orchestrator/AgentRunner.ts
+var AgentRunner = class {
+  constructor(eventBus, contextManager, globalWorkDir, config) {
+    this.eventBus = eventBus;
+    this.contextManager = contextManager;
+    this.globalWorkDir = globalWorkDir;
+    this.config = config;
+  }
+  async run(agent, signal) {
+    const startTime = /* @__PURE__ */ new Date();
+    const model = resolveModel(agent, this.config);
+    this.eventBus.emit({
+      type: "agent:start",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: {
+        agentId: agent.id,
+        agentName: agent.name,
+        icon: agent.icon,
+        model,
+        taskTitle: agent.taskTitle
+      }
+    });
+    let attempts = 0;
+    let output = "";
+    let usage;
+    let costUsd;
+    try {
+      const workDir = agent.workDir ? path4.resolve(this.globalWorkDir, agent.workDir) : this.globalWorkDir;
+      fs3.mkdirSync(workDir, { recursive: true });
+      const runtime = runtimeRegistry.get(agent.runtime ?? "acp");
+      const retries = agent.retries ?? 0;
+      const timeout = agent.timeout ?? 6e5;
+      const tools = agent.tools ?? ["Read", "Write", "Bash"];
+      const completed = await withTimeout(
+        (innerSignal) => withRetry(
+          async (attempt) => {
+            attempts = attempt;
+            const agentContext = {
+              ...this.contextManager.snapshot(),
+              // Every built-in task template references both. The leader only
+              // fills them in when the architect wrote a plan entry for this
+              // agent, and the no-leader path has no plan at all — so without a
+              // default the model is handed the literal text `{{agentScope}}`
+              // and has to guess what it was supposed to say.
+              agentScope: agent.agentScope ?? "Not narrowed down \u2014 cover the whole task.",
+              agentPlan: agent.agentPlan ?? "No step-by-step plan was provided \u2014 use your judgement."
+            };
+            const prompt = await renderPrompt(agent.taskPrompt, agentContext, this.globalWorkDir);
+            return await runtime.execute({
+              agentId: agent.id,
+              systemPrompt: agent.systemPrompt,
+              prompt,
+              tools,
+              workDir,
+              timeout,
+              signal: innerSignal,
+              model,
+              // Only the caller knows which session to continue; absent means a
+              // fresh one. It must stay `undefined` rather than `""` — the ACP
+              // runtime tests `if (task.sessionId)`, so an empty string would
+              // read as "load this session" for a session that does not exist.
+              sessionId: this.config.resume?.sessions?.[agent.id],
+              // Resolve through provider/defaults exactly as the CLI's
+              // availability gate does — an agent that pins `provider` (or
+              // leans on `defaults`) must launch that provider's bridge, not
+              // the runtime's built-in default. Passing the raw `agent.command`
+              // here sent a `provider: "claude"` config straight to `opencode`.
+              command: resolveCommand(agent, this.config),
+              args: resolveArgs(agent, this.config),
+              // A runtime's diagnostics travel on the event bus rather than
+              // stderr: under the TUI's alternate screen a stderr write is
+              // never seen. The agent name prefixes the line so it is
+              // locatable in the one-row status area.
+              onWarning: (message) => {
+                this.eventBus.emit({
+                  type: "orchestration:warning",
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                  payload: { message: `[${agent.name}] ${message}` }
+                });
+              },
+              onEvent: (e) => {
+                if ((e.type === "message_delta" || e.type === "message") && e.role === "agent" && e.text) {
+                  this.emitOutput(agent.id, e.text);
+                  return;
+                }
+                if (e.type === "tool_call") {
+                  const summary = summarizeToolInput(e.input);
+                  this.emitOutput(
+                    agent.id,
+                    `
+\u203A ${e.name}${summary ? ` ${summary}` : ""}
+`,
+                    "tool"
+                  );
+                  return;
+                }
+                if (e.type === "tool_result") {
+                  const summary = summarizeToolOutput(e.output);
+                  this.emitOutput(
+                    agent.id,
+                    `  ${e.isError ? "\u2717" : "\u2713"} ${summary}
+`,
+                    e.isError ? "tool" : "tool-detail"
+                  );
+                }
+              }
+            });
+          },
+          retries,
+          (attempt, err) => {
+            this.eventBus.emit({
+              type: "agent:retrying",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              payload: {
+                agentId: agent.id,
+                agentName: agent.name,
+                attempt,
+                maxAttempts: retries + 1,
+                error: err.message
+              }
+            });
+          },
+          DEFAULT_RETRY_DELAY_MS,
+          innerSignal,
+          // A permanent failure (a missing binary, an unsupported capability)
+          // will fail the same way on every attempt, so let the loop fail fast
+          // instead of burning the whole backoff budget on a doomed run.
+          (err) => !isPermanent(err)
+        ),
+        retryBudgetMs(timeout + KILL_ESCALATION_MS, retries),
+        agent.name,
+        signal
+      );
+      output = completed.output;
+      usage = completed.usage;
+      costUsd = completed.costUsd;
+      const sessionId = completed.sessionId;
+      const endTime = /* @__PURE__ */ new Date();
+      const result = {
+        agentId: agent.id,
+        agentName: agent.name,
+        status: "success",
+        output,
+        duration: endTime.getTime() - startTime.getTime(),
+        attempts,
+        startTime: startTime.toISOString(),
+        endTime: endTime.toISOString(),
+        model,
+        ...usage ? { usage } : {},
+        ...costUsd !== void 0 ? { costUsd } : {},
+        ...sessionId ? { sessionId } : {}
+      };
+      this.eventBus.emit({
+        type: "agent:complete",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: result
+      });
+      return result;
+    } catch (err) {
+      const endTime = /* @__PURE__ */ new Date();
+      const result = {
+        agentId: agent.id,
+        agentName: agent.name,
+        // An abort is a cancellation, not a failure: the team stopped because it
+        // was told to, and the roster must not paint every agent as broken.
+        status: isAbortError(err) ? "cancelled" : "failed",
+        output,
+        duration: endTime.getTime() - startTime.getTime(),
+        attempts,
+        error: err.message,
+        startTime: startTime.toISOString(),
+        endTime: endTime.toISOString(),
+        model
+      };
+      this.eventBus.emit({
+        type: "agent:failed",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: result
+      });
+      return result;
+    }
+  }
+  /**
+   * Publish one chunk of agent output.
+   *
+   * `kind` is omitted for text so the payload shape is unchanged for every
+   * consumer written before tool activity was surfaced.
+   */
+  emitOutput(agentId, chunk, kind) {
+    this.eventBus.emit({
+      type: "agent:output",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: { agentId, chunk, ...kind ? { kind } : {} }
+    });
+  }
+};
+
+// src/orchestrator/ContextManager.ts
+var ContextManager = class {
+  constructor(initial) {
+    this.store = /* @__PURE__ */ new Map();
+    if (initial) for (const [k, v] of Object.entries(initial)) this.store.set(k, v);
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  get(key) {
+    return this.store.get(key);
+  }
+  snapshot() {
+    return Object.fromEntries(this.store.entries());
+  }
+};
+
+// src/orchestrator/StageBuilder.ts
+function buildStages(agents2) {
+  const stages = [];
+  const completed = /* @__PURE__ */ new Set();
+  let remaining = [...agents2];
+  const allIds = new Set(agents2.map((a) => a.id));
+  for (const a of agents2) {
+    for (const dep of a.dependsOn ?? []) {
+      if (!allIds.has(dep)) {
+        throw new Error(`Agent "${a.id}" depends on "${dep}" which does not exist`);
+      }
+    }
+  }
+  while (remaining.length > 0) {
+    const stage = remaining.filter((a) => (a.dependsOn ?? []).every((dep) => completed.has(dep)));
+    if (stage.length === 0) {
+      const ids = remaining.map((a) => a.id).join(", ");
+      throw new Error(`Circular or unsatisfiable dependency detected: ${ids}`);
+    }
+    stages.push(stage);
+    for (const a of stage) completed.add(a.id);
+    remaining = remaining.filter((a) => !stage.includes(a));
+  }
+  return stages;
+}
+
+// src/orchestrator/Orchestrator.ts
+var Orchestrator = class {
+  constructor(config) {
+    this.config = config;
+    this.eventBus = new EventBus();
+    this.workDir = path5.resolve(config.workDir);
+    fs4.mkdirSync(this.workDir, { recursive: true });
+    this.contextManager = new ContextManager(config.context);
+    this.contextManager.set("conversation", renderConversation(config.history));
+    this.contextManager.set("upstreamOutputs", "");
+    this.runner = new AgentRunner(this.eventBus, this.contextManager, this.workDir, config);
+  }
+  async preview(options = {}) {
+    this.clearStaleTaskPlan();
+    const resolution = await this.resolveTurn(options.signal);
+    if (resolution.kind === "message") {
+      return {
+        name: this.config.name,
+        totalAgents: 0,
+        stages: [],
+        reply: { mode: resolution.mode, message: resolution.message },
+        ...this.requirementField()
+      };
+    }
+    const agents2 = resolution.agents;
+    this.contextManager.set("pipelineAgents", agents2.map((a) => `${a.id}: ${a.name}`).join("\n"));
+    const stages = this.buildStagesOrFallback(agents2, "Could not order the configured agents");
+    const stageInfos = this.stageInfos(stages);
+    return {
+      name: this.config.name,
+      totalAgents: agents2.length,
+      stages: stageInfos,
+      ...this.reasonField(resolution.reason),
+      ...this.requirementField()
+    };
+  }
+  async run(options = {}) {
+    const startTime = /* @__PURE__ */ new Date();
+    this.clearStaleTaskPlan();
+    const resolution = await this.resolveTurn(options.signal);
+    if (resolution.kind === "message") {
+      return this.finishWithMessage(resolution.mode, resolution.message, startTime);
+    }
+    const agents2 = resolution.agents;
+    if (agents2.length === 0) return this.finishEmpty(startTime);
+    this.contextManager.set("pipelineAgents", agents2.map((a) => `${a.id}: ${a.name}`).join("\n"));
+    let stages = this.buildStagesOrFallback(agents2, "Could not order the configured agents");
+    const toStageInfos = (list) => this.stageInfos(list);
+    this.eventBus.emit({
+      type: "orchestration:start",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: {
+        name: this.config.name,
+        requirement: this.config.context?.requirement,
+        totalAgents: agents2.length,
+        stages: toStageInfos(stages),
+        ...this.reasonField(resolution.reason)
+      }
+    });
+    const results = [];
+    let allSuccess = true;
+    let cancelled = false;
+    let planApplied = false;
+    for (let i = 0; i < stages.length; i++) {
+      const stage = stages[i];
+      this.eventBus.emit({
+        type: "stage:start",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: { stageIndex: i, agentIds: stage.map((a) => a.id) }
+      });
+      const stageResults = await this.runStage(stage, options.signal);
+      results.push(...stageResults);
+      this.contextManager.set(
+        "upstreamOutputs",
+        renderUpstreamOutputs(
+          results.filter((r) => r.status === "success").map((r) => ({ agentId: r.agentId, name: r.agentName, output: r.output }))
+        )
+      );
+      if (options.signal?.aborted) {
+        cancelled = true;
+        allSuccess = false;
+        break;
+      }
+      if (!planApplied && stage.some((a) => this.isPlanner(a)) && stageResults.some((r) => r.status === "success")) {
+        planApplied = true;
+        await this.applyTaskPlan(agents2);
+        stages = this.buildStagesOrFallback(
+          agents2,
+          "The task plan's dependencies could not be satisfied"
+        );
+        this.eventBus.emit({
+          type: "orchestration:stages",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          payload: { totalAgents: agents2.length, stages: toStageInfos(stages) }
+        });
+      }
+      for (const r of stageResults) {
+        if (r.status !== "success") {
+          allSuccess = false;
+          if (!this.config.continueOnError) break;
+        }
+      }
+      this.eventBus.emit({
+        type: "stage:complete",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: { stageIndex: i }
+      });
+      if (!allSuccess && !this.config.continueOnError) {
+        for (const remainingStage of stages.slice(i + 1)) {
+          for (const agent of remainingStage) {
+            this.eventBus.emit({
+              type: "agent:skipped",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              payload: { agentId: agent.id, agentName: agent.name, icon: agent.icon }
+            });
+          }
+        }
+        break;
+      }
+    }
+    const endTime = /* @__PURE__ */ new Date();
+    const totalCostUsd = sumCosts(results);
+    const result = {
+      name: this.config.name,
+      success: allSuccess,
+      totalDuration: endTime.getTime() - startTime.getTime(),
+      agentResults: results,
+      startTime: startTime.toISOString(),
+      endTime: endTime.toISOString(),
+      ...cancelled ? { cancelled: true } : {},
+      ...totalCostUsd !== void 0 ? { totalCostUsd } : {},
+      ...this.reasonField(resolution.reason),
+      ...this.requirementField()
+    };
+    this.eventBus.emit({
+      type: "orchestration:complete",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: result
+    });
+    return result;
+  }
+  stageInfos(stages) {
+    const getModel = (agent) => resolveModel(agent, this.config);
+    return stages.map((stage, i) => ({
+      stageIndex: i,
+      agents: stage.map((a) => ({
+        id: a.id,
+        name: a.name,
+        icon: a.icon,
+        model: getModel(a),
+        description: a.description,
+        taskTitle: a.taskTitle
+      }))
+    }));
+  }
+  /**
+   * Order the agents into stages, degrading to declaration order if the graph is
+   * broken.
+   *
+   * `buildStages` throws on a missing dependency and on a cycle. Letting that
+   * escape would reject `run()` before `orchestration:complete` is emitted, so
+   * the caller sees an unhandled rejection instead of a structured failure. A
+   * bad ordering is not a reason to run nothing.
+   */
+  buildStagesOrFallback(agents2, context) {
+    try {
+      return buildStages(agents2);
+    } catch (err) {
+      this.warn(`${context} (${errorMessage2(err)}) \u2014 running the agents in declaration order.`);
+      return [agents2];
+    }
+  }
+  /**
+   * Drop last run's task plan before the architect gets a chance to write one.
+   *
+   * The console runs every turn against the same workspace, so the plan file
+   * survives between turns. If a turn's architect fails to write a new one,
+   * `applyTaskPlan` would silently re-apply the previous turn's titles, scopes
+   * and dependencies to a completely different requirement.
+   */
+  clearStaleTaskPlan() {
+    fs4.rmSync(path5.join(this.workDir, "task-plan.json"), { force: true });
+  }
+  /**
+   * Decide what this turn is: a pipeline, an answer, or a question.
+   *
+   * Only the leader can answer that, so without one the configured team is the
+   * whole story. With one, its prose output is *not* a failure mode to be papered
+   * over by running everybody — a leader that answers a greeting has done its
+   * job, and that is what `message` records.
+   */
+  async resolveTurn(signal) {
+    if (this.config.resume) {
+      return {
+        kind: "run",
+        agents: this.selectAgents(this.config.resume.agents, "The resume list")
+      };
+    }
+    if (!this.config.leader || this.config.useLeader === false) {
+      return { kind: "run", agents: this.configuredAgents() };
+    }
+    this.contextManager.set(
+      "availableAgents",
+      this.config.agents.map((a) => `${a.id}: ${a.name}`).join("\n")
+    );
+    const result = await this.runner.run(this.config.leader, signal);
+    if (result.status !== "success") {
+      this.warn("The leader could not be reached \u2014 running the full configured team.");
+      return { kind: "run", agents: this.configuredAgents() };
+    }
+    const decision = parseLeaderDecision(result.output);
+    if (decision) {
+      if (decision.mode !== "run") {
+        return { kind: "message", mode: decision.mode, message: decision.message };
+      }
+      return { kind: "run", agents: this.selectAgents(decision.run), reason: decision.reason };
+    }
+    const message = result.output.trim();
+    if (!message) {
+      this.warn("The leader returned no output \u2014 running the full configured team.");
+      return { kind: "run", agents: this.configuredAgents() };
+    }
+    return { kind: "message", mode: "reply", message };
+  }
+  /**
+   * The configured team, as copies.
+   *
+   * `applyTaskPlan` writes `taskTitle` / `dependsOn` / `agentScope` onto whatever
+   * objects it is handed. The console reuses a single config across turns, so
+   * returning the config's own objects would leak turn 1's dependency graph into
+   * turn 2 — the exact cross-turn contamination `clearStaleTaskPlan` exists to
+   * prevent, but for the in-memory fields rather than the file.
+   */
+  configuredAgents() {
+    return this.config.agents.map(
+      (a) => a.dependsOn ? { ...a, dependsOn: [...a.dependsOn] } : { ...a }
+    );
+  }
+  /**
+   * Narrow the configured team to the ids `namedBy` asked for.
+   *
+   * Always a subset: an id that is not in the config is reported and dropped
+   * rather than added, so a typo in a prompt cannot conjure an agent that has no
+   * definition behind it.
+   *
+   * `namedBy` labels the warning. A resume names agents too — with no leader in
+   * the run at all — so blaming "the leader" for a bad resumed id would send the
+   * reader looking in the wrong place.
+   */
+  selectAgents(run, namedBy = "The leader") {
+    const runSet = new Set(run);
+    const known = new Set(this.config.agents.map((a) => a.id));
+    for (const id of run) {
+      if (!known.has(id)) {
+        this.warn(`${namedBy} named "${id}", which is not in the config \u2014 ignoring it.`);
+      }
+    }
+    const skippedIds = new Set(this.config.agents.filter((a) => !runSet.has(a.id)).map((a) => a.id));
+    for (const agent of this.config.agents.filter((a) => skippedIds.has(a.id))) {
+      this.eventBus.emit({
+        type: "agent:skipped",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: { agentId: agent.id, agentName: agent.name, icon: agent.icon }
+      });
+    }
+    return this.config.agents.filter((a) => runSet.has(a.id)).map((a) => ({
+      ...a,
+      dependsOn: a.dependsOn?.filter((dep) => !skippedIds.has(dep))
+    }));
+  }
+  async runStage(agents2, signal) {
+    const { maxConcurrency } = this.config;
+    if (!maxConcurrency || agents2.length <= maxConcurrency) {
+      return Promise.all(agents2.map((a) => this.runner.run(a, signal)));
+    }
+    const results = new Array(agents2.length);
+    let next = 0;
+    const workers = Array.from({ length: Math.min(maxConcurrency, agents2.length) }, async () => {
+      while (next < agents2.length) {
+        const index = next;
+        next += 1;
+        results[index] = await this.runner.run(agents2[index], signal);
+      }
+    });
+    await Promise.all(workers);
+    return results;
+  }
+  /**
+   * Whether `agent` owns task decomposition.
+   *
+   * The explicit `role` is the source of truth, so a config can name its planner
+   * anything. The id `"architect"` is kept as a fallback so every config written
+   * before `role` existed keeps working unchanged.
+   */
+  isPlanner(agent) {
+    return agent.role === "planner" || agent.id === "architect";
+  }
+  async applyTaskPlan(agents2) {
+    const taskPlanPath = path5.join(this.workDir, "task-plan.json");
+    if (!fs4.existsSync(taskPlanPath)) return;
+    let taskPlan;
+    try {
+      taskPlan = JSON.parse(fs4.readFileSync(taskPlanPath, "utf-8"));
+    } catch (err) {
+      this.warn(
+        `Could not parse task-plan.json \u2014 continuing with the original agent set: ${errorMessage2(err)}`
+      );
+      return;
+    }
+    if (!Array.isArray(taskPlan.tasks)) {
+      this.warn("task-plan.json has no `tasks` array \u2014 ignoring it.");
+      return;
+    }
+    const taskMap = new Map(taskPlan.tasks.map((t) => [t.id, t]));
+    const selected = new Set(agents2.map((a) => a.id));
+    for (const agent of agents2) {
+      const task = taskMap.get(agent.id);
+      if (task) {
+        agent.taskTitle = task.title;
+        const dependsOn = task.dependsOn?.filter((dep) => selected.has(dep));
+        for (const dep of task.dependsOn ?? []) {
+          if (!selected.has(dep)) {
+            this.warn(
+              `The task plan makes "${agent.id}" depend on "${dep}", which is not in this run \u2014 ignoring that dependency.`
+            );
+          }
+        }
+        agent.dependsOn = dependsOn;
+        agent.agentScope = task.scope;
+        if (task.plan?.length) {
+          agent.agentPlan = task.plan.map((s, i) => `${i + 1}. ${s}`).join("\n");
+        }
+      }
+    }
+  }
+  /**
+   * The `requirement` field for a result, present only when the caller set one.
+   *
+   * Spread into every result builder so all three outcomes carry it the same
+   * way: a completion event doubles as the report a resume driver reads back,
+   * and a requirement that never reaches the report cannot be resumed.
+   */
+  requirementField() {
+    const requirement = this.config.context?.requirement;
+    return requirement !== void 0 ? { requirement } : {};
+  }
+  /**
+   * The `selectionReason` field, present only when the leader explained itself.
+   *
+   * Omitted rather than sent as `undefined`/`""` so a run without an
+   * explanation stays byte-identical to one from before the field existed.
+   */
+  reasonField(reason) {
+    return reason ? { selectionReason: reason } : {};
+  }
+  /**
+   * Close out a turn the leader answered rather than planned.
+   *
+   * `success: true` on purpose: the user asked something and got an answer. What
+   * keeps that from reading as a completed pipeline is `reply`, which the console
+   * uses to say "answered" instead of "done".
+   */
+  finishWithMessage(mode, message, startTime) {
+    const endTime = /* @__PURE__ */ new Date();
+    const result = {
+      name: this.config.name,
+      success: true,
+      totalDuration: endTime.getTime() - startTime.getTime(),
+      agentResults: [],
+      startTime: startTime.toISOString(),
+      endTime: endTime.toISOString(),
+      reply: { mode, message },
+      ...this.requirementField()
+    };
+    this.eventBus.emit({
+      type: "orchestration:complete",
+      timestamp: endTime.toISOString(),
+      payload: result
+    });
+    return result;
+  }
+  warn(message) {
+    this.eventBus.emit({
+      type: "orchestration:warning",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: { message }
+    });
+  }
+  /**
+   * Close out a turn that scheduled no agents.
+   *
+   * Reported as a failure rather than a no-op: the user asked for work, and the
+   * only honest outcome is to say that none was done. Running the whole team
+   * instead would contradict the leader's explicit choice.
+   */
+  finishEmpty(startTime) {
+    const usedLeader = this.config.leader !== void 0 && this.config.useLeader !== false;
+    this.warn(
+      usedLeader ? "The leader selected none of the configured agents \u2014 nothing to run." : "The config lists no agents \u2014 nothing to run."
+    );
+    const endTime = /* @__PURE__ */ new Date();
+    const result = {
+      name: this.config.name,
+      success: false,
+      totalDuration: endTime.getTime() - startTime.getTime(),
+      agentResults: [],
+      startTime: startTime.toISOString(),
+      endTime: endTime.toISOString(),
+      ...this.requirementField()
+    };
+    this.eventBus.emit({
+      type: "orchestration:complete",
+      timestamp: endTime.toISOString(),
+      payload: result
+    });
+    return result;
+  }
+};
+function errorMessage2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function sumCosts(results) {
+  let total = 0;
+  let reported = false;
+  for (const result of results) {
+    if (typeof result.costUsd === "number") {
+      total += result.costUsd;
+      reported = true;
+    }
+  }
+  return reported ? total : void 0;
+}
+
+// src/providers/detect.ts
+import { spawn as spawn2 } from "child_process";
+async function versionFor(command) {
+  return new Promise((resolve4) => {
+    let out = "";
+    const child = spawn2(command, ["--version"], { env: process.env });
+    child.stdout.on("data", (d) => {
+      out += d.toString();
+    });
+    child.on("close", () => {
+      resolve4(out.trim() || void 0);
+    });
+    child.on("error", () => {
+      resolve4(void 0);
+    });
+    setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      resolve4(void 0);
+    }, 3e3);
+  });
+}
+async function detectProviders(opts) {
+  const results = [];
+  for (const spec of PROVIDERS) {
+    const candidates = [spec.command, ...spec.aliases ?? []];
+    let matched;
+    let version;
+    let source = "path";
+    let resolvedPath;
+    for (const cmd of candidates) {
+      const exe = resolveExecutable(cmd);
+      if (!exe) continue;
+      const bundled = exe !== cmd;
+      if (spec.confirm) {
+        if (opts?.withVersion) {
+          const v = await versionFor(exe);
+          if (v && spec.confirm(v)) {
+            matched = cmd;
+            version = v;
+            source = bundled ? "bundled" : "path";
+            resolvedPath = bundled ? exe : void 0;
+            break;
+          }
+        }
+        continue;
+      }
+      matched = cmd;
+      source = bundled ? "bundled" : "path";
+      resolvedPath = bundled ? exe : void 0;
+      if (opts?.withVersion) {
+        version = await versionFor(exe);
+      }
+      break;
+    }
+    if (matched) {
+      results.push({
+        id: spec.id,
+        label: spec.label,
+        command: matched,
+        status: "present",
+        version,
+        note: spec.auth.hint || void 0,
+        source,
+        ...resolvedPath !== void 0 ? { resolvedPath } : {}
+      });
+    } else {
+      results.push({
+        id: spec.id,
+        label: spec.label,
+        command: spec.command,
+        status: "missing",
+        note: spec.install.hint
+      });
+    }
+  }
+  return results;
+}
+function presentProviders(detected) {
+  return detected.filter((d) => d.status === "present").map((d) => d.id);
+}
+
+// src/utils/resumePlan.ts
+function describeResumePlan({ agents: agents2, sessions = {}, team }) {
+  const teamById = new Map(team.map((member) => [member.id, member]));
+  const running = new Set(agents2);
+  const clauses = agents2.map(
+    (id) => sessions[id] ? `${id} continues its session` : `${id} starts fresh`
+  );
+  for (const id of agents2) {
+    const dropped = (teamById.get(id)?.dependsOn ?? []).filter(
+      (dep) => teamById.has(dep) && !running.has(dep)
+    );
+    if (dropped.length > 0) clauses.push(`${id} runs without ${dropped.join(", ")}`);
+  }
+  return clauses.join("; ");
+}
 export {
-  ClaudeRuntime,
+  ABORT_ERROR_NAME,
+  AcpRuntime,
+  BRIDGE_PACKAGES,
   EventBus,
   Orchestrator,
+  PROVIDERS,
   RuntimeBase,
+  abortError,
   agents,
   buildStages,
   defineConfig,
-  runtimeRegistry
+  describeResumePlan,
+  detectProviders,
+  isAbortError,
+  presentProviders,
+  providerCommands,
+  providerIds,
+  resolveAgentRuntime,
+  resolveArgs,
+  resolveBridgeBinary,
+  resolveCommand,
+  resolveExecutable,
+  resolveModel,
+  resolveProvider,
+  resolvesOnPath,
+  runtimeRegistry,
+  specForCommand,
+  specForProvider,
+  tierModel
 };