@multiclawcli/core 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,9 +1,1069 @@
-export * from "./types";
-export { EventBus } from "./event/EventBus";
-export { Orchestrator } from "./orchestrator/Orchestrator";
-export { buildStages } from "./orchestrator/StageBuilder";
-export { runtimeRegistry, ClaudeRuntime } from "./runtime";
-export { RuntimeBase } from "./runtime/RuntimeBase";
-export { defineConfig } from "./config/defineConfig";
-export { agents } from "./agents";
-//# sourceMappingURL=index.js.map
+// src/event/EventBus.ts
+var EventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.error("EventBus listener error:", err);
+      }
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/orchestrator/Orchestrator.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// src/orchestrator/ContextManager.ts
+var ContextManager = class {
+  constructor(initial) {
+    this.store = /* @__PURE__ */ new Map();
+    if (initial) for (const [k, v] of Object.entries(initial)) this.store.set(k, v);
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  get(key) {
+    return this.store.get(key);
+  }
+  snapshot() {
+    return Object.fromEntries(this.store.entries());
+  }
+};
+
+// src/orchestrator/AgentRunner.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/runtime/ClaudeRuntime.ts
+import { spawn, execSync } from "child_process";
+
+// src/runtime/RuntimeBase.ts
+var RuntimeBase = class {
+};
+
+// src/runtime/ClaudeRuntime.ts
+var ClaudeRuntime = class extends RuntimeBase {
+  constructor() {
+    super(...arguments);
+    this.name = "claude";
+  }
+  async checkAvailable() {
+    try {
+      execSync("claude --version", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async execute(task) {
+    const args = [
+      "-p",
+      task.prompt,
+      "--allowedTools",
+      task.tools.join(",")
+    ];
+    if (task.systemPrompt) args.push("--system-prompt", task.systemPrompt);
+    if (task.model) args.push("--model", task.model);
+    return new Promise((resolve4, reject) => {
+      const child = spawn("claude", args, { cwd: task.workDir, env: process.env });
+      task.signal?.addEventListener("abort", () => child.kill());
+      let output = "";
+      let errorOutput = "";
+      child.stdout.on("data", (d) => {
+        const chunk = d.toString();
+        output += chunk;
+        task.onOutput?.(chunk);
+      });
+      child.stderr.on("data", (d) => {
+        errorOutput += d.toString();
+      });
+      child.on("close", (code) => {
+        if (task.signal?.aborted) return;
+        code === 0 ? resolve4({ output, exitCode: code }) : reject(new Error(`claude exited with code ${code}: ${errorOutput}`));
+      });
+      child.on("error", (err) => reject(new Error(`Failed to start claude: ${err.message}`)));
+    });
+  }
+};
+
+// src/runtime/index.ts
+var RuntimeRegistry = class {
+  constructor() {
+    this.runtimes = /* @__PURE__ */ new Map();
+    this.register(new ClaudeRuntime());
+  }
+  register(r) {
+    this.runtimes.set(r.name, r);
+  }
+  get(name) {
+    const r = this.runtimes.get(name);
+    if (!r) throw new Error(`Runtime not found: "${name}". Available: ${[...this.runtimes.keys()].join(", ")}`);
+    return r;
+  }
+  has(name) {
+    return this.runtimes.has(name);
+  }
+  list() {
+    return [...this.runtimes.keys()];
+  }
+};
+var runtimeRegistry = new RuntimeRegistry();
+
+// src/utils/retry.ts
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function withRetry(fn, retries, onRetry, delayMs = 2e3) {
+  let lastError = new Error("Unknown error");
+  for (let attempt = 1; attempt <= retries + 1; attempt++) {
+    try {
+      return await fn(attempt);
+    } catch (err) {
+      lastError = err;
+      if (attempt <= retries) {
+        onRetry?.(attempt, err);
+        await sleep(delayMs * attempt);
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/utils/timeout.ts
+function withTimeout(factory, ms, label) {
+  const controller = new AbortController();
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`[${label}] timed out (${ms / 1e3}s)`));
+    }, ms);
+  });
+  return Promise.race([factory(controller.signal), timeout]).finally(() => clearTimeout(timer));
+}
+
+// src/utils/prompt.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+async function renderPrompt(template, context, workDir) {
+  let result = template;
+  const fileMatches = [...template.matchAll(/\{\{file:([^}]+)\}\}/g)];
+  for (const match of fileMatches) {
+    const filePath = path.resolve(workDir, match[1].trim());
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      result = result.replace(match[0], content);
+    } catch {
+      result = result.replace(match[0], `[file not found: ${match[1]}]`);
+    }
+  }
+  for (const [key, value] of Object.entries(context)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+
+// src/orchestrator/AgentRunner.ts
+var AgentRunner = class {
+  constructor(eventBus, contextManager, globalWorkDir) {
+    this.eventBus = eventBus;
+    this.contextManager = contextManager;
+    this.globalWorkDir = globalWorkDir;
+  }
+  async run(agent) {
+    const startTime = /* @__PURE__ */ new Date();
+    const workDir = agent.workDir ? path2.resolve(this.globalWorkDir, agent.workDir) : this.globalWorkDir;
+    fs2.mkdirSync(workDir, { recursive: true });
+    const runtime = runtimeRegistry.get(agent.runtime ?? "claude");
+    const retries = agent.retries ?? 0;
+    const timeout = agent.timeout ?? 6e5;
+    const tools = agent.tools ?? ["Read", "Write", "Bash"];
+    const model = agent.model ?? agent.models?.[agent.runtime ?? "claude"];
+    this.eventBus.emit({
+      type: "agent:start",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: { agentId: agent.id, agentName: agent.name, icon: agent.icon, model, taskTitle: agent.taskTitle }
+    });
+    let attempts = 0;
+    let output = "";
+    try {
+      output = await withTimeout(
+        (signal) => withRetry(async (attempt) => {
+          attempts = attempt;
+          const prompt = await renderPrompt(
+            agent.taskPrompt,
+            this.contextManager.snapshot(),
+            this.globalWorkDir
+          );
+          return (await runtime.execute({
+            agentId: agent.id,
+            systemPrompt: agent.systemPrompt,
+            prompt,
+            tools,
+            workDir,
+            timeout,
+            signal,
+            model,
+            onOutput: (chunk) => {
+              this.eventBus.emit({
+                type: "agent:output",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                payload: { agentId: agent.id, chunk }
+              });
+            }
+          })).output;
+        }, retries, (attempt, err) => {
+          this.eventBus.emit({
+            type: "agent:retrying",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            payload: {
+              agentId: agent.id,
+              agentName: agent.name,
+              attempt,
+              maxAttempts: retries + 1,
+              error: err.message
+            }
+          });
+        }),
+        timeout,
+        agent.name
+      );
+      const endTime = /* @__PURE__ */ new Date();
+      const result = {
+        agentId: agent.id,
+        agentName: agent.name,
+        status: "success",
+        output,
+        duration: endTime.getTime() - startTime.getTime(),
+        attempts,
+        startTime: startTime.toISOString(),
+        endTime: endTime.toISOString()
+      };
+      this.eventBus.emit({
+        type: "agent:complete",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: result
+      });
+      return result;
+    } catch (err) {
+      const endTime = /* @__PURE__ */ new Date();
+      const result = {
+        agentId: agent.id,
+        agentName: agent.name,
+        status: "failed",
+        output,
+        duration: endTime.getTime() - startTime.getTime(),
+        attempts,
+        error: err.message,
+        startTime: startTime.toISOString(),
+        endTime: endTime.toISOString()
+      };
+      this.eventBus.emit({
+        type: "agent:failed",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: result
+      });
+      return result;
+    }
+  }
+};
+
+// src/orchestrator/StageBuilder.ts
+function buildStages(agents2) {
+  const stages = [];
+  const completed = /* @__PURE__ */ new Set();
+  let remaining = [...agents2];
+  const allIds = new Set(agents2.map((a) => a.id));
+  for (const a of agents2) {
+    for (const dep of a.dependsOn ?? []) {
+      if (!allIds.has(dep)) {
+        throw new Error(`Agent "${a.id}" depends on "${dep}" which does not exist`);
+      }
+    }
+  }
+  while (remaining.length > 0) {
+    const stage = remaining.filter(
+      (a) => (a.dependsOn ?? []).every((dep) => completed.has(dep))
+    );
+    if (stage.length === 0) {
+      const ids = remaining.map((a) => a.id).join(", ");
+      throw new Error(`Circular or unsatisfiable dependency detected: ${ids}`);
+    }
+    stages.push(stage);
+    stage.forEach((a) => completed.add(a.id));
+    remaining = remaining.filter((a) => !stage.includes(a));
+  }
+  return stages;
+}
+
+// src/orchestrator/Orchestrator.ts
+var Orchestrator = class {
+  constructor(config) {
+    this.config = config;
+    this.eventBus = new EventBus();
+    this.workDir = path3.resolve(config.workDir);
+    fs3.mkdirSync(this.workDir, { recursive: true });
+    this.contextManager = new ContextManager(config.context);
+    this.runner = new AgentRunner(this.eventBus, this.contextManager, this.workDir);
+  }
+  async run() {
+    const startTime = /* @__PURE__ */ new Date();
+    const agents2 = await this.resolveAgents();
+    this.contextManager.set(
+      "pipelineAgents",
+      agents2.map((a) => `${a.id}: ${a.name}`).join("\n")
+    );
+    let stages = buildStages(agents2);
+    const getModel = (agent) => {
+      return agent.model ?? agent.models?.[agent.runtime ?? "claude"];
+    };
+    const stageInfos = stages.map((stage, i) => ({
+      stageIndex: i,
+      agents: stage.map((a) => ({ id: a.id, name: a.name, icon: a.icon, model: getModel(a), taskTitle: a.taskTitle }))
+    }));
+    this.eventBus.emit({
+      type: "orchestration:start",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: { name: this.config.name, requirement: this.config.context?.requirement, totalAgents: agents2.length, stages: stageInfos }
+    });
+    const results = [];
+    let allSuccess = true;
+    for (let i = 0; i < stages.length; i++) {
+      const stage = stages[i];
+      this.eventBus.emit({
+        type: "stage:start",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: { stageIndex: i, agentIds: stage.map((a) => a.id) }
+      });
+      const stageResults = await this.runStage(stage);
+      results.push(...stageResults);
+      if (i === 0 && stage.some((a) => a.id === "architect") && stageResults.some((r) => r.status === "success")) {
+        await this.applyTaskPlan(agents2);
+        stages = buildStages(agents2);
+      }
+      for (const r of stageResults) {
+        if (r.status !== "success") {
+          allSuccess = false;
+          if (!this.config.continueOnError) break;
+        }
+      }
+      this.eventBus.emit({
+        type: "stage:complete",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: { stageIndex: i }
+      });
+      if (!allSuccess && !this.config.continueOnError) {
+        for (const remainingStage of stages.slice(i + 1)) {
+          for (const agent of remainingStage) {
+            this.eventBus.emit({
+              type: "agent:skipped",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              payload: { agentId: agent.id, agentName: agent.name, icon: agent.icon }
+            });
+          }
+        }
+        break;
+      }
+    }
+    const endTime = /* @__PURE__ */ new Date();
+    const result = {
+      name: this.config.name,
+      success: allSuccess,
+      totalDuration: endTime.getTime() - startTime.getTime(),
+      agentResults: results,
+      startTime: startTime.toISOString(),
+      endTime: endTime.toISOString()
+    };
+    this.eventBus.emit({
+      type: "orchestration:complete",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: result
+    });
+    return result;
+  }
+  async resolveAgents() {
+    if (!this.config.leader || this.config.useLeader === false) return this.config.agents;
+    this.contextManager.set(
+      "availableAgents",
+      this.config.agents.map((a) => `${a.id}: ${a.name}`).join("\n")
+    );
+    const result = await this.runner.run(this.config.leader);
+    if (result.status !== "success") return this.config.agents;
+    const match = result.output.match(/\{[\s\S]*?"run"\s*:\s*\[[\s\S]*?\]\s*\}/);
+    if (!match) return this.config.agents;
+    let plan;
+    try {
+      plan = JSON.parse(match[0]);
+    } catch {
+      return this.config.agents;
+    }
+    const runSet = new Set(plan.run);
+    const skippedIds = new Set(
+      this.config.agents.filter((a) => !runSet.has(a.id)).map((a) => a.id)
+    );
+    for (const agent of this.config.agents.filter((a) => skippedIds.has(a.id))) {
+      this.eventBus.emit({
+        type: "agent:skipped",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: { agentId: agent.id, agentName: agent.name, icon: agent.icon }
+      });
+    }
+    return this.config.agents.filter((a) => runSet.has(a.id)).map((a) => ({
+      ...a,
+      dependsOn: a.dependsOn?.filter((dep) => !skippedIds.has(dep))
+    }));
+  }
+  async runStage(agents2) {
+    const { maxConcurrency } = this.config;
+    if (!maxConcurrency || agents2.length <= maxConcurrency) {
+      return Promise.all(agents2.map((a) => this.runner.run(a)));
+    }
+    const results = [];
+    for (let i = 0; i < agents2.length; i += maxConcurrency) {
+      const batch = agents2.slice(i, i + maxConcurrency);
+      results.push(...await Promise.all(batch.map((a) => this.runner.run(a))));
+    }
+    return results;
+  }
+  async applyTaskPlan(agents2) {
+    try {
+      const taskPlanPath = path3.join(this.workDir, "task-plan.json");
+      if (!fs3.existsSync(taskPlanPath)) return;
+      const content = fs3.readFileSync(taskPlanPath, "utf-8");
+      const taskPlan = JSON.parse(content);
+      const taskMap = new Map(taskPlan.tasks.map((t) => [t.id, t]));
+      for (const agent of agents2) {
+        const task = taskMap.get(agent.id);
+        if (task) {
+          agent.taskTitle = task.title;
+          agent.dependsOn = task.dependsOn;
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/config/defineConfig.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/agents/leader.ts
+var SYSTEM = `You are the project leader. Analyze the requirement and the current state of the codebase, then decide the minimum set of agents needed to complete the task.
+
+Do not apply fixed rules \u2014 use your judgment based on the actual requirement and code. A minor bug fix may need only a developer and code-reviewer; a complex new feature may need the full pipeline. Read the code to understand the impact before deciding.
+
+Output ONLY a single JSON object on its own line \u2014 no prose, no markdown fences:
+{"run": ["agent-id-1", "agent-id-2"]}`;
+var TASK = `## Project
+{{projectName}}
+
+## Requirement
+{{requirement}}
+
+## Available Agents
+{{availableAgents}}
+
+## Task
+Read the codebase to understand the current state, then decide which agents to run.
+Output a single JSON object: {"run": ["agent-id-1", ...]}
+Agent IDs must come from the Available Agents list above.`;
+function leader(overrides) {
+  return {
+    id: "leader",
+    name: "Leader",
+    icon: "\u2605",
+    models: { claude: "sonnet" },
+    systemPrompt: SYSTEM,
+    taskPrompt: TASK,
+    tools: ["Read", "Bash"],
+    ...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
+
+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>",
+      "dependsOn": ["<other agent id>"]
+    }
+  ]
+}
+
+Rules for task-plan.json:
+- Only create tasks for implementation agents (those that produce code, designs, or infrastructure). Skip review agents (code-reviewer, arch-design-reviewer, ui-design-reviewer, reviewer) and planning agents (product-manager, architect, leader).
+- Use the exact agent id from pipelineAgents as the task id.
+- If an agent is not in pipelineAgents, do not create a task for it.
+- dependsOn references other task ids, not agent names.
+
+Principles: Execute tasks directly without asking for confirmation. If information is missing, mark the file with BLOCKED and describe what is needed. Do not change the requirement scope. Do not write business feature code. Do not refactor beyond the task scope.`;
+var TASK2 = `## Project
+{{projectName}}
+
+## Requirement
+{{requirement}}
+
+## Pipeline Agents
+The following agents will run in this pipeline (id: name):
+{{pipelineAgents}}
+
+## Task
+Analyze the requirement and create three files in the current directory:
+1. architecture.md \u2014 architecture plan (module breakdown, directory structure, technology choices, key component descriptions, affected scope)
+2. api-spec.md \u2014 complete API specification (paths, methods, request parameters, response formats, status codes, error handling)
+3. task-plan.json \u2014 task breakdown for each implementation agent listed in the pipeline above
+
+For task-plan.json: create one task per implementation agent (skip reviewers and planners). Each task's scope should be concrete enough that the agent knows exactly what to build without ambiguity. Set dependsOn to reflect actual execution order constraints (e.g. devops depends on backend and frontend).
+
+Create the files directly. No extra output.`;
+function architect(overrides) {
+  return {
+    id: "architect",
+    name: "Architect",
+    icon: "\u25C6",
+    models: { claude: "opus" },
+    systemPrompt: SYSTEM2,
+    taskPrompt: TASK2,
+    tools: ["Read", "Write"],
+    ...overrides
+  };
+}
+
+// src/agents/product-manager.ts
+var SYSTEM3 = `You are the product manager. Your responsibility is to transform vague business ideas into clear, development-ready, testable product requirement documents.
+
+Responsibilities:
+- Analyze business goals and user scenarios
+- Define feature scope, business rules, and acceptance criteria
+- Structure "what is needed" into a PRD that the development team can execute directly
+
+Deliverables (save to the working directory):
+- requirements.md \u2014 product requirements document containing: one-line definition, goals and success metrics, user roles, functional requirements (FR-), business rules (BR-), acceptance criteria (AC-), open questions (OP-)
+
+Principles: Output the document directly without preamble. Mark uncertain items as OP- (open questions) rather than guessing. Do not do technical architecture design. Do not write feature code.`;
+var TASK3 = `## Business Context
+{{requirement}}
+
+## Task
+Based on the context above, create requirements.md in the current directory containing:
+- One-line definition (what this product/feature is)
+- Goals and success metrics
+- User roles and typical scenarios
+- Functional requirements (FR-01, FR-02, ...)
+- Business rules (BR-01, ...)
+- Acceptance criteria (AC-01, ..., each must be executable and verifiable)
+- Open questions (OP-01, ..., list uncertain items here)
+
+Create the file directly. Mark uncertain items as OP- rather than guessing.`;
+function productManager(overrides) {
+  return {
+    id: "product-manager",
+    name: "Product Manager",
+    icon: "\u2261",
+    models: { claude: "sonnet" },
+    systemPrompt: SYSTEM3,
+    taskPrompt: TASK3,
+    tools: ["Write"],
+    ...overrides
+  };
+}
+
+// src/agents/backend-developer.ts
+var SYSTEM4 = `You are the backend engineer. You own the API contract and all server-side logic.
+
+Responsibilities:
+- Read the architecture design and API specification, implement server-side logic and data models
+- Write backend tests (unit tests / integration tests)
+- Run validation commands (compile, lint, test) and record the results
+
+Deliverables (write code to the working directory, and record in implementation-notes.md):
+- List of files created or modified
+- Commands actually executed and their output
+- Known issues and risks
+
+Principles: Write code directly without asking for confirmation. Follow the API spec strictly \u2014 do not change the contract unilaterally; escalate contract issues upstream. Do not refactor unrelated code. Run commands and report evidence.`;
+var TASK4 = `## Task Scope
+{{file:task-plan.json}}
+
+Find the entry where id == "backend-developer" and treat its scope as the primary guide for your work.
+If task-plan.json is not found, determine your scope from the architecture design and API specification below.
+
+---
+
+## 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",
+    models: { claude: "sonnet" },
+    systemPrompt: SYSTEM4,
+    taskPrompt: TASK4,
+    tools: ["Read", "Write", "Bash"],
+    ...overrides
+  };
+}
+
+// src/agents/frontend-developer.ts
+var SYSTEM5 = `You are the frontend engineer. Your responsibility is to turn design specs and API contracts into a working user interface.
+
+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 TASK5 = `## Task Scope
+{{file:task-plan.json}}
+
+Find the entry where id == "frontend-developer" and treat its scope as the primary guide for your work.
+If task-plan.json is not found, determine your scope from the UI design specification and architecture design below.
+
+---
+
+## 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",
+    models: { claude: "sonnet" },
+    systemPrompt: SYSTEM5,
+    taskPrompt: TASK5,
+    tools: ["Read", "Write", "Bash"],
+    ...overrides
+  };
+}
+
+// src/agents/tester.ts
+var SYSTEM6 = `You are the test engineer. Your responsibility is to verify that requirements have actually been implemented.
+
+Responsibilities:
+- Read requirements (acceptance criteria AC-) and the implementation code
+- Write and execute test cases covering: happy path, edge cases, error paths
+- Produce a reproducible test report
+
+Deliverables (save to the working directory):
+- test-report.md \u2014 overall verdict (PASS / FAIL / BLOCKED), test results per feature, reproduction steps and evidence for failures
+
+Principles: Do not PASS just because the code compiles or because a developer says it is fine. Every core feature must be verified with actual execution. When BLOCKED, state exactly what is missing.`;
+var TASK6 = `## Task Scope
+{{file:task-plan.json}}
+
+Find the entry where id == "tester" and treat its scope as the primary guide for what features to verify.
+If task-plan.json is not found, verify all features described in the requirement below.
+
+---
+
+## 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",
+    models: { claude: "sonnet" },
+    systemPrompt: SYSTEM6,
+    taskPrompt: TASK6,
+    tools: ["Read", "Write", "Bash"],
+    ...overrides
+  };
+}
+
+// src/agents/reviewer.ts
+var SYSTEM7 = `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 TASK7 = `## Project
+{{projectName}}
+
+## Requirement
+{{requirement}}
+
+## 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",
+    models: { claude: "haiku" },
+    systemPrompt: SYSTEM7,
+    taskPrompt: TASK7,
+    tools: ["Read", "Write"],
+    ...overrides
+  };
+}
+
+// src/agents/arch-design-reviewer.ts
+var SYSTEM8 = `You are an architecture design reviewer. Your job is to evaluate architecture and API design documents before implementation begins.
+
+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 TASK8 = `## Architecture Design
+{{file:architecture.md}}
+
+## API Specification
+{{file:api-spec.md}}
+
+## Task
+Review the architecture design and API specification above. Output arch-review.md:
+1. Overall verdict: Approved / Changes Required
+2. Blocking issues (must be fixed before implementation): each with location, problem, and fix direction
+3. Advisory issues (should fix but not blocking): each with location and suggestion
+4. Design strengths worth noting
+5. Final summary (1\u20132 sentences)
+
+Be specific. Reference section names or endpoint paths when citing issues.`;
+function archDesignReviewer(overrides) {
+  return {
+    id: "arch-design-reviewer",
+    name: "Arch Design Reviewer",
+    icon: "\u25B3",
+    models: { claude: "haiku" },
+    systemPrompt: SYSTEM8,
+    taskPrompt: TASK8,
+    tools: ["Read", "Write"],
+    ...overrides
+  };
+}
+
+// src/agents/ui-designer.ts
+var SYSTEM9 = `You are a UI/UX designer. Your job is to translate architecture and requirements into a detailed, developer-ready UI design specification.
+
+Responsibilities:
+- Define the component inventory: every page, section, and reusable component
+- Specify layouts, spacing principles, and responsive breakpoints
+- Define interaction patterns: loading states, empty states, error states, transitions
+- Specify design tokens: color palette, typography scale, spacing scale, shadow levels
+- Describe accessibility requirements: ARIA roles, keyboard navigation, focus management
+- Do not write implementation code \u2014 produce specification documents only
+
+Deliverables (save to the working directory):
+- ui-design.md \u2014 full UI design specification: component inventory, page layouts, interaction flows, design tokens, accessibility requirements
+
+Principles: Be specific enough that a developer can implement without guessing. Every component gets a name, purpose, props/variants, and states. Flag anything that depends on backend data.`;
+var TASK9 = `## Task Scope
+{{file:task-plan.json}}
+
+Find the entry where id == "ui-designer" and treat its scope as the primary guide for your work.
+If task-plan.json is not found, determine your scope from the architecture design and API specification below.
+
+---
+
+## Project
+{{projectName}}
+
+## 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",
+    models: { claude: "sonnet" },
+    systemPrompt: SYSTEM9,
+    taskPrompt: TASK9,
+    tools: ["Read", "Write"],
+    ...overrides
+  };
+}
+
+// src/agents/ui-design-reviewer.ts
+var SYSTEM10 = `You are a UI/UX design reviewer. Your job is to evaluate a UI design specification before implementation begins.
+
+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 TASK10 = `## Requirement
+{{requirement}}
+
+## UI Design Specification
+{{file:ui-design.md}}
+
+## 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",
+    models: { claude: "haiku" },
+    systemPrompt: SYSTEM10,
+    taskPrompt: TASK10,
+    tools: ["Read", "Write"],
+    ...overrides
+  };
+}
+
+// src/agents/code-reviewer.ts
+var SYSTEM11 = `You are a code review expert focused on implementation quality, correctness, and security.
+
+Responsibilities:
+- Read the requirement, architecture design, and all implementation code
+- Verify the implementation matches the API specification and satisfies the requirement
+- Identify bugs, security vulnerabilities, error handling gaps, and test coverage issues
+- Assess code quality: readability, naming, separation of concerns, duplication
+- Do not run code, do not modify code \u2014 provide written judgment only
+
+Deliverables (save to the working directory):
+- code-review.md \u2014 score (1\u201310), blocking issues, advisory issues, conclusion (Approved / Changes Required)
+
+Principles: Judge the code, not the developer. A blocking issue must include the file path, the specific problem, and a fix direction. Advisory items should be actionable, not vague. If the code is solid, say so.`;
+var TASK11 = `## Project
+{{projectName}}
+
+## Requirement
+{{requirement}}
+
+## Architecture Design
+{{file:architecture.md}}
+
+## API Specification
+{{file:api-spec.md}}
+
+## Task
+Perform a thorough code review of all implementation in the current directory and output code-review.md:
+1. Overall score (1\u201310) and verdict: Approved / Changes Required
+2. Blocking issues (bugs, security holes, missing requirement coverage, broken tests):
+   - file path + line range, problem description, fix direction
+3. Advisory issues (code quality, naming, duplication, missing error handling):
+   - file path, observation, suggestion
+4. Test coverage assessment
+5. Final summary (2\u20133 sentences)
+
+Start by reading implementation-notes.md (if present), then read source and test files.`;
+function codeReviewer(overrides) {
+  return {
+    id: "code-reviewer",
+    name: "Code Reviewer",
+    icon: "\u2297",
+    models: { claude: "haiku" },
+    systemPrompt: SYSTEM11,
+    taskPrompt: TASK11,
+    tools: ["Read", "Write"],
+    ...overrides
+  };
+}
+
+// src/agents/devops.ts
+var SYSTEM12 = `You are the DevOps engineer. Your job is to containerize the application, set up CI/CD pipelines, and produce deployment-ready infrastructure configuration.
+
+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 TASK12 = `## Task Scope
+{{file:task-plan.json}}
+
+Find the entry where id == "devops" and treat its scope as the primary guide for your work.
+If task-plan.json is not found, determine your scope from the architecture design below.
+
+---
+
+## 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",
+    models: { claude: "sonnet" },
+    systemPrompt: SYSTEM12,
+    taskPrompt: TASK12,
+    tools: ["Read", "Write"],
+    ...overrides
+  };
+}
+
+// src/agents/index.ts
+var agents = {
+  leader,
+  architect,
+  productManager,
+  backendDeveloper,
+  frontendDeveloper,
+  tester,
+  reviewer,
+  archDesignReviewer,
+  uiDesigner,
+  uiDesignReviewer,
+  codeReviewer,
+  devops
+};
+export {
+  ClaudeRuntime,
+  EventBus,
+  Orchestrator,
+  RuntimeBase,
+  agents,
+  buildStages,
+  defineConfig,
+  runtimeRegistry
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiclawcli/core",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,12 +16,11 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {},
   "devDependencies": {
-    "typescript": "^5.4.0",
-    "@types/node": "^20.11.0"
+    "@types/node": "^20.11.0",
+    "typescript": "^5.4.0"
   },
   "scripts": {
-    "build": "tsc"
+    "build": "tsup"
   }
 }

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "composite": false,
+    "incremental": false
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsup"
+
+export default defineConfig({
+  entry: { index: "src/index.ts" },
+  format: ["esm"],
+  outDir: "dist",
+  dts: { compilerOptions: { composite: false, incremental: false } },
+  clean: true,
+  shims: true,
+})