@multiclawcli/core 0.6.2 → 0.7.0

package/dist/index.js

@@ -1,1621 +1,613 @@
-// 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.
-
-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
-
-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
-
-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}}
-
-## API Specification
-{{file:api-spec.md}}
-{{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)
+// 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;
+}
 
-Be specific. Reference section names or endpoint paths when citing issues.`;
-function archDesignReviewer(overrides) {
+// 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 {
-    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
+    provider,
+    command: resolveCommand(agent, config),
+    model: resolveModel(agent, config),
+    spec
   };
 }
 
-// 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.
-
-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)
+// src/runtime/AcpRuntime.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { Readable, Writable } from "stream";
+import { StringDecoder } from "string_decoder";
 
-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>"]
+// 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;
 }
-
-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
-  };
+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;
+  }
 }
-
-// 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
-  };
+function resolveExecutable(command) {
+  if (resolvesOnPath(command)) return command;
+  return resolveBridgeBinary(command);
 }
 
-// src/agents/code-reviewer.ts
-var SYSTEM4 = `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)
-- When the task includes a Delivery acceptance review contract, the final response must be only its JSON verdict, not the prose report. Approve only with no unresolved blocking issues; include file locations and fix directions in changes_required issues. The verdict is a review judgment, not proof that unexecuted tests passed.
-
-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}}
+// 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;
+}
 
-## Architecture Design
-{{file:architecture.md}}
+// src/utils/errors.ts
+var PermanentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PermanentError";
+  }
+};
+function isPermanent(err) {
+  return err instanceof PermanentError;
+}
 
-## API Specification
-{{file:api-spec.md}}
-{{upstreamOutputs}}
+// 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 hasToolArgs(input) {
+  if (input === void 0 || input === null) return false;
+  if (typeof input !== "object" || Array.isArray(input)) return true;
+  return Object.keys(input).length > 0;
+}
+function summarizeToolInput(input) {
+  return hasToolArgs(input) ? firstLineTruncated(input) : "";
+}
+function summarizeToolOutput(output) {
+  return firstLineTruncated(output);
+}
 
-## 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)
+// src/runtime/RuntimeBase.ts
+var RuntimeBase = class {
+};
 
-Start by reading implementation-notes.md (if present), then read source and test files.`;
-function codeReviewer(overrides) {
+// src/runtime/AcpRuntime.ts
+var discoveredModels = /* @__PURE__ */ new Map();
+var KILL_ESCALATION_MS = 3e3;
+var CANCEL_GRACE_MS = 2e3;
+var CLEANUP_ACK_MS = 3e3;
+var STEER_ACK_MS = 15e3;
+var DEFAULT_TIMEOUT_MS = 6e5;
+var DEFAULT_COMMAND2 = "opencode";
+var DEFAULT_ARGS = ["acp"];
+var STEER_METHOD = "_session/steering";
+function advertisesSteering(init) {
+  const steering = init._meta?.steering;
+  return isRecord(steering) && steering.supported === true;
+}
+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 matchesTool(pattern, name) {
+  if (!pattern.includes("*")) return pattern === name;
+  const source = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${source}$`).test(name);
+}
+function toolPermitted(params, tools) {
+  const allowed = tools.map((tool) => tool.toLowerCase());
+  const name = params.toolCall.name ?? void 0;
+  if (name !== void 0) {
+    const candidate = name.toLowerCase();
+    return allowed.some((pattern) => matchesTool(pattern, candidate));
+  }
+  return (KIND_TO_TOOLS[params.toolCall.kind ?? ""] ?? []).some((tool) => {
+    const candidate = tool.toLowerCase();
+    return allowed.some((pattern) => matchesTool(pattern, candidate));
+  });
+}
+function decidePermission(params, tools, sessionId) {
+  if (sessionId !== void 0 && params.sessionId !== sessionId) {
+    return { response: { outcome: { outcome: "cancelled" } }, approved: false };
+  }
+  const name = params.toolCall.name ?? void 0;
+  const kind = params.toolCall.kind ?? void 0;
+  const approved = toolPermitted(params, tools);
+  const option = params.options.find(
+    (o) => approved ? o.kind === "allow_once" : o.kind === "reject_once"
+  );
+  const response = option ? { outcome: { outcome: "selected", optionId: option.optionId } } : { outcome: { outcome: "cancelled" } };
+  if (approved) return { response, approved };
   return {
-    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
+    response,
+    approved,
+    rejected: {
+      toolCallId: params.toolCall.toolCallId,
+      name,
+      kind,
+      title: params.toolCall.title ?? void 0
+    }
   };
 }
