@multiclawcli/core 0.1.0 → 0.2.0

package/README.md

@@ -0,0 +1,16 @@
+# @multiclawcli/core
+
+[![npm](https://img.shields.io/npm/v/@multiclawcli/core)](https://www.npmjs.com/package/@multiclawcli/core)
+[![GitHub](https://img.shields.io/badge/GitHub-shipengqi%2Fmulticlaw-blue?logo=github)](https://github.com/shipengqi/multiclaw)
+
+Core runtime for [multiclaw](https://github.com/shipengqi/multiclaw) — the multi-agent orchestration CLI.
+
+This package provides the agent runner, orchestrator, event bus, and runtime abstractions used internally by the `multiclaw` CLI. It is not intended for direct use; install [`multiclaw`](https://www.npmjs.com/package/multiclaw) instead.
+
+## Documentation
+
+Full documentation is available in the [main repository](https://github.com/shipengqi/multiclaw).
+
+## License
+
+[MIT](https://github.com/shipengqi/multiclaw/blob/main/LICENSE)

package/dist/index.js

@@ -2,7 +2,7 @@ export * from "./types";
 export { EventBus } from "./event/EventBus";
 export { Orchestrator } from "./orchestrator/Orchestrator";
 export { buildStages } from "./orchestrator/StageBuilder";
-export { runtimeRegistry, ClaudeRuntime, CodexRuntime, OpenCodeRuntime, CursorRuntime } from "./runtime";
+export { runtimeRegistry, ClaudeRuntime } from "./runtime";
 export { RuntimeBase } from "./runtime/RuntimeBase";
 export { defineConfig } from "./config/defineConfig";
 export { agents } from "./agents";

package/package.json

@@ -1,9 +1,18 @@
 {
   "name": "@multiclawcli/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shipengqi/multiclaw.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/shipengqi/multiclaw#readme",
+  "bugs": {
+    "url": "https://github.com/shipengqi/multiclaw/issues"
+  },
   "publishConfig": {
     "access": "public"
   },

package/src/agents/arch-design-reviewer.ts

@@ -36,6 +36,7 @@ export function archDesignReviewer(overrides?: Overrides): AgentDefinition {
     id: "arch-design-reviewer",
     name: "Arch Design Reviewer",
     icon: "△",
+    models: { claude: "haiku" },
     systemPrompt: SYSTEM,
     taskPrompt: TASK,
     tools: ["Read", "Write"],

package/src/agents/architect.ts

@@ -9,10 +9,32 @@ Responsibilities:
 - 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 — architecture plan (module breakdown, directory structure, technology choices, key component descriptions)
 - api-spec.md — complete API specification (paths, methods, request/response formats, status codes, error handling)
+- task-plan.json — 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.`
 
@@ -22,10 +44,17 @@ const TASK = `## Project
 ## Requirement
 {{requirement}}
 
+## Pipeline Agents
+The following agents will run in this pipeline (id: name):
+{{pipelineAgents}}
+
 ## Task
-Analyze the requirement and create two files in the current directory:
+Analyze the requirement and create three files in the current directory:
 1. architecture.md — architecture plan (module breakdown, directory structure, technology choices, key component descriptions, affected scope)
 2. api-spec.md — complete API specification (paths, methods, request parameters, response formats, status codes, error handling)
+3. task-plan.json — 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.`
 
@@ -34,6 +63,7 @@ export function architect(overrides?: Overrides): AgentDefinition {
     id: "architect",
     name: "Architect",
     icon: "◆",
+    models: { claude: "opus" },
     systemPrompt: SYSTEM,
     taskPrompt: TASK,
     tools: ["Read", "Write"],

package/src/agents/backend-developer.ts

@@ -16,7 +16,15 @@ Deliverables (write code to the working directory, and record in implementation-
 
 Principles: Write code directly without asking for confirmation. Follow the API spec strictly — do not change the contract unilaterally; escalate contract issues upstream. Do not refactor unrelated code. Run commands and report evidence.`
 
-const TASK = `## Architecture Design
+const TASK = `## 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
@@ -37,6 +45,7 @@ export function backendDeveloper(overrides?: Overrides): AgentDefinition {
     id: "backend-developer",
     name: "Backend Developer",
     icon: "⊕",
+    models: { claude: "sonnet" },
     systemPrompt: SYSTEM,
     taskPrompt: TASK,
     tools: ["Read", "Write", "Bash"],

package/src/agents/code-reviewer.ts

@@ -45,6 +45,7 @@ export function codeReviewer(overrides?: Overrides): AgentDefinition {
     id: "code-reviewer",
     name: "Code Reviewer",
     icon: "⊗",
+    models: { claude: "haiku" },
     systemPrompt: SYSTEM,
     taskPrompt: TASK,
     tools: ["Read", "Write"],

package/src/agents/devops.ts

@@ -21,7 +21,15 @@ Deliverables (save to the working directory):
 
 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.`
 
-const TASK = `## Project
+const TASK = `## 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
@@ -42,6 +50,7 @@ export function devops(overrides?: Overrides): AgentDefinition {
     id: "devops",
     name: "DevOps",
     icon: "▶",
+    models: { claude: "sonnet" },
     systemPrompt: SYSTEM,
     taskPrompt: TASK,
     tools: ["Read", "Write"],

package/src/agents/frontend-developer.ts

@@ -13,7 +13,15 @@ Deliverables (write code to the working directory, and record results in impleme
 
 Principles: Write code directly without asking for confirmation. Do not change the API contract — escalate contract issues upstream. Do not refactor unrelated code. Run commands and report evidence.`
 
-const TASK = `## UI Design Specification
+const TASK = `## 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
@@ -39,6 +47,7 @@ export function frontendDeveloper(overrides?: Overrides): AgentDefinition {
     id: "frontend-developer",
     name: "Frontend Developer",
     icon: "◇",
+    models: { claude: "sonnet" },
     systemPrompt: SYSTEM,
     taskPrompt: TASK,
     tools: ["Read", "Write", "Bash"],

package/src/agents/index.ts

@@ -1,3 +1,4 @@
+import { leader } from "./leader"
 import { architect } from "./architect"
 import { productManager } from "./product-manager"
 import { backendDeveloper } from "./backend-developer"
@@ -11,6 +12,7 @@ import { codeReviewer } from "./code-reviewer"
 import { devops } from "./devops"
 
 export const agents = {
+  leader,
   architect,
   productManager,
   backendDeveloper,

package/src/agents/leader.ts

@@ -0,0 +1,37 @@
+import type { AgentDefinition } from "../types/agent"
+
+type Overrides = Partial<AgentDefinition>
+
+const 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 — 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 — no prose, no markdown fences:
+{"run": ["agent-id-1", "agent-id-2"]}`
+
+const 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.`
+
+export function leader(overrides?: Overrides): AgentDefinition {
+  return {
+    id: "leader",
+    name: "Leader",
+    icon: "★",
+    models: { claude: "sonnet" },
+    systemPrompt: SYSTEM,
+    taskPrompt: TASK,
+    tools: ["Read", "Bash"],
+    ...overrides,
+  }
+}

package/src/agents/product-manager.ts

@@ -34,6 +34,7 @@ export function productManager(overrides?: Overrides): AgentDefinition {
     id: "product-manager",
     name: "Product Manager",
     icon: "≡",
+    models: { claude: "sonnet" },
     systemPrompt: SYSTEM,
     taskPrompt: TASK,
     tools: ["Write"],

package/src/agents/reviewer.ts

@@ -38,6 +38,7 @@ export function reviewer(overrides?: Overrides): AgentDefinition {
     id: "reviewer",
     name: "Reviewer",
     icon: "◉",
+    models: { claude: "haiku" },
     systemPrompt: SYSTEM,
     taskPrompt: TASK,
     tools: ["Read", "Write"],

package/src/agents/tester.ts

@@ -14,7 +14,15 @@ Deliverables (save to the working directory):
 
 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.`
 
-const TASK = `## Project
+const TASK = `## 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
@@ -36,6 +44,7 @@ export function tester(overrides?: Overrides): AgentDefinition {
     id: "tester",
     name: "Tester",
     icon: "⊙",
+    models: { claude: "sonnet" },
     systemPrompt: SYSTEM,
     taskPrompt: TASK,
     tools: ["Read", "Write", "Bash"],

package/src/agents/ui-design-reviewer.ts

@@ -39,6 +39,7 @@ export function uiDesignReviewer(overrides?: Overrides): AgentDefinition {
     id: "ui-design-reviewer",
     name: "UI Design Reviewer",
     icon: "◎",
+    models: { claude: "haiku" },
     systemPrompt: SYSTEM,
     taskPrompt: TASK,
     tools: ["Read", "Write"],

package/src/agents/ui-designer.ts

@@ -17,7 +17,15 @@ Deliverables (save to the working directory):
 
 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.`
 
-const TASK = `## Project
+const TASK = `## 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
@@ -44,6 +52,7 @@ export function uiDesigner(overrides?: Overrides): AgentDefinition {
     id: "ui-designer",
     name: "UI Designer",
     icon: "▣",
+    models: { claude: "sonnet" },
     systemPrompt: SYSTEM,
     taskPrompt: TASK,
     tools: ["Read", "Write"],

package/src/index.ts

@@ -2,7 +2,7 @@ export * from "./types"
 export { EventBus } from "./event/EventBus"
 export { Orchestrator } from "./orchestrator/Orchestrator"
 export { buildStages } from "./orchestrator/StageBuilder"
-export { runtimeRegistry, ClaudeRuntime, CodexRuntime, OpenCodeRuntime, CursorRuntime } from "./runtime"
+export { runtimeRegistry, ClaudeRuntime } from "./runtime"
 export { RuntimeBase } from "./runtime/RuntimeBase"
 export { defineConfig } from "./config/defineConfig"
 export { agents } from "./agents"

package/src/orchestrator/AgentRunner.ts

@@ -26,11 +26,12 @@ export class AgentRunner {
     const retries = agent.retries ?? 0
     const timeout = agent.timeout ?? 600_000
     const tools = agent.tools ?? ["Read", "Write", "Bash"]
+    const model = agent.model ?? agent.models?.[agent.runtime ?? "claude"]
 
     this.eventBus.emit({
       type: "agent:start",
       timestamp: new Date().toISOString(),
-      payload: { agentId: agent.id, agentName: agent.name, icon: agent.icon },
+      payload: { agentId: agent.id, agentName: agent.name, icon: agent.icon, model, taskTitle: agent.taskTitle },
     })
 
     let attempts = 0
@@ -49,6 +50,7 @@ export class AgentRunner {
             agentId: agent.id,
             systemPrompt: agent.systemPrompt,
             prompt, tools, workDir, timeout, signal,
+            model,
             onOutput: (chunk) => {
               this.eventBus.emit({
                 type: "agent:output",

package/src/orchestrator/Orchestrator.ts

@@ -1,7 +1,7 @@
 import * as fs from "fs"
 import * as path from "path"
 import type { MultiClawConfig, OrchestratorResult } from "../types/config"
-import type { AgentDefinition, AgentResult } from "../types/agent"
+import type { AgentDefinition, AgentResult, TaskPlan } from "../types/agent"
 import type { StageInfo } from "../types/event"
 import { EventBus } from "../event/EventBus"
 import { ContextManager } from "./ContextManager"
@@ -23,17 +23,27 @@ export class Orchestrator {
 
   async run(): Promise<OrchestratorResult> {
     const startTime = new Date()
-    const stages = buildStages(this.config.agents)
+    const agents = await this.resolveAgents()
+    this.contextManager.set(
+      "pipelineAgents",
+      agents.map((a) => `${a.id}: ${a.name}`).join("\n")
+    )
+
+    let stages = buildStages(agents)
+
+    const getModel = (agent: AgentDefinition): string | undefined => {
+      return agent.model ?? agent.models?.[agent.runtime ?? "claude"]
+    }
 
     const stageInfos: StageInfo[] = stages.map((stage, i) => ({
       stageIndex: i,
-      agents: stage.map((a) => ({ id: a.id, name: a.name, icon: a.icon })),
+      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: new Date().toISOString(),
-      payload: { name: this.config.name, totalAgents: this.config.agents.length, stages: stageInfos },
+      payload: { name: this.config.name, requirement: this.config.context?.requirement, totalAgents: agents.length, stages: stageInfos },
     })
 
     const results: AgentResult[] = []
@@ -41,6 +51,7 @@ export class Orchestrator {
 
     for (let i = 0; i < stages.length; i++) {
       const stage = stages[i]
+
       this.eventBus.emit({
         type: "stage:start", timestamp: new Date().toISOString(),
         payload: { stageIndex: i, agentIds: stage.map((a) => a.id) },
@@ -49,6 +60,12 @@ export class Orchestrator {
       const stageResults = await this.runStage(stage)
       results.push(...stageResults)
 
+      // After architect stage completes, apply task plan and rebuild stages
+      if (i === 0 && stage.some((a) => a.id === "architect") && stageResults.some((r) => r.status === "success")) {
+        await this.applyTaskPlan(agents)
+        stages = buildStages(agents)
+      }
+
       for (const r of stageResults) {
         if (r.status !== "success") {
           allSuccess = false
@@ -89,6 +106,44 @@ export class Orchestrator {
     return result
   }
 
+  private async resolveAgents(): Promise<AgentDefinition[]> {
+    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: { run: string[] }
+    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: 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)),
+      }))
+  }
+
   private async runStage(agents: AgentDefinition[]): Promise<AgentResult[]> {
     const { maxConcurrency } = this.config
     if (!maxConcurrency || agents.length <= maxConcurrency) {
@@ -101,4 +156,25 @@ export class Orchestrator {
     }
     return results
   }
+
+  private async applyTaskPlan(agents: AgentDefinition[]): Promise<void> {
+    try {
+      const taskPlanPath = path.join(this.workDir, "task-plan.json")
+      if (!fs.existsSync(taskPlanPath)) return
+
+      const content = fs.readFileSync(taskPlanPath, "utf-8")
+      const taskPlan: TaskPlan = JSON.parse(content)
+
+      const taskMap = new Map(taskPlan.tasks.map((t) => [t.id, t]))
+      for (const agent of agents) {
+        const task = taskMap.get(agent.id)
+        if (task) {
+          agent.taskTitle = task.title
+          agent.dependsOn = task.dependsOn
+        }
+      }
+    } catch {
+      // Silently ignore parsing errors
+    }
+  }
 }

package/src/runtime/ClaudeRuntime.ts

@@ -16,6 +16,7 @@ export class ClaudeRuntime extends RuntimeBase {
       "--allowedTools", task.tools.join(","),
     ]
     if (task.systemPrompt) args.push("--system-prompt", task.systemPrompt)
+    if (task.model) args.push("--model", task.model)
 
     return new Promise((resolve, reject) => {
       const child = spawn("claude", args, { cwd: task.workDir, env: process.env })

package/src/runtime/index.ts

@@ -1,16 +1,10 @@
 import type { AgentRuntime } from "../types/runtime"
 import { ClaudeRuntime } from "./ClaudeRuntime"
-import { CodexRuntime } from "./CodexRuntime"
-import { OpenCodeRuntime } from "./OpenCodeRuntime"
-import { CursorRuntime } from "./CursorRuntime"
 
 class RuntimeRegistry {
   private runtimes = new Map<string, AgentRuntime>()
   constructor() {
     this.register(new ClaudeRuntime())
-    this.register(new CodexRuntime())
-    this.register(new OpenCodeRuntime())
-    this.register(new CursorRuntime())
   }
   register(r: AgentRuntime) { this.runtimes.set(r.name, r) }
   get(name: string): AgentRuntime {
@@ -23,4 +17,4 @@ class RuntimeRegistry {
 }
 
 export const runtimeRegistry = new RuntimeRegistry()
-export { ClaudeRuntime, CodexRuntime, OpenCodeRuntime, CursorRuntime }
+export { ClaudeRuntime }

package/src/types/agent.ts

@@ -7,8 +7,11 @@ export interface AgentDefinition {
   name: string
   icon?: string
   runtime?: string
+  model?: string
+  models?: Partial<Record<string, string>>
   systemPrompt: string
   taskPrompt: string
+  taskTitle?: string
   tools?: ToolName[]
   dependsOn?: string[]
   timeout?: number
@@ -30,3 +33,16 @@ export interface AgentResult {
   startTime: string
   endTime: string
 }
+
+export interface SubTask {
+  id: string       // matches AgentDefinition.id
+  title: string
+  scope: string
+  dependsOn?: string[]
+}
+
+export interface TaskPlan {
+  projectName: string
+  requirement: string
+  tasks: SubTask[]
+}

package/src/types/config.ts

@@ -3,11 +3,13 @@ import type { AgentDefinition } from "./agent"
 export interface MultiClawConfig {
   name: string
   workDir: string
+  leader?: AgentDefinition
   agents: AgentDefinition[]
   context?: Record<string, string>
   logDir?: string
   continueOnError?: boolean
   maxConcurrency?: number
+  useLeader?: boolean
   dashboard?: {
     port?: number
     autoOpen?: boolean

package/src/types/event.ts

@@ -2,15 +2,15 @@ import type { AgentResult, OrchestratorResult } from "./index"
 
 export interface StageInfo {
   stageIndex: number
-  agents: Array<{ id: string; name: string; icon?: string }>
+  agents: Array<{ id: string; name: string; icon?: string; model?: string; taskTitle?: string }>
 }
 
 export type MultiClawEvent =
-  | { type: "orchestration:start";    timestamp: string; payload: { name: string; totalAgents: number; stages: StageInfo[] } }
+  | { type: "orchestration:start";    timestamp: string; payload: { name: string; requirement?: string; totalAgents: number; stages: StageInfo[] } }
   | { type: "orchestration:complete"; timestamp: string; payload: OrchestratorResult }
   | { type: "stage:start";            timestamp: string; payload: { stageIndex: number; agentIds: string[] } }
   | { type: "stage:complete";         timestamp: string; payload: { stageIndex: number } }
-  | { type: "agent:start";            timestamp: string; payload: { agentId: string; agentName: string; icon?: string } }
+  | { type: "agent:start";            timestamp: string; payload: { agentId: string; agentName: string; icon?: string; model?: string; taskTitle?: string } }
   | { type: "agent:output";           timestamp: string; payload: { agentId: string; chunk: string } }
   | { type: "agent:complete";         timestamp: string; payload: AgentResult }
   | { type: "agent:failed";           timestamp: string; payload: AgentResult }

package/src/types/runtime.ts

@@ -7,6 +7,7 @@ export interface AgentTask {
   timeout: number
   signal?: AbortSignal
   onOutput?: (chunk: string) => void
+  model?: string
 }
 
 export interface AgentOutput {

package/dist/agents/arch-design-reviewer.d.ts

@@ -1,4 +0,0 @@
-import type { AgentDefinition } from "../types/agent";
-type Overrides = Partial<AgentDefinition>;
-export declare function archDesignReviewer(overrides?: Overrides): AgentDefinition;
-export {};

package/dist/agents/arch-design-reviewer.js

@@ -1,39 +0,0 @@
-const 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 — provide only design-level feedback
-
-Deliverables (save to the working directory):
-- arch-review.md — verdict (Approved / Changes Required), issue list (blocking / advisory) with specific locations and suggested fixes, overall assessment
-
-Principles: Be precise — 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.`;
-const TASK = `## 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–2 sentences)
-
-Be specific. Reference section names or endpoint paths when citing issues.`;
-export function archDesignReviewer(overrides) {
-    return {
-        id: "arch-design-reviewer",
-        name: "Arch Design Reviewer",
-        icon: "△",
-        systemPrompt: SYSTEM,
-        taskPrompt: TASK,
-        tools: ["Read", "Write"],
-        ...overrides,
-    };
-}
-//# sourceMappingURL=arch-design-reviewer.js.map

package/dist/agents/arch-design-reviewer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"arch-design-reviewer.js","sourceRoot":"","sources":["../../src/agents/arch-design-reviewer.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,GAAG;;;;;;;;;;;0MAW2L,CAAA;AAE1M,MAAM,IAAI,GAAG;;;;;;;;;;;;;;2EAc8D,CAAA;AAE3E,MAAM,UAAU,kBAAkB,CAAC,SAAqB;IACtD,OAAO;QACL,EAAE,EAAE,sBAAsB;QAC1B,IAAI,EAAE,sBAAsB;QAC5B,IAAI,EAAE,GAAG;QACT,YAAY,EAAE,MAAM;QACpB,UAAU,EAAE,IAAI;QAChB,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;QACxB,GAAG,SAAS;KACb,CAAA;AACH,CAAC"}

package/dist/agents/architect.d.ts

@@ -1,4 +0,0 @@
-import type { AgentDefinition } from "../types/agent";
-type Overrides = Partial<AgentDefinition>;
-export declare function architect(overrides?: Overrides): AgentDefinition;
-export {};