-
-// 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:
-- 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):
-- 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
-
-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}}
-
-## Plan
-{{agentPlan}}
-{{upstreamOutputs}}
-
----
-
-## Project
-{{projectName}}
-
-## Architecture Design
-{{file:architecture.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
-
-Start by reading implementation-notes.md (if present) to understand what commands are used for build and test.`;
-function devops(overrides) {
-  return {
-    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
-  };
+var FORM_ANNOTATIONS = ["title", "description", "default", "_meta"];
+function knownFormKeys(value, keys) {
+  return Object.keys(value).every((key) => keys.includes(key) || FORM_ANNOTATIONS.includes(key));
 }
-
-// src/agents/frontend-developer.ts
-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
-- Integrate backend API contracts correctly; use mock data when the backend is not ready
-- Write frontend tests and run validation commands
-
-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 TASK6 = `## Task Scope
-{{agentScope}}
-
-## Plan
-{{agentPlan}}
-{{upstreamOutputs}}
-
----
-
-## UI Design Specification
-{{file:ui-design.md}}
-
-## Architecture Design
-{{file:architecture.md}}
-
-## API Specification
-{{file:api-spec.md}}
-
-## Task
-Implement complete frontend code following the UI design specification, architecture design, and API specification:
-1. Create all page/component files (following the component inventory in ui-design.md and directory structure in architecture.md)
-2. Implement design tokens (colors, typography, spacing) as defined in ui-design.md
-3. Integrate API endpoints (following api-spec.md); use mock data if the backend is not ready
-4. Implement all interaction states: loading, empty, error, success
-5. Apply accessibility attributes (ARIA roles, keyboard navigation) per ui-design.md
-6. Write basic tests
-7. Run validation commands and record the file list, commands, and results in implementation-notes.md
-
-Follow ui-design.md exactly. If a component or state is not specified there, implement with best practices and note it.`;
-function frontendDeveloper(overrides) {
-  return {
-    id: "frontend-developer",
-    name: "Frontend Developer",
-    icon: "\u25C7",
-    description: "builds the interface",
-    runtime: "acp",
-    models: { acp: "sonnet" },
-    modelTier: "balanced",
-    systemPrompt: SYSTEM6,
-    taskPrompt: TASK6,
-    tools: ["Read", "Write", "Bash"],
-    ...overrides
-  };
+function validFormBound(value, integer = false) {
+  return value == null || typeof value === "number" && Number.isFinite(value) && (!integer || Number.isInteger(value) && value >= 0);
 }
-
-// src/agents/leader.ts
-var SYSTEM7 = `You are the project leader. Decide what the requirement actually needs before anyone else starts.
-
-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.
-
-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. For every "run" decision, include a complete, standalone "requirement" that combines the original task goal with all clarification answers and constraints. Never pass only the latest short answer to the team.
-
-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", "requirement": "the complete task and constraints", "run": ["agent-id-1", "agent-id-2"]}`;
-var TASK7 = `## Project
-{{projectName}}
-
-## Requirement
-{{requirement}}
-{{conversation}}
-## Available Agents
-{{availableAgents}}
-
-## Task
-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", "requirement": "the complete task and constraints", "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
-  };
+function titledChoices(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(
+    (option) => isRecord(option) && knownFormKeys(option, ["const"]) && typeof option.const === "string"
+  );
 }
-
-// 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: "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
-  };
+function supportedQuestionSchema(schema) {
+  if (!isRecord(schema) || schema.type !== void 0 && schema.type !== "object" || !knownFormKeys(schema, ["type", "properties", "required"]))
+    return false;
+  const properties = schema.properties ?? {};
+  if (!isRecord(properties)) return false;
+  if (schema.required != null && (!Array.isArray(schema.required) || !schema.required.every(
+    (key) => typeof key === "string" && Object.getOwnPropertyDescriptor(properties, key) !== void 0
+  )))
+    return false;
+  return Object.values(properties).every((field) => {
+    if (!isRecord(field)) return false;
+    if (field.type === "string") {
+      return knownFormKeys(field, ["type", "enum", "oneOf", "minLength", "maxLength"]) && validFormBound(field.minLength, true) && validFormBound(field.maxLength, true) && (field.enum == null || Array.isArray(field.enum) && field.enum.length > 0 && field.enum.every((value) => typeof value === "string")) && (field.oneOf == null || titledChoices(field.oneOf));
+    }
+    if (field.type === "boolean") return knownFormKeys(field, ["type"]);
+    if (field.type === "number" || field.type === "integer") {
+      return knownFormKeys(field, ["type", "minimum", "maximum"]) && validFormBound(field.minimum) && validFormBound(field.maximum);
+    }
+    if (field.type !== "array" || !isRecord(field.items) || !knownFormKeys(field, ["type", "items", "minItems", "maxItems"]) || !validFormBound(field.minItems, true) || !validFormBound(field.maxItems, true))
+      return false;
+    return knownFormKeys(field.items, ["type", "enum"]) && field.items.type === "string" && Array.isArray(field.items.enum) && field.items.enum.length > 0 && field.items.enum.every((value) => typeof value === "string") || knownFormKeys(field.items, ["anyOf"]) && field.items.type === void 0 && titledChoices(field.items.anyOf);
+  });
 }
-
-// src/agents/reviewer.ts
-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
-- Assess: whether the implementation satisfies requirements, code quality, security risks, and maintainability
-- Do not run code, do not modify code \u2014 provide only professional judgment
-
-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 TASK9 = `## Project
-{{projectName}}
-
-## Requirement
-{{requirement}}
-{{upstreamOutputs}}
-
-## Task
-Perform an independent code review of all implementation in the current directory and output review.md:
-1. Read architecture.md (if present) to understand the design intent
-2. Read all implementation code
-3. Evaluate across these dimensions:
-   - Requirement coverage: is every feature implemented?
-   - Code quality: readability, maintainability, edge case handling
-   - Security and robustness: input validation, error handling
-   - Test adequacy (if test code is present)
-4. Output review.md: overall score (1\u201310), issue list (blocking / advisory), conclusion (Approved / Changes Required)
-
-Judge independently. Do not accept "the developer says it's fine" as a reason to approve.`;
-function reviewer(overrides) {
-  return {
-    id: "reviewer",
-    name: "Reviewer",
-    icon: "\u25C9",
-    description: "reviews the delivery",
-    runtime: "acp",
-    models: { acp: "haiku" },
-    modelTier: "fast",
-    systemPrompt: SYSTEM9,
-    taskPrompt: TASK9,
-    tools: ["Read", "Write"],
-    ...overrides
-  };
+function validateRuntimeQuestionContent(schema, content) {
+  if (!supportedQuestionSchema(schema) || !isRecord(content)) return false;
+  if (Object.getOwnPropertySymbols(content).length > 0 || Object.getOwnPropertyNames(content).some((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(content, key);
+    return !descriptor?.enumerable || !("value" in descriptor);
+  }))
+    return false;
+  const properties = schema.properties ?? {};
+  if ((schema.required ?? []).some(
+    (key) => Object.getOwnPropertyDescriptor(content, key) === void 0
+  ))
+    return false;
+  return Object.entries(content).every(([key, value]) => {
+    if (Object.getOwnPropertyDescriptor(properties, key) === void 0) return false;
+    const field = properties[key];
+    if (field.type === "boolean") return typeof value === "boolean";
+    if (field.type === "number" || field.type === "integer") {
+      return typeof value === "number" && Number.isFinite(value) && (field.type !== "integer" || Number.isInteger(value)) && (typeof field.minimum !== "number" || value >= field.minimum) && (typeof field.maximum !== "number" || value <= field.maximum);
+    }
+    if (field.type === "string") {
+      return typeof value === "string" && (typeof field.minLength !== "number" || [...value].length >= field.minLength) && (typeof field.maxLength !== "number" || [...value].length <= field.maxLength) && (!Array.isArray(field.enum) || field.enum.includes(value)) && (!Array.isArray(field.oneOf) || field.oneOf.some((option) => isRecord(option) && option.const === value));
+    }
+    const items = field.items;
+    const choices = Array.isArray(items.enum) ? items.enum : items.anyOf.map((option) => option.const);
+    return Array.isArray(value) && value.every((item) => typeof item === "string" && choices.includes(item)) && new Set(value).size === value.length && (typeof field.minItems !== "number" || value.length >= field.minItems) && (typeof field.maxItems !== "number" || value.length <= field.maxItems);
+  });
 }
-
-// src/agents/tester.ts
-var SYSTEM10 = `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
-
-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}}
-
-## Plan
-{{agentPlan}}
-{{upstreamOutputs}}
-
----
-
-## Project
-{{projectName}}
-
-## Requirement
-{{requirement}}
-
-## 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
-
-Start immediately. Verify actual behavior \u2014 do not just review code.`;
-function tester(overrides) {
-  return {
-    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 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
-- Verify all user flows and states are accounted for (loading, empty, error, success)
-- Assess accessibility coverage: ARIA roles, keyboard navigation, focus management
-- Check that design tokens are consistent and the component inventory covers all requirements
-- Do not write implementation code \u2014 provide design-level feedback only
-
-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 TASK11 = `## Requirement
-{{requirement}}
-
-## UI Design Specification
-{{file:ui-design.md}}
-{{upstreamOutputs}}
-
-## Task
-Review the UI design specification above and output ui-review.md:
-1. Overall verdict: Approved / Changes Required
-2. Blocking issues (missing components, undefined states, broken flows, accessibility gaps):
-   - component/section name, problem, fix direction
-3. Advisory issues (inconsistent tokens, unclear props, polish):
-   - component/section name, observation, suggestion
-4. Design strengths worth noting
-5. Final summary (1\u20132 sentences)
-
-Reference specific component names or section titles when citing issues.`;
-function uiDesignReviewer(overrides) {
-  return {
-    id: "ui-design-reviewer",
-    name: "UI Design Reviewer",
-    icon: "\u25CE",
-    description: "reviews the UI design",
-    runtime: "acp",
-    models: { acp: "haiku" },
-    modelTier: "fast",
-    systemPrompt: SYSTEM11,
-    taskPrompt: TASK11,
-    tools: ["Read", "Write"],
-    ...overrides
-  };
+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;
 }
-
-// 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:
-- 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 TASK12 = `## Task Scope
-{{agentScope}}
-
-## Plan
-{{agentPlan}}
-{{upstreamOutputs}}
-
----
-
-## Project
-{{projectName}}
-
-## 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
-
-Be concrete. Reference API endpoints where components bind to data. Flag any UX decision that needs product clarification.`;
-function uiDesigner(overrides) {
-  return {
-    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"],
-    ...overrides
-  };
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
 }
-
-// src/agents/index.ts
-var agents = {
-  leader,
-  architect,
-  productManager,
-  backendDeveloper,
-  frontendDeveloper,
-  tester,
-  reviewer,
-  archDesignReviewer,
-  uiDesigner,
-  uiDesignReviewer,
-  codeReviewer,
-  devops
-};
-
-// src/config/defineConfig.ts
-function defineConfig(config) {
-  return config;
+function timeoutMs(value) {
+  const timeout = value ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(timeout) || timeout < 0 || timeout > 2147483647) {
+    throw new PermanentError("ACP timeout must be a finite non-negative timer duration");
+  }
+  return timeout;
 }
-
-// src/event/EventBus.ts
-var EventBus = class {
+var AcpRuntime = class extends RuntimeBase {
   constructor() {
-    this.listeners = /* @__PURE__ */ new Set();
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
+    super(...arguments);
+    this.name = "acp";
   }
-  emit(event) {
-    for (const listener of this.listeners) {
-      try {
-        listener(event);
-      } catch (err) {
-        console.error("EventBus listener error:", err);
+  async describe(options) {
+    const command = options?.command ?? DEFAULT_COMMAND2;
+    return {
+      name: this.name,
+      available: resolveExecutable(command) !== null,
+      capabilities: {
+        ...BASE_CAPABILITIES,
+        tools: specForCommand(command)?.tools ?? false,
+        models: specForCommand(command)?.modelSelection === "config-option"
       }
-    }
-  }
-  clear() {
-    this.listeners.clear();
+    };
   }
-};
-
-// 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/orchestrator/AgentSessionManager.ts
-var AgentSessionManager = class {
-  constructor() {
-    this.entries = /* @__PURE__ */ new Map();
-    this.closed = false;
+  async execute(task) {
+    const { prompt, onEvent, signal, permissionMode, onPermission, onQuestion, ...options } = task;
+    const startup = new AbortController();
+    const forward = () => startup.abort();
+    if (signal?.aborted) startup.abort();
+    signal?.addEventListener("abort", forward, { once: true });
+    let session;
+    try {
+      session = await this.openSession({
+        ...options,
+        questionForms: Boolean(onQuestion),
+        signal: startup.signal
+      });
+    } finally {
+      signal?.removeEventListener("abort", forward);
+    }
+    try {
+      return await session.prompt(prompt, {
+        signal,
+        timeout: task.timeout,
+        onEvent,
+        permissionMode,
+        onPermission,
+        onQuestion
+      });
+    } finally {
+      await session.close();
+    }
   }
-  async execute(runtime, task) {
-    if (this.closed) throw new Error("AgentSessionManager is closed");
-    if (this.resetting) throw new Error("AgentSessionManager is resetting");
-    if (task.signal?.aborted) throw abortError();
-    let entry3 = this.entries.get(task.agentId);
-    if (entry3?.busy || entry3?.session && entry3.session.state !== "idle" && entry3.session.state !== "closed") {
-      throw new Error(`Agent session ${task.agentId} is busy`);
-    }
-    if (entry3?.closing) await entry3.closing;
-    const fingerprint = JSON.stringify([
-      task.command,
-      task.args,
-      task.model,
-      task.workDir,
-      task.systemPrompt,
-      task.tools,
-      task.sessionId,
-      task.resume,
-      Boolean(task.onQuestion)
-    ]);
-    if (entry3 && (entry3.runtime !== runtime || entry3.fingerprint !== fingerprint || entry3.session?.state === "closed" || !runtime.openSession)) {
-      entry3.busy = true;
-      try {
-        await this.closeEntry(entry3);
-        this.entries.delete(task.agentId);
-      } finally {
-        entry3.busy = false;
-      }
-      entry3 = void 0;
-      if (this.closed || this.resetting) throw abortError();
-    }
-    if (task.signal?.aborted) throw abortError();
-    const openSession = runtime.openSession;
-    if (!openSession) return runtime.execute(task);
-    let detach;
-    if (!entry3) {
-      const startup = new AbortController();
-      const forwardAbort = () => startup.abort(task.signal?.reason);
-      task.signal?.addEventListener("abort", forwardAbort, { once: true });
-      detach = () => task.signal?.removeEventListener("abort", forwardAbort);
-      const created = {
-        runtime,
-        fingerprint,
-        startup,
-        busy: true,
-        onWarning: task.onWarning,
-        // Defer opening until the cache entry is installed, including synchronous failures.
-        opening: Promise.resolve().then(
-          () => openSession.call(runtime, {
-            agentId: task.agentId,
-            systemPrompt: task.systemPrompt,
-            tools: task.tools,
-            workDir: task.workDir,
-            command: task.command,
-            args: task.args,
-            model: task.model,
-            sessionId: task.sessionId,
-            resume: task.resume,
-            timeout: task.timeout,
-            questionForms: Boolean(task.onQuestion),
-            signal: startup.signal,
-            onWarning: (message) => created.onWarning?.(message)
-          })
-        ).then((session) => {
-          created.session = session;
-          return session;
-        })
-      };
-      entry3 = created;
-      this.entries.set(task.agentId, entry3);
-    } else {
-      entry3.busy = true;
-      entry3.onWarning = task.onWarning;
+  async openSession(options) {
+    if (options.signal?.aborted) throw abortError();
+    if (options.resume === "fork") {
+      throw new PermanentError("ACP does not support forked sessions");
     }
+    const defaultTimeout = timeoutMs(options.timeout);
+    const questionForms = options.questionForms === true;
+    let startupReject;
+    const startupFailure = new Promise((_, reject) => {
+      startupReject = reject;
+    });
+    let failSession;
+    const failStartup = (error) => {
+      startupReject(error);
+      failSession?.(error);
+    };
+    const onSessionAbort = () => failStartup(abortError());
+    options.signal?.addEventListener("abort", onSessionAbort, { once: true });
+    const startupTimer = setTimeout(
+      () => failStartup(new Error(`acp startup timed out (${defaultTimeout}ms)`)),
+      defaultTimeout
+    );
+    let cleanup;
     try {
-      const session = await entry3.opening;
-      detach?.();
-      detach = void 0;
-      if (entry3.startup.signal.aborted || this.closed || this.resetting) {
-        await this.closeEntry(entry3);
-        throw abortError();
-      }
-      if (session.state !== "idle") throw new Error(`Agent session ${task.agentId} is busy`);
-      return await session.prompt(task.prompt, {
-        signal: task.signal,
-        timeout: task.timeout,
-        onEvent: task.onEvent,
-        permissionMode: task.permissionMode,
-        onPermission: task.onPermission,
-        onQuestion: task.onQuestion
+      const acp = await Promise.race([import("@agentclientprotocol/sdk"), startupFailure]);
+      if (options.signal?.aborted) throw abortError();
+      const command = options.command ?? DEFAULT_COMMAND2;
+      const spec = specForCommand(command);
+      const meta = spec?.meta?.({ ...options, prompt: "", timeout: defaultTimeout });
+      const child = spawn(resolveExecutable(command) ?? command, options.args ?? DEFAULT_ARGS, {
+        cwd: options.workDir,
+        env: process.env,
+        detached: true
       });
-    } finally {
-      detach?.();
-      entry3.onWarning = void 0;
-      try {
-        if (entry3.session?.state === "closed") {
-          await this.closeEntry(entry3);
-          if (this.entries.get(task.agentId) === entry3) this.entries.delete(task.agentId);
-        } else if (!entry3.session) {
-          if (this.entries.get(task.agentId) === entry3) this.entries.delete(task.agentId);
-        }
-      } finally {
-        entry3.busy = false;
-      }
-    }
-  }
-  /**
-   * Deliver a message into every session that is running a turn right now.
-   *
-   * Only `running` sessions are candidates, and that is the whole safety
-   * argument: a session between turns has nothing to inject into, and asking a
-   * provider to steer an idle session makes it *start* a turn that this manager
-   * never scheduled — one whose output belongs to no turn and which nothing
-   * would ever settle. Sessions that are idle are therefore not reported as
-   * failures but simply absent, and the caller sees an empty list.
-   *
-   * One agent failing never stops the others: each report stands alone, because
-   * the caller has to be able to say "architect took it, qa did not" rather than
-   * "steering failed".
-   */
-  async supplement(text) {
-    if (this.closed) return [];
-    const targets = [...this.entries.entries()].filter(
-      ([, entry3]) => entry3.session?.state === "running"
-    );
-    return await Promise.all(
-      targets.map(async ([agentId, entry3]) => {
-        const session = entry3.session;
-        if (!session) return { agentId, status: "idle" };
-        if (!session.capabilities.supplement || !session.supplement) {
-          return { agentId, status: "unsupported" };
+      let state = "idle";
+      let sessionId = "";
+      let steeringSupported = false;
+      let active;
+      let childClosed = false;
+      let terminalError;
+      let errorOutput = "";
+      let escalation;
+      let acknowledgement;
+      let closePromise;
+      let closeResolve;
+      let closeReject;
+      let connection;
+      const argsSurfaced = /* @__PURE__ */ new Set();
+      const toolNames = /* @__PURE__ */ new Map();
+      const killTree = (signal) => {
+        if (child.pid !== void 0) {
+          try {
+            process.kill(-child.pid, signal);
+            return;
+          } catch {
+          }
         }
         try {
-          return { agentId, status: (await session.supplement(text)).status };
-        } catch (error) {
-          return {
-            agentId,
-            status: "error",
-            error: error instanceof Error ? error.message : String(error)
-          };
+          child.kill(signal);
+        } catch {
         }
-      })
-    );
-  }
-  /** Closes all sessions and permits a fresh conversation after cleanup completes. */
-  reset() {
-    if (this.closing) return this.closing;
-    if (this.resetting) return this.resetting;
-    this.resetting = this.drain().finally(() => {
-      this.resetting = void 0;
-    });
-    return this.resetting;
-  }
-  /** Terminal, idempotent cleanup barrier. No new executions may start. */
-  close() {
-    if (this.closing) return this.closing;
-    this.closed = true;
-    this.closing = this.resetting ?? this.drain();
-    return this.closing;
-  }
-  async drain() {
-    const entries = [...this.entries.entries()];
-    for (const [, entry3] of entries) entry3.startup.abort();
-    const results = await Promise.allSettled(
-      entries.map(async ([id, entry3]) => {
-        await this.closeEntry(entry3);
-        if (this.entries.get(id) === entry3) this.entries.delete(id);
-      })
-    );
-    const errors = results.flatMap(
-      (result) => result.status === "rejected" ? [result.reason] : []
-    );
-    if (errors.length === 1) throw errors[0];
-    if (errors.length > 1) throw new AggregateError(errors, "Agent session cleanup failed");
-  }
-  closeEntry(entry3) {
-    if (!entry3.closing) {
-      entry3.closing = (async () => {
-        let session;
-        try {
-          session = await entry3.opening;
-        } catch (error) {
-          if (isAbortError(error)) return;
-          throw error;
-        }
-        await session.close();
-      })();
-    }
-    return entry3.closing;
-  }
-};
-
-// 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() : "";
-    const requirement = typeof record.requirement === "string" ? record.requirement.trim() : "";
-    if ("requirement" in record && !requirement) return void 0;
-    return {
-      mode: "run",
-      run,
-      ...reason ? { reason } : {},
-      ...requirement ? { requirement } : {}
-    };
-  }
-  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/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 CLEANUP_ACK_MS = 3e3;
-var STEER_ACK_MS = 15e3;
-var DEFAULT_TIMEOUT_MS = 6e5;
-var DEFAULT_COMMAND2 = "opencode";
-var DEFAULT_ARGS = ["acp"];
-var STEER_METHOD = "_session/steering";
-function advertisesSteering(init) {
-  const steering = init._meta?.steering;
-  return isRecord(steering) && steering.supported === true;
-}
-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 toolPermitted(params, tools) {
-  const allowed = new Set(tools.map((tool) => tool.toLowerCase()));
-  const name = params.toolCall.name ?? void 0;
-  return name !== void 0 ? allowed.has(name.toLowerCase()) : (KIND_TO_TOOLS[params.toolCall.kind ?? ""] ?? []).some(
-    (tool) => allowed.has(tool.toLowerCase())
-  );
-}
-function decidePermission(params, tools, sessionId) {
-  if (sessionId !== void 0 && params.sessionId !== sessionId) {
-    return { response: { outcome: { outcome: "cancelled" } } };
-  }
-  const name = params.toolCall.name ?? void 0;
-  const kind = params.toolCall.kind ?? void 0;
-  const approved = toolPermitted(params, tools);
-  const option = params.options.find(
-    (o) => approved ? o.kind === "allow_once" : 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
-    }
-  };
-}
-var FORM_ANNOTATIONS = ["title", "description", "default", "_meta"];
-function knownFormKeys(value, keys) {
-  return Object.keys(value).every((key) => keys.includes(key) || FORM_ANNOTATIONS.includes(key));
-}
-function validFormBound(value, integer = false) {
-  return value == null || typeof value === "number" && Number.isFinite(value) && (!integer || Number.isInteger(value) && value >= 0);
-}
-function titledChoices(value) {
-  return Array.isArray(value) && value.length > 0 && value.every(
-    (option) => isRecord(option) && knownFormKeys(option, ["const"]) && typeof option.const === "string"
-  );
-}
-function supportedQuestionSchema(schema) {
-  if (!isRecord(schema) || schema.type !== void 0 && schema.type !== "object" || !knownFormKeys(schema, ["type", "properties", "required"]))
-    return false;
-  const properties = schema.properties ?? {};
-  if (!isRecord(properties)) return false;
-  if (schema.required != null && (!Array.isArray(schema.required) || !schema.required.every(
-    (key) => typeof key === "string" && Object.getOwnPropertyDescriptor(properties, key) !== void 0
-  )))
-    return false;
-  return Object.values(properties).every((field) => {
-    if (!isRecord(field)) return false;
-    if (field.type === "string") {
-      return knownFormKeys(field, ["type", "enum", "oneOf", "minLength", "maxLength"]) && validFormBound(field.minLength, true) && validFormBound(field.maxLength, true) && (field.enum == null || Array.isArray(field.enum) && field.enum.length > 0 && field.enum.every((value) => typeof value === "string")) && (field.oneOf == null || titledChoices(field.oneOf));
-    }
-    if (field.type === "boolean") return knownFormKeys(field, ["type"]);
-    if (field.type === "number" || field.type === "integer") {
-      return knownFormKeys(field, ["type", "minimum", "maximum"]) && validFormBound(field.minimum) && validFormBound(field.maximum);
-    }
-    if (field.type !== "array" || !isRecord(field.items) || !knownFormKeys(field, ["type", "items", "minItems", "maxItems"]) || !validFormBound(field.minItems, true) || !validFormBound(field.maxItems, true))
-      return false;
-    return knownFormKeys(field.items, ["type", "enum"]) && field.items.type === "string" && Array.isArray(field.items.enum) && field.items.enum.length > 0 && field.items.enum.every((value) => typeof value === "string") || knownFormKeys(field.items, ["anyOf"]) && field.items.type === void 0 && titledChoices(field.items.anyOf);
-  });
-}
-function validateRuntimeQuestionContent(schema, content) {
-  if (!supportedQuestionSchema(schema) || !isRecord(content)) return false;
-  if (Object.getOwnPropertySymbols(content).length > 0 || Object.getOwnPropertyNames(content).some((key) => {
-    const descriptor = Object.getOwnPropertyDescriptor(content, key);
-    return !descriptor?.enumerable || !("value" in descriptor);
-  }))
-    return false;
-  const properties = schema.properties ?? {};
-  if ((schema.required ?? []).some(
-    (key) => Object.getOwnPropertyDescriptor(content, key) === void 0
-  ))
-    return false;
-  return Object.entries(content).every(([key, value]) => {
-    if (Object.getOwnPropertyDescriptor(properties, key) === void 0) return false;
-    const field = properties[key];
-    if (field.type === "boolean") return typeof value === "boolean";
-    if (field.type === "number" || field.type === "integer") {
-      return typeof value === "number" && Number.isFinite(value) && (field.type !== "integer" || Number.isInteger(value)) && (typeof field.minimum !== "number" || value >= field.minimum) && (typeof field.maximum !== "number" || value <= field.maximum);
-    }
-    if (field.type === "string") {
-      return typeof value === "string" && (typeof field.minLength !== "number" || [...value].length >= field.minLength) && (typeof field.maxLength !== "number" || [...value].length <= field.maxLength) && (!Array.isArray(field.enum) || field.enum.includes(value)) && (!Array.isArray(field.oneOf) || field.oneOf.some((option) => isRecord(option) && option.const === value));
-    }
-    const items = field.items;
-    const choices = Array.isArray(items.enum) ? items.enum : items.anyOf.map((option) => option.const);
-    return Array.isArray(value) && value.every((item) => typeof item === "string" && choices.includes(item)) && new Set(value).size === value.length && (typeof field.minItems !== "number" || value.length >= field.minItems) && (typeof field.maxItems !== "number" || value.length <= field.maxItems);
-  });
-}
-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);
-}
-function timeoutMs(value) {
-  const timeout = value ?? DEFAULT_TIMEOUT_MS;
-  if (!Number.isFinite(timeout) || timeout < 0 || timeout > 2147483647) {
-    throw new PermanentError("ACP timeout must be a finite non-negative timer duration");
-  }
-  return timeout;
-}
-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,
-      capabilities: {
-        ...BASE_CAPABILITIES,
-        tools: specForCommand(command)?.tools ?? false,
-        models: specForCommand(command)?.modelSelection === "config-option"
-      }
-    };
-  }
-  async execute(task) {
-    const { prompt, onEvent, signal, permissionMode, onPermission, onQuestion, ...options } = task;
-    const startup = new AbortController();
-    const forward = () => startup.abort();
-    if (signal?.aborted) startup.abort();
-    signal?.addEventListener("abort", forward, { once: true });
-    let session;
-    try {
-      session = await this.openSession({
-        ...options,
-        questionForms: Boolean(onQuestion),
-        signal: startup.signal
-      });
-    } finally {
-      signal?.removeEventListener("abort", forward);
-    }
-    try {
-      return await session.prompt(prompt, {
-        signal,
-        timeout: task.timeout,
-        onEvent,
-        permissionMode,
-        onPermission,
-        onQuestion
-      });
-    } finally {
-      await session.close();
-    }
-  }
-  async openSession(options) {
-    if (options.signal?.aborted) throw abortError();
-    if (options.resume === "fork") {
-      throw new PermanentError("ACP does not support forked sessions");
-    }
-    const defaultTimeout = timeoutMs(options.timeout);
-    const questionForms = options.questionForms === true;
-    let startupReject;
-    const startupFailure = new Promise((_, reject) => {
-      startupReject = reject;
-    });
-    let failSession;
-    const failStartup = (error) => {
-      startupReject(error);
-      failSession?.(error);
-    };
-    const onSessionAbort = () => failStartup(abortError());
-    options.signal?.addEventListener("abort", onSessionAbort, { once: true });
-    const startupTimer = setTimeout(
-      () => failStartup(new Error(`acp startup timed out (${defaultTimeout}ms)`)),
-      defaultTimeout
-    );
-    let cleanup;
-    try {
-      const acp = await Promise.race([import("@agentclientprotocol/sdk"), startupFailure]);
-      if (options.signal?.aborted) throw abortError();
-      const command = options.command ?? DEFAULT_COMMAND2;
-      const spec = specForCommand(command);
-      const meta = spec?.meta?.({ ...options, prompt: "", timeout: defaultTimeout });
-      const child = spawn(resolveExecutable(command) ?? command, options.args ?? DEFAULT_ARGS, {
-        cwd: options.workDir,
-        env: process.env,
-        detached: true
-      });
-      let state = "idle";
-      let sessionId = "";
-      let steeringSupported = false;
-      let active;
-      let childClosed = false;
-      let terminalError;
-      let errorOutput = "";
-      let escalation;
-      let acknowledgement;
-      let closePromise;
-      let closeResolve;
-      let closeReject;
-      let connection;
-      const killTree = (signal) => {
-        if (child.pid !== void 0) {
-          try {
-            process.kill(-child.pid, signal);
-            return;
-          } catch {
-          }
-        }
-        try {
-          child.kill(signal);
-        } catch {
-        }
-      };
-      const emitForTurn = (turn, event) => {
-        turn.options.onEvent?.({
-          ...event,
-          runId: turn.runId,
-          agentId: options.agentId,
-          seq: turn.seq++
-        });
-      };
-      const emit = (event) => {
-        if (active) emitForTurn(active, event);
-      };
-      const settleTurn = (turn, output, error) => {
-        if (active !== turn) return;
-        turn.decisions.abort();
-        if (turn.timer) clearTimeout(turn.timer);
-        if (turn.cancelTimer) clearTimeout(turn.cancelTimer);
-        if (turn.onAbort) turn.options.signal?.removeEventListener("abort", turn.onAbort);
-        active = void 0;
-        if (state === "running" || state === "cancelling") state = "idle";
-        if (error) {
-          if (closePromise) {
-            void closePromise.then(
-              () => turn.reject(error),
-              (cleanupError) => turn.reject(cleanupError)
-            );
-          } else turn.reject(error);
-        } else if (output) turn.resolve(output);
-      };
-      const clearCleanupTimers = () => {
-        if (escalation) clearTimeout(escalation);
-        if (acknowledgement) clearTimeout(acknowledgement);
-      };
-      const close = () => {
-        if (closePromise) return closePromise;
-        closePromise = new Promise((resolve4, reject) => {
-          closeResolve = resolve4;
-          closeReject = reject;
-        });
-        options.signal?.removeEventListener("abort", onSessionAbort);
-        clearTimeout(startupTimer);
-        state = "closing";
-        if (active) settleTurn(active, void 0, active.error ?? terminalError ?? abortError());
-        if (childClosed) {
-          state = "closed";
-          closeResolve?.();
-          return closePromise;
+      };
+      const emitForTurn = (turn, event) => {
+        turn.options.onEvent?.({
+          ...event,
+          runId: turn.runId,
+          agentId: options.agentId,
+          seq: turn.seq++
+        });
+      };
+      const emit = (event) => {
+        if (active) emitForTurn(active, event);
+      };
+      const settleTurn = (turn, output, error) => {
+        if (active !== turn) return;
+        turn.decisions.abort();
+        if (turn.timer) clearTimeout(turn.timer);
+        if (turn.cancelTimer) clearTimeout(turn.cancelTimer);
+        if (turn.onAbort) turn.options.signal?.removeEventListener("abort", turn.onAbort);
+        active = void 0;
+        if (state === "running" || state === "cancelling") state = "idle";
+        if (error) {
+          if (closePromise) {
+            void closePromise.then(
+              () => turn.reject(error),
+              (cleanupError) => turn.reject(cleanupError)
+            );
+          } else turn.reject(error);
+        } else if (output) turn.resolve(output);
+      };
+      const clearCleanupTimers = () => {
+        if (escalation) clearTimeout(escalation);
+        if (acknowledgement) clearTimeout(acknowledgement);
+      };
+      const close = () => {
+        if (closePromise) return closePromise;
+        closePromise = new Promise((resolve4, reject) => {
+          closeResolve = resolve4;
+          closeReject = reject;
+        });
+        options.signal?.removeEventListener("abort", onSessionAbort);
+        clearTimeout(startupTimer);
+        state = "closing";
+        if (active) settleTurn(active, void 0, active.error ?? terminalError ?? abortError());
+        if (childClosed) {
+          state = "closed";
+          closeResolve?.();
+          return closePromise;
         }
         escalation = setTimeout(() => {
           killTree("SIGKILL");
@@ -1691,15 +683,23 @@ var AcpRuntime = class extends RuntimeBase {
             }
             break;
           }
-          case "tool_call":
-            emit({
-              type: "tool_call",
-              id: update.toolCallId,
-              name: update.name ?? update.title,
-              input: update.rawInput
-            });
+          case "tool_call": {
+            const name = update.name ?? update.title;
+            toolNames.set(update.toolCallId, name);
+            if (hasToolArgs(update.rawInput)) argsSurfaced.add(update.toolCallId);
+            emit({ type: "tool_call", id: update.toolCallId, name, input: update.rawInput });
             break;
-          case "tool_call_update":
+          }
+          case "tool_call_update": {
+            if (!argsSurfaced.has(update.toolCallId) && hasToolArgs(update.rawInput)) {
+              argsSurfaced.add(update.toolCallId);
+              emit({
+                type: "tool_call",
+                id: update.toolCallId,
+                name: update.name ?? toolNames.get(update.toolCallId) ?? update.title ?? "",
+                input: update.rawInput
+              });
+            }
             emit({
               type: "tool_result",
               id: update.toolCallId,
@@ -1707,6 +707,7 @@ var AcpRuntime = class extends RuntimeBase {
               isError: update.status === "failed"
             });
             break;
+          }
           case "plan":
             emit({ type: "plan", entries: update.entries.map((entry3) => entry3.content) });
             break;
@@ -1741,22 +742,26 @@ var AcpRuntime = class extends RuntimeBase {
         if (state !== "running" || !turn || params.sessionId !== sessionId || context.signal.aborted)
           return cancelled;
         const mode = turn.options.permissionMode ?? "auto";
-        const { response, rejected } = decidePermission(params, options.tools, sessionId);
-        if (rejected) {
-          warn("Tool permission denied by the configured tools policy.");
-          emit({
-            type: "raw",
-            vendor: "acp",
-            payload: { type: "permission_rejected", ...rejected }
-          });
-          return response;
+        const { response, approved, rejected } = decidePermission(params, options.tools, sessionId);
+        if (approved) {
+          if (mode !== "deny") return response;
+          warn("Tool permission denied by the configured approval mode.");
+          return cancelled;
         }
-        if (mode === "auto") return response;
-        if (mode !== "ask" || !turn.options.onPermission) {
+        const askable = mode === "ask" && turn.options.onPermission !== void 0;
+        if (!askable) {
+          const label = rejected?.name ?? rejected?.kind ?? rejected?.toolCallId ?? "an unnamed tool";
           warn(
-            mode === "ask" ? "Tool permission cancelled: no approval handler is available." : "Tool permission denied by the configured approval mode."
+            mode === "ask" ? `Tool permission cancelled: no approval handler is available (${label}).` : `Tool permission denied by the configured tools policy: ${label}.`
           );
-          return cancelled;
+          if (rejected) {
+            emit({
+              type: "raw",
+              vendor: "acp",
+              payload: { type: "permission_rejected", ...rejected }
+            });
+          }
+          return mode === "deny" ? cancelled : response;
         }
         const signal = AbortSignal.any([turn.decisions.signal, context.signal]);
         const offered = new Set(params.options.map((option) => option.optionId));
@@ -1787,7 +792,18 @@ var AcpRuntime = class extends RuntimeBase {
             aborted
           ]);
           if (signal.aborted || active !== turn || state !== "running") return cancelled;
-          return optionId !== void 0 && offered.has(optionId) ? { outcome: { outcome: "selected", optionId } } : cancelled;
+          const chosen = params.options.find((option) => option.optionId === optionId);
+          if (optionId === void 0 || chosen === void 0 || !offered.has(optionId)) {
+            return cancelled;
+          }
+          if (chosen.kind.startsWith("reject") && rejected) {
+            emit({
+              type: "raw",
+              vendor: "acp",
+              payload: { type: "permission_rejected", ...rejected, source: "user" }
+            });
+          }
+          return { outcome: { outcome: "selected", optionId } };
         } catch {
           return cancelled;
         } finally {
@@ -1886,245 +902,1428 @@ var AcpRuntime = class extends RuntimeBase {
         if (!steeringSupported) {
           throw new Error(`${command} does not accept mid-turn input`);
         }
-        const turn = active;
-        if (!turn || state !== "running") return { status: "idle" };
-        if (supplementOptions.signal?.aborted) throw abortError();
-        let timer;
-        try {
-          const response = await Promise.race([
-            ctx.request(STEER_METHOD, {
-              sessionId,
-              prompt: [{ type: "text", text }],
-              _meta: { steering: { idleBehavior: "promptRequired" } }
-            }),
-            new Promise((_, reject) => {
-              timer = setTimeout(
-                () => reject(new Error(`steering was not acknowledged within ${STEER_ACK_MS}ms`)),
-                STEER_ACK_MS
+        const turn = active;
+        if (!turn || state !== "running") return { status: "idle" };
+        if (supplementOptions.signal?.aborted) throw abortError();
+        let timer;
+        try {
+          const response = await Promise.race([
+            ctx.request(STEER_METHOD, {
+              sessionId,
+              prompt: [{ type: "text", text }],
+              _meta: { steering: { idleBehavior: "promptRequired" } }
+            }),
+            new Promise((_, reject) => {
+              timer = setTimeout(
+                () => reject(new Error(`steering was not acknowledged within ${STEER_ACK_MS}ms`)),
+                STEER_ACK_MS
+              );
+            })
+          ]);
+          if (active !== turn) return { status: "idle" };
+          const outcome = response?.outcome;
+          if (outcome === "injected") return { status: "injected" };
+          if (outcome === "promptRequired") return { status: "idle" };
+          if (outcome === "startedNewTurn") {
+            await Promise.resolve().then(() => ctx.notify(acp.methods.agent.session.cancel, { sessionId })).catch(() => {
+            });
+            return { status: "idle" };
+          }
+          if (outcome === "failed") {
+            throw new Error("the agent could not apply the mid-turn message");
+          }
+          throw new Error(`unexpected steering outcome: ${JSON.stringify(outcome ?? null)}`);
+        } finally {
+          if (timer) clearTimeout(timer);
+        }
+      };
+      const prompt = (text, promptOptions = {}) => {
+        if (state !== "idle") {
+          return Promise.reject(new Error(`Cannot prompt ACP session while ${state}`));
+        }
+        if (options.signal?.aborted || promptOptions.signal?.aborted) {
+          return Promise.reject(abortError());
+        }
+        let duration;
+        try {
+          duration = timeoutMs(promptOptions.timeout ?? defaultTimeout);
+        } catch (error) {
+          return Promise.reject(error);
+        }
+        let resolve4;
+        let reject;
+        const promise = new Promise((res, rej) => {
+          resolve4 = res;
+          reject = rej;
+        });
+        const turn = {
+          runId: randomUUID(),
+          seq: 0,
+          options: promptOptions,
+          output: "",
+          decisions: new AbortController(),
+          promise,
+          resolve: resolve4,
+          reject
+        };
+        active = turn;
+        state = "running";
+        turn.onAbort = () => {
+          turn.error = abortError();
+          void cancelTurn().catch(() => {
+          });
+        };
+        promptOptions.signal?.addEventListener("abort", turn.onAbort, { once: true });
+        turn.timer = setTimeout(() => {
+          turn.error = new Error(`acp timed out (${duration}ms)`);
+          fail(turn.error);
+        }, duration);
+        const run = async () => {
+          emit({ type: "run_started", model: options.model });
+          if (active !== turn) return;
+          const response = await ctx.request(acp.methods.agent.session.prompt, {
+            sessionId,
+            prompt: [
+              {
+                type: "text",
+                text: meta === void 0 && options.systemPrompt ? `${options.systemPrompt}
+
+---
+
+${text}` : text
+              }
+            ]
+          });
+          if (active !== turn) return;
+          if (turn.error) {
+            settleTurn(turn, void 0, turn.error);
+            return;
+          }
+          const stopReason = mapStopReason(response.stopReason);
+          settleTurn(turn, {
+            output: turn.output,
+            exitCode: stopReason === "success" ? 0 : 1,
+            sessionId,
+            stopReason,
+            ...turn.usage ? { usage: turn.usage } : {},
+            ...turn.cost?.currency.toLowerCase() === "usd" ? { costUsd: turn.cost.amount } : {}
+          });
+          emitForTurn(turn, { type: "run_finished", stopReason });
+        };
+        void run().catch((error) => {
+          if (active === turn) fail(withAuthHint(acp, error));
+        });
+        return promise;
+      };
+      const session = {
+        get sessionId() {
+          return sessionId;
+        },
+        get state() {
+          return state;
+        },
+        get capabilities() {
+          return { continuation: true, supplement: steeringSupported };
+        },
+        prompt,
+        supplement,
+        cancelTurn,
+        close
+      };
+      const warn = (message) => {
+        if (options.onWarning) options.onWarning(message);
+        else process.stderr.write(`[multiclaw] Warning: ${message}
+`);
+      };
+      const initialize = async () => {
+        const init = await ctx.request(acp.methods.agent.initialize, {
+          protocolVersion: acp.PROTOCOL_VERSION,
+          ...questionForms ? { clientCapabilities: { elicitation: { form: {} } } } : {}
+        });
+        if (terminalError) throw terminalError;
+        steeringSupported = advertisesSteering(init);
+        if (options.sessionId) {
+          if (init.agentCapabilities?.loadSession !== true) {
+            throw new PermanentError(
+              `Agent does not support session/load (loadSession=false); cannot resume session ${options.sessionId}`
+            );
+          }
+          await ctx.request(acp.methods.agent.session.load, {
+            sessionId: options.sessionId,
+            cwd: options.workDir,
+            mcpServers: [],
+            ...meta ? { _meta: meta } : {}
+          });
+          sessionId = options.sessionId;
+        } else {
+          const created = await ctx.request(acp.methods.agent.session.new, {
+            cwd: options.workDir,
+            mcpServers: [],
+            ...meta ? { _meta: meta } : {}
+          });
+          sessionId = created.sessionId;
+          const modelOpt = created.configOptions?.find(
+            (option) => option.category === "model" || option.id === "model"
+          );
+          if (modelOpt && "options" in modelOpt && Array.isArray(modelOpt.options)) {
+            discoveredModels.set(
+              command,
+              (modelOpt.options ?? []).map(
+                (option) => option.value ?? String(option)
+              )
+            );
+          }
+        }
+        if (terminalError) throw terminalError;
+        if (options.model && spec?.modelSelection === "config-option") {
+          const known = discoveredModels.get(command);
+          if (known && !known.includes(options.model)) {
+            warn(
+              `model "${options.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: options.model
+              });
+            } catch (error) {
+              if (terminalError) throw terminalError;
+              warn(
+                `Could not set model "${options.model}" on ${command}; running with the provider's default (${errorMessage(error)}).`
               );
-            })
-          ]);
-          if (active !== turn) return { status: "idle" };
-          const outcome = response?.outcome;
-          if (outcome === "injected") return { status: "injected" };
-          if (outcome === "promptRequired") return { status: "idle" };
-          if (outcome === "startedNewTurn") {
-            await Promise.resolve().then(() => ctx.notify(acp.methods.agent.session.cancel, { sessionId })).catch(() => {
-            });
-            return { status: "idle" };
-          }
-          if (outcome === "failed") {
-            throw new Error("the agent could not apply the mid-turn message");
+            }
           }
-          throw new Error(`unexpected steering outcome: ${JSON.stringify(outcome ?? null)}`);
-        } finally {
-          if (timer) clearTimeout(timer);
         }
+        if (terminalError) throw terminalError;
+        if (options.signal?.aborted) throw abortError();
+      };
+      await Promise.race([
+        initialize().catch((error) => {
+          throw withAuthHint(acp, error);
+        }),
+        startupFailure
+      ]);
+      clearTimeout(startupTimer);
+      return session;
+    } catch (error) {
+      clearTimeout(startupTimer);
+      options.signal?.removeEventListener("abort", onSessionAbort);
+      if (cleanup) await cleanup();
+      throw error;
+    }
+  }
+};
+
+// 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/config/toolsPolicy.ts
+var TOOLS_PROVENANCE = /* @__PURE__ */ Symbol.for("multiclaw.toolsProvenance");
+function markPresetTools(agent, overrides) {
+  const provenance = overrides?.tools !== void 0 ? { explicit: true } : {
+    explicit: false,
+    reference: agent.tools,
+    snapshot: Object.freeze([...agent.tools ?? []])
+  };
+  Object.defineProperty(agent, TOOLS_PROVENANCE, {
+    value: Object.freeze(provenance),
+    enumerable: true
+  });
+  return agent;
+}
+function hasExplicitTools(agent) {
+  if (agent.tools === void 0) return false;
+  const provenance = agent[TOOLS_PROVENANCE];
+  if (!provenance || provenance.explicit) return true;
+  return agent.tools !== provenance.reference || agent.tools.length !== provenance.snapshot.length || agent.tools.some((tool, index) => tool !== provenance.snapshot[index]);
+}
+async function validateToolsPolicy(config, options = {}) {
+  const { signal } = options;
+  const checkAbort = () => {
+    if (signal?.aborted) throw abortError();
+  };
+  checkAbort();
+  const agents2 = [
+    ...config.leader && config.useLeader !== false ? [config.leader] : [],
+    ...config.agents
+  ];
+  const descriptions = /* @__PURE__ */ new Map();
+  for (const agent of agents2) {
+    checkAbort();
+    if (!hasExplicitTools(agent)) continue;
+    const runtime = runtimeRegistry.get(agent.runtime ?? "acp");
+    const command = resolveCommand(agent, config);
+    let commands = descriptions.get(runtime);
+    if (!commands) {
+      commands = /* @__PURE__ */ new Map();
+      descriptions.set(runtime, commands);
+    }
+    let info = commands.get(command);
+    if (!info) {
+      let onAbort;
+      const cancelled = new Promise((_, reject) => {
+        if (!signal) return;
+        onAbort = () => reject(abortError());
+        signal.addEventListener("abort", onAbort, { once: true });
+      });
+      try {
+        info = await Promise.race([runtime.describe({ command }), cancelled]);
+      } catch (error) {
+        checkAbort();
+        throw error;
+      } finally {
+        if (onAbort) signal?.removeEventListener("abort", onAbort);
+      }
+      checkAbort();
+      commands.set(command, info);
+    }
+    if (!info.capabilities.tools) {
+      throw new Error(
+        `Agent "${agent.name}" (${agent.id}), runtime "${runtime.name}", resolved command "${command}" cannot enforce explicit tools. Select a provider that supports tools restrictions or remove the explicit tools setting; the policy will not be relaxed.`
+      );
+    }
+  }
+  checkAbort();
+}
+
+// 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.
+
+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
+
+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
+
+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}}
+
+## API Specification
+{{file:api-spec.md}}
+{{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 markPresetTools(
+    {
+      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
+    },
+    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.
+
+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>"]
+    }
+  ]
+}
+
+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 markPresetTools(
+    {
+      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
+    },
+    overrides
+  );
+}
+
+// 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 markPresetTools(
+    {
+      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
+    },
+    overrides
+  );
+}
+
+// src/agents/code-reviewer.ts
+var SYSTEM4 = `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)
+- When the task includes a Delivery acceptance review contract, the final response must be only its JSON verdict, not the prose report. Approve only with no unresolved blocking issues; include file locations and fix directions in changes_required issues. The verdict is a review judgment, not proof that unexecuted tests passed.
+
+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}}
+
+## Architecture Design
+{{file:architecture.md}}
+
+## API Specification
+{{file:api-spec.md}}
+{{upstreamOutputs}}
+
+## 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 markPresetTools(
+    {
+      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
+    },
+    overrides
+  );
+}
+
+// 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:
+- 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):
+- 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
+
+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}}
+
+## Plan
+{{agentPlan}}
+{{upstreamOutputs}}
+
+---
+
+## Project
+{{projectName}}
+
+## Architecture Design
+{{file:architecture.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
+
+Start by reading implementation-notes.md (if present) to understand what commands are used for build and test.`;
+function devops(overrides) {
+  return markPresetTools(
+    {
+      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
+    },
+    overrides
+  );
+}
+
+// src/agents/frontend-developer.ts
+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
+- Integrate backend API contracts correctly; use mock data when the backend is not ready
+- Write frontend tests and run validation commands
+
+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 TASK6 = `## Task Scope
+{{agentScope}}
+
+## Plan
+{{agentPlan}}
+{{upstreamOutputs}}
+
+---
+
+## UI Design Specification
+{{file:ui-design.md}}
+
+## Architecture Design
+{{file:architecture.md}}
+
+## API Specification
+{{file:api-spec.md}}
+
+## Task
+Implement complete frontend code following the UI design specification, architecture design, and API specification:
+1. Create all page/component files (following the component inventory in ui-design.md and directory structure in architecture.md)
+2. Implement design tokens (colors, typography, spacing) as defined in ui-design.md
+3. Integrate API endpoints (following api-spec.md); use mock data if the backend is not ready
+4. Implement all interaction states: loading, empty, error, success
+5. Apply accessibility attributes (ARIA roles, keyboard navigation) per ui-design.md
+6. Write basic tests
+7. Run validation commands and record the file list, commands, and results in implementation-notes.md
+
+Follow ui-design.md exactly. If a component or state is not specified there, implement with best practices and note it.`;
+function frontendDeveloper(overrides) {
+  return markPresetTools(
+    {
+      id: "frontend-developer",
+      name: "Frontend Developer",
+      icon: "\u25C7",
+      description: "builds the interface",
+      runtime: "acp",
+      models: { acp: "sonnet" },
+      modelTier: "balanced",
+      systemPrompt: SYSTEM6,
+      taskPrompt: TASK6,
+      tools: ["Read", "Write", "Bash"],
+      ...overrides
+    },
+    overrides
+  );
+}
+
+// src/agents/leader.ts
+var SYSTEM7 = `You are the project leader. Decide what the requirement actually needs before anyone else starts.
+
+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.
+
+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. For every "run" decision, include a complete, standalone "requirement" that combines the original task goal with all clarification answers and constraints. Never pass only the latest short answer to the team.
+
+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", "requirement": "the complete task and constraints", "run": ["agent-id-1", "agent-id-2"]}`;
+var TASK7 = `## Project
+{{projectName}}
+
+## Requirement
+{{requirement}}
+{{conversation}}
+## Available Agents
+{{availableAgents}}
+
+## Task
+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", "requirement": "the complete task and constraints", "run": ["agent-id", ...]}
+Agent IDs must come from the Available Agents list above.`;
+function leader(overrides) {
+  return markPresetTools(
+    {
+      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
+    },
+    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 markPresetTools(
+    {
+      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
+    },
+    overrides
+  );
+}
+
+// src/agents/reviewer.ts
+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
+- Assess: whether the implementation satisfies requirements, code quality, security risks, and maintainability
+- Do not run code, do not modify code \u2014 provide only professional judgment
+
+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 TASK9 = `## Project
+{{projectName}}
+
+## Requirement
+{{requirement}}
+{{upstreamOutputs}}
+
+## Task
+Perform an independent code review of all implementation in the current directory and output review.md:
+1. Read architecture.md (if present) to understand the design intent
+2. Read all implementation code
+3. Evaluate across these dimensions:
+   - Requirement coverage: is every feature implemented?
+   - Code quality: readability, maintainability, edge case handling
+   - Security and robustness: input validation, error handling
+   - Test adequacy (if test code is present)
+4. Output review.md: overall score (1\u201310), issue list (blocking / advisory), conclusion (Approved / Changes Required)
+
+Judge independently. Do not accept "the developer says it's fine" as a reason to approve.`;
+function reviewer(overrides) {
+  return markPresetTools(
+    {
+      id: "reviewer",
+      name: "Reviewer",
+      icon: "\u25C9",
+      description: "reviews the delivery",
+      runtime: "acp",
+      models: { acp: "haiku" },
+      modelTier: "fast",
+      systemPrompt: SYSTEM9,
+      taskPrompt: TASK9,
+      tools: ["Read", "Write"],
+      ...overrides
+    },
+    overrides
+  );
+}
+
+// src/agents/tester.ts
+var SYSTEM10 = `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
+
+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}}
+
+## Plan
+{{agentPlan}}
+{{upstreamOutputs}}
+
+---
+
+## Project
+{{projectName}}
+
+## Requirement
+{{requirement}}
+
+## 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
+
+Start immediately. Verify actual behavior \u2014 do not just review code.`;
+function tester(overrides) {
+  return markPresetTools(
+    {
+      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
+    },
+    overrides
+  );
+}
+
+// src/agents/ui-design-reviewer.ts
+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
+- Verify all user flows and states are accounted for (loading, empty, error, success)
+- Assess accessibility coverage: ARIA roles, keyboard navigation, focus management
+- Check that design tokens are consistent and the component inventory covers all requirements
+- Do not write implementation code \u2014 provide design-level feedback only
+
+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 TASK11 = `## Requirement
+{{requirement}}
+
+## UI Design Specification
+{{file:ui-design.md}}
+{{upstreamOutputs}}
+
+## Task
+Review the UI design specification above and output ui-review.md:
+1. Overall verdict: Approved / Changes Required
+2. Blocking issues (missing components, undefined states, broken flows, accessibility gaps):
+   - component/section name, problem, fix direction
+3. Advisory issues (inconsistent tokens, unclear props, polish):
+   - component/section name, observation, suggestion
+4. Design strengths worth noting
+5. Final summary (1\u20132 sentences)
+
+Reference specific component names or section titles when citing issues.`;
+function uiDesignReviewer(overrides) {
+  return markPresetTools(
+    {
+      id: "ui-design-reviewer",
+      name: "UI Design Reviewer",
+      icon: "\u25CE",
+      description: "reviews the UI design",
+      runtime: "acp",
+      models: { acp: "haiku" },
+      modelTier: "fast",
+      systemPrompt: SYSTEM11,
+      taskPrompt: TASK11,
+      tools: ["Read", "Write"],
+      ...overrides
+    },
+    overrides
+  );
+}
+
+// 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:
+- 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 TASK12 = `## Task Scope
+{{agentScope}}
+
+## Plan
+{{agentPlan}}
+{{upstreamOutputs}}
+
+---
+
+## Project
+{{projectName}}
+
+## 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
+
+Be concrete. Reference API endpoints where components bind to data. Flag any UX decision that needs product clarification.`;
+function uiDesigner(overrides) {
+  return markPresetTools(
+    {
+      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"],
+      ...overrides
+    },
+    overrides
+  );
+}
+
+// src/agents/index.ts
+var agents = {
+  leader,
+  architect,
+  productManager,
+  backendDeveloper,
+  frontendDeveloper,
+  tester,
+  reviewer,
+  archDesignReviewer,
+  uiDesigner,
+  uiDesignReviewer,
+  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/AgentSessionManager.ts
+var AgentSessionManager = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.closed = false;
+  }
+  async execute(runtime, task) {
+    if (this.closed) throw new Error("AgentSessionManager is closed");
+    if (this.resetting) throw new Error("AgentSessionManager is resetting");
+    if (task.signal?.aborted) throw abortError();
+    let entry3 = this.entries.get(task.agentId);
+    if (entry3?.busy || entry3?.session && entry3.session.state !== "idle" && entry3.session.state !== "closed") {
+      throw new Error(`Agent session ${task.agentId} is busy`);
+    }
+    if (entry3?.closing) await entry3.closing;
+    const fingerprint = JSON.stringify([
+      task.command,
+      task.args,
+      task.model,
+      task.workDir,
+      task.systemPrompt,
+      task.tools,
+      task.sessionId,
+      task.resume,
+      Boolean(task.onQuestion)
+    ]);
+    if (entry3 && (entry3.runtime !== runtime || entry3.fingerprint !== fingerprint || entry3.session?.state === "closed" || !runtime.openSession)) {
+      entry3.busy = true;
+      try {
+        await this.closeEntry(entry3);
+        this.entries.delete(task.agentId);
+      } finally {
+        entry3.busy = false;
+      }
+      entry3 = void 0;
+      if (this.closed || this.resetting) throw abortError();
+    }
+    if (task.signal?.aborted) throw abortError();
+    const openSession = runtime.openSession;
+    if (!openSession) return runtime.execute(task);
+    let detach;
+    if (!entry3) {
+      const startup = new AbortController();
+      const forwardAbort = () => startup.abort(task.signal?.reason);
+      task.signal?.addEventListener("abort", forwardAbort, { once: true });
+      detach = () => task.signal?.removeEventListener("abort", forwardAbort);
+      const created = {
+        runtime,
+        fingerprint,
+        startup,
+        busy: true,
+        onWarning: task.onWarning,
+        // Defer opening until the cache entry is installed, including synchronous failures.
+        opening: Promise.resolve().then(
+          () => openSession.call(runtime, {
+            agentId: task.agentId,
+            systemPrompt: task.systemPrompt,
+            tools: task.tools,
+            workDir: task.workDir,
+            command: task.command,
+            args: task.args,
+            model: task.model,
+            sessionId: task.sessionId,
+            resume: task.resume,
+            timeout: task.timeout,
+            questionForms: Boolean(task.onQuestion),
+            signal: startup.signal,
+            onWarning: (message) => created.onWarning?.(message)
+          })
+        ).then((session) => {
+          created.session = session;
+          return session;
+        })
       };
-      const prompt = (text, promptOptions = {}) => {
-        if (state !== "idle") {
-          return Promise.reject(new Error(`Cannot prompt ACP session while ${state}`));
+      entry3 = created;
+      this.entries.set(task.agentId, entry3);
+    } else {
+      entry3.busy = true;
+      entry3.onWarning = task.onWarning;
+    }
+    try {
+      const session = await entry3.opening;
+      detach?.();
+      detach = void 0;
+      if (entry3.startup.signal.aborted || this.closed || this.resetting) {
+        await this.closeEntry(entry3);
+        throw abortError();
+      }
+      if (session.state !== "idle") throw new Error(`Agent session ${task.agentId} is busy`);
+      return await session.prompt(task.prompt, {
+        signal: task.signal,
+        timeout: task.timeout,
+        onEvent: task.onEvent,
+        permissionMode: task.permissionMode,
+        onPermission: task.onPermission,
+        onQuestion: task.onQuestion
+      });
+    } finally {
+      detach?.();
+      entry3.onWarning = void 0;
+      try {
+        if (entry3.session?.state === "closed") {
+          await this.closeEntry(entry3);
+          if (this.entries.get(task.agentId) === entry3) this.entries.delete(task.agentId);
+        } else if (!entry3.session) {
+          if (this.entries.get(task.agentId) === entry3) this.entries.delete(task.agentId);
         }
-        if (options.signal?.aborted || promptOptions.signal?.aborted) {
-          return Promise.reject(abortError());
+      } finally {
+        entry3.busy = false;
+      }
+    }
+  }
+  /**
+   * Deliver a message into every session that is running a turn right now.
+   *
+   * Only `running` sessions are candidates, and that is the whole safety
+   * argument: a session between turns has nothing to inject into, and asking a
+   * provider to steer an idle session makes it *start* a turn that this manager
+   * never scheduled — one whose output belongs to no turn and which nothing
+   * would ever settle. Sessions that are idle are therefore not reported as
+   * failures but simply absent, and the caller sees an empty list.
+   *
+   * One agent failing never stops the others: each report stands alone, because
+   * the caller has to be able to say "architect took it, qa did not" rather than
+   * "steering failed".
+   */
+  async supplement(text) {
+    if (this.closed) return [];
+    const targets = [...this.entries.entries()].filter(
+      ([, entry3]) => entry3.session?.state === "running"
+    );
+    return await Promise.all(
+      targets.map(async ([agentId, entry3]) => {
+        const session = entry3.session;
+        if (!session) return { agentId, status: "idle" };
+        if (!session.capabilities.supplement || !session.supplement) {
+          return { agentId, status: "unsupported" };
         }
-        let duration;
         try {
-          duration = timeoutMs(promptOptions.timeout ?? defaultTimeout);
+          return { agentId, status: (await session.supplement(text)).status };
         } catch (error) {
-          return Promise.reject(error);
-        }
-        let resolve4;
-        let reject;
-        const promise = new Promise((res, rej) => {
-          resolve4 = res;
-          reject = rej;
-        });
-        const turn = {
-          runId: randomUUID(),
-          seq: 0,
-          options: promptOptions,
-          output: "",
-          decisions: new AbortController(),
-          promise,
-          resolve: resolve4,
-          reject
-        };
-        active = turn;
-        state = "running";
-        turn.onAbort = () => {
-          turn.error = abortError();
-          void cancelTurn().catch(() => {
-          });
-        };
-        promptOptions.signal?.addEventListener("abort", turn.onAbort, { once: true });
-        turn.timer = setTimeout(() => {
-          turn.error = new Error(`acp timed out (${duration}ms)`);
-          fail(turn.error);
-        }, duration);
-        const run = async () => {
-          emit({ type: "run_started", model: options.model });
-          if (active !== turn) return;
-          const response = await ctx.request(acp.methods.agent.session.prompt, {
-            sessionId,
-            prompt: [
-              {
-                type: "text",
-                text: meta === void 0 && options.systemPrompt ? `${options.systemPrompt}
-
----
-
-${text}` : text
-              }
-            ]
-          });
-          if (active !== turn) return;
-          if (turn.error) {
-            settleTurn(turn, void 0, turn.error);
-            return;
-          }
-          const stopReason = mapStopReason(response.stopReason);
-          settleTurn(turn, {
-            output: turn.output,
-            exitCode: stopReason === "success" ? 0 : 1,
-            sessionId,
-            stopReason,
-            ...turn.usage ? { usage: turn.usage } : {},
-            ...turn.cost?.currency.toLowerCase() === "usd" ? { costUsd: turn.cost.amount } : {}
-          });
-          emitForTurn(turn, { type: "run_finished", stopReason });
-        };
-        void run().catch((error) => {
-          if (active === turn) fail(withAuthHint(acp, error));
-        });
-        return promise;
-      };
-      const session = {
-        get sessionId() {
-          return sessionId;
-        },
-        get state() {
-          return state;
-        },
-        get capabilities() {
-          return { continuation: true, supplement: steeringSupported };
-        },
-        prompt,
-        supplement,
-        cancelTurn,
-        close
-      };
-      const warn = (message) => {
-        if (options.onWarning) options.onWarning(message);
-        else process.stderr.write(`[multiclaw] Warning: ${message}
-`);
-      };
-      const initialize = async () => {
-        const init = await ctx.request(acp.methods.agent.initialize, {
-          protocolVersion: acp.PROTOCOL_VERSION,
-          ...questionForms ? { clientCapabilities: { elicitation: { form: {} } } } : {}
-        });
-        if (terminalError) throw terminalError;
-        steeringSupported = advertisesSteering(init);
-        if (options.sessionId) {
-          if (init.agentCapabilities?.loadSession !== true) {
-            throw new PermanentError(
-              `Agent does not support session/load (loadSession=false); cannot resume session ${options.sessionId}`
-            );
-          }
-          await ctx.request(acp.methods.agent.session.load, {
-            sessionId: options.sessionId,
-            cwd: options.workDir,
-            mcpServers: [],
-            ...meta ? { _meta: meta } : {}
-          });
-          sessionId = options.sessionId;
-        } else {
-          const created = await ctx.request(acp.methods.agent.session.new, {
-            cwd: options.workDir,
-            mcpServers: [],
-            ...meta ? { _meta: meta } : {}
-          });
-          sessionId = created.sessionId;
-          const modelOpt = created.configOptions?.find(
-            (option) => option.category === "model" || option.id === "model"
-          );
-          if (modelOpt && "options" in modelOpt && Array.isArray(modelOpt.options)) {
-            discoveredModels.set(
-              command,
-              (modelOpt.options ?? []).map(
-                (option) => option.value ?? String(option)
-              )
-            );
-          }
+          return {
+            agentId,
+            status: "error",
+            error: error instanceof Error ? error.message : String(error)
+          };
         }
-        if (terminalError) throw terminalError;
-        if (options.model && spec?.modelSelection === "config-option") {
-          const known = discoveredModels.get(command);
-          if (known && !known.includes(options.model)) {
-            warn(
-              `model "${options.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: options.model
-              });
-            } catch (error) {
-              if (terminalError) throw terminalError;
-              warn(
-                `Could not set model "${options.model}" on ${command}; running with the provider's default (${errorMessage(error)}).`
-              );
-            }
-          }
+      })
+    );
+  }
+  /** Closes all sessions and permits a fresh conversation after cleanup completes. */
+  reset() {
+    if (this.closing) return this.closing;
+    if (this.resetting) return this.resetting;
+    this.resetting = this.drain().finally(() => {
+      this.resetting = void 0;
+    });
+    return this.resetting;
+  }
+  /** Terminal, idempotent cleanup barrier. No new executions may start. */
+  close() {
+    if (this.closing) return this.closing;
+    this.closed = true;
+    this.closing = this.resetting ?? this.drain();
+    return this.closing;
+  }
+  async drain() {
+    const entries = [...this.entries.entries()];
+    for (const [, entry3] of entries) entry3.startup.abort();
+    const results = await Promise.allSettled(
+      entries.map(async ([id, entry3]) => {
+        await this.closeEntry(entry3);
+        if (this.entries.get(id) === entry3) this.entries.delete(id);
+      })
+    );
+    const errors = results.flatMap(
+      (result) => result.status === "rejected" ? [result.reason] : []
+    );
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1) throw new AggregateError(errors, "Agent session cleanup failed");
+  }
+  closeEntry(entry3) {
+    if (!entry3.closing) {
+      entry3.closing = (async () => {
+        let session;
+        try {
+          session = await entry3.opening;
+        } catch (error) {
+          if (isAbortError(error)) return;
+          throw error;
         }
-        if (terminalError) throw terminalError;
-        if (options.signal?.aborted) throw abortError();
-      };
-      await Promise.race([
-        initialize().catch((error) => {
-          throw withAuthHint(acp, error);
-        }),
-        startupFailure
-      ]);
-      clearTimeout(startupTimer);
-      return session;
-    } catch (error) {
-      clearTimeout(startupTimer);
-      options.signal?.removeEventListener("abort", onSessionAbort);
-      if (cleanup) await cleanup();
-      throw error;
+        await session.close();
+      })();
     }
+    return entry3.closing;
   }
 };
 
-// src/runtime/index.ts
-var RuntimeRegistry = class {
-  constructor() {
-    this.runtimes = /* @__PURE__ */ new Map();
-    this.register(new AcpRuntime());
+// src/orchestrator/Orchestrator.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+
+// 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 agentSummary(label, agents2, format) {
+  let text = `${label}: `;
+  if (agents2.length === 0) text += "none";
+  for (let i = 0; i < agents2.length; i++) {
+    text += `${i > 0 ? ", " : ""}${clip(format(agents2[i]), MAX_ENTRY_CHARS)}`;
+    if (text.length >= MAX_ENTRY_CHARS - 3) {
+      if (i < agents2.length - 1) text += ELLIPSIS;
+      break;
+    }
   }
-  register(r) {
-    this.runtimes.set(r.name, r);
+  return `   ${clip(text, MAX_ENTRY_CHARS - 3)}`;
+}
+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)}`);
+  } else if (turn.outcome) {
+    const { execution, completedAgents, failedAgents, acceptance } = turn.outcome;
+    lines.push(
+      `   ${clip(`execution: ${execution}`, MAX_ENTRY_CHARS - 3)}`,
+      agentSummary("completed", completedAgents, (agentId) => agentId),
+      agentSummary(
+        "failed",
+        failedAgents,
+        ({ agentId, reason }) => reason ? `${agentId} (${reason})` : agentId
+      ),
+      `   ${clip(
+        `acceptance: ${acceptance ? `${acceptance.status}${acceptance.reason ? ` (${acceptance.reason})` : ""}` : "not configured"}`,
+        MAX_ENTRY_CHARS - 3
+      )}`
+    );
   }
-  get(name) {
-    const r = this.runtimes.get(name);
-    if (!r)
-      throw new Error(
-        `Runtime not found: "${name}". Available: ${[...this.runtimes.keys()].join(", ")}`
-      );
-    return r;
+  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();
   }
-  has(name) {
-    return this.runtimes.has(name);
+  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;
   }
-  list() {
-    return [...this.runtimes.keys()];
+  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;
+    }
   }
-};
-var runtimeRegistry = new RuntimeRegistry();
+  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() : "";
+    const requirement = typeof record.requirement === "string" ? record.requirement.trim() : "";
+    if ("requirement" in record && !requirement) return void 0;
+    return {
+      mode: "run",
+      run,
+      ...reason ? { reason } : {},
+      ...requirement ? { requirement } : {}
+    };
+  }
+  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/utils/prompt.ts
 import * as fs2 from "fs/promises";
@@ -2234,31 +2433,6 @@ function withTimeout(factory, ms, label, signal, options) {
   });
 }
 
-// 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, sessionManager) {
@@ -2319,6 +2493,16 @@ ${prompt}`;
             if (instruction) prompt += `
 
 ${instruction}`;
+            const toolRows = /* @__PURE__ */ new Set();
+            const toolNames = /* @__PURE__ */ new Map();
+            const printToolRow = (id, name, input) => {
+              if (toolRows.has(id)) return;
+              toolRows.add(id);
+              const summary = summarizeToolInput(input);
+              this.emitOutput(agent.id, `
+\u203A ${name}${summary ? ` ${summary}` : ""}
+`, "tool");
+            };
             const task = {
               agentId: agent.id,
               systemPrompt: agent.systemPrompt,
@@ -2360,17 +2544,13 @@ ${instruction}`;
                   return;
                 }
                 if (e.type === "tool_call") {
-                  const summary = summarizeToolInput(e.input);
-                  this.emitOutput(
-                    agent.id,
-                    `
-\u203A ${e.name}${summary ? ` ${summary}` : ""}
-`,
-                    "tool"
-                  );
+                  toolNames.set(e.id, e.name);
+                  if (summarizeToolInput(e.input)) printToolRow(e.id, e.name, e.input);
                   return;
                 }
                 if (e.type === "tool_result") {
+                  const name = toolNames.get(e.id);
+                  if (name !== void 0) printToolRow(e.id, name, void 0);
                   const summary = summarizeToolOutput(e.output);
                   this.emitOutput(
                     agent.id,
@@ -2542,8 +2722,19 @@ var Orchestrator = class {
     );
   }
   async preview(options = {}) {
+    if (options.signal?.aborted)
+      return { name: this.config.name, totalAgents: 0, stages: [], ...this.requirementField() };
     const policyError = this.reviewPolicyError();
     if (policyError) throw new Error(policyError);
+    try {
+      await validateToolsPolicy(this.config, options);
+    } catch (error) {
+      if (options.signal?.aborted)
+        return { name: this.config.name, totalAgents: 0, stages: [], ...this.requirementField() };
+      throw error;
+    }
+    if (options.signal?.aborted)
+      return { name: this.config.name, totalAgents: 0, stages: [], ...this.requirementField() };
     this.clearStaleTaskPlan();
     const resolution = await this.resolveTurn(options.signal);
     if (resolution.kind === "cancelled" || options.signal?.aborted) {
@@ -2587,6 +2778,14 @@ var Orchestrator = class {
       });
       return result2;
     }
+    try {
+      await validateToolsPolicy(this.config, options);
+    } catch (error) {
+      if (options.signal?.aborted) return this.finishCancelled(startTime);
+      this.warn(errorMessage2(error));
+      return this.finishEmpty(startTime, void 0, false);
+    }
+    if (options.signal?.aborted) return this.finishCancelled(startTime);
     this.clearStaleTaskPlan();
     const resolution = await this.resolveTurn(options.signal);
     if (resolution.kind === "cancelled" || options.signal?.aborted) {
@@ -3171,9 +3370,9 @@ Address these findings within your assigned scope, preserve the complete task re
    * only honest outcome is to say that none was done. Running the whole team
    * instead would contradict the leader's explicit choice.
    */
-  finishEmpty(startTime, acceptance) {
+  finishEmpty(startTime, acceptance, warnEmpty = true) {
     const usedLeader = this.config.leader !== void 0 && this.config.useLeader !== false;
-    if (!acceptance?.reason)
+    if (warnEmpty && !acceptance?.reason)
       this.warn(
         usedLeader ? "The leader selected none of the configured agents \u2014 nothing to run." : "The config lists no agents \u2014 nothing to run."
       );
@@ -3358,6 +3557,7 @@ export {
   defineConfig,
   describeResumePlan,
   detectProviders,
+  hasExplicitTools,
   isAbortError,
   presentProviders,
   providerCommands,
@@ -3374,5 +3574,6 @@ export {
   specForCommand,
   specForProvider,
   tierModel,
-  validateRuntimeQuestionContent
+  validateRuntimeQuestionContent,
+  validateToolsPolicy
 };