agent-collab-mcp 1.3.0 → 1.3.1

package/build/dispatch.d.ts

@@ -16,5 +16,6 @@ export interface DispatchResult {
 export declare function dispatchAgent(target: "reviewer" | "builder", prompt: string): DispatchResult;
 export declare function dispatchReview(taskIds: string[]): DispatchResult;
 export declare function dispatchBuilder(taskIds?: string[], message?: string): DispatchResult;
+export declare function dispatchArchitect(userRequest: string): DispatchResult;
 declare function formatResult(r: DispatchResult): string;
 export { formatResult };

package/build/dispatch.js

@@ -112,6 +112,35 @@ export function dispatchBuilder(taskIds, message) {
     }
     return dispatchAgent("builder", prompt);
 }
+export function dispatchArchitect(userRequest) {
+    const mode = getEngineMode();
+    if (isSingleEngine()) {
+        return { dispatched: false, reason: "Single-engine mode — you are the architect. Create the HLD and tasks yourself." };
+    }
+    if (!cliExists("claude")) {
+        return { dispatched: false, reason: "claude CLI not found on PATH. Install Claude Code CLI or create tasks manually." };
+    }
+    const prompt = `Call get_my_status from the agent-collab MCP. You are the Architect. Create an HLD with set_context("hld", ...) and then break the work into tasks with create_task. Set notify_builder=true on the LAST create_task call. The user wants: ${userRequest}`;
+    const logDir = ensureLogDir();
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const logFile = path.join(logDir, `dispatch-architect-${ts}.log`);
+    const out = fs.openSync(logFile, "w");
+    const child = spawn("claude", ["-p", "--permission-mode", "auto", prompt], {
+        detached: true,
+        stdio: ["ignore", out, out],
+        cwd: process.cwd(),
+    });
+    child.unref();
+    const pid = child.pid ?? 0;
+    fs.writeSync(out, `--- Dispatched architect: claude -p ...\n--- PID: ${pid}\n--- Time: ${new Date().toISOString()}\n--- Request: ${userRequest}\n---\n`);
+    const db = getDb();
+    db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(getRole(), `Invoked architect for: ${userRequest.slice(0, 100)} (PID ${pid})`);
+    return {
+        dispatched: true,
+        pid,
+        logFile: path.relative(process.cwd(), logFile),
+    };
+}
 function formatResult(r) {
     if (r.dispatched) {
         return `Dispatched (PID: ${r.pid}, log: ${r.logFile})`;

package/build/index.js

@@ -31,7 +31,7 @@ else {
     }
     const server = new McpServer({
         name: "agent-collab",
-        version: "1.3.0",
+        version: "1.3.1",
     }, { instructions });
     registerStatusTools(server);
     registerSetupTools(server);

package/build/templates.js

@@ -121,15 +121,17 @@ alwaysApply: true
 You have the agent-collab MCP configured. Follow the MCP workflow strictly:
 
 1. Call \`get_my_status\` to check your role, available tools, and next action
-2. If setup is needed, ask the user for strategy/engine preferences, then call \`setup_project\`
-3. If no tasks exist and you can create them, create an HLD with \`set_context\` then create tasks with \`create_task\`
+2. If setup is needed, ask the user for BOTH strategy AND engine mode, then call \`setup_project(strategy, engine_mode)\`
+3. If no tasks exist:
+   - In cursor-only mode: create HLD with \`set_context("hld", ...)\` then tasks with \`create_task\`
+   - In both mode: call \`invoke_architect("what the user wants built")\` to have Claude Code design and create tasks
 4. For each assigned task: \`claim_task\` -> \`get_task\` -> implement -> \`submit_for_review\`
 5. After submitting for review in "both" mode, call \`trigger_review()\` to auto-invoke the reviewer
 6. Check \`get_my_status\` after reviews — if changes-requested, \`claim_task\` again, fix, resubmit
 7. When all tasks are done, suggest \`archive_epic\` to the user to clear the board
 8. NEVER write code without claiming a task first via \`claim_task\`
 9. NEVER skip the MCP workflow even if the user says "just build it"
-10. The \`get_my_status\` response includes your available tools — only call tools listed there
+10. The \`get_my_status\` response lists your available tools — only call tools listed there
 `;
 const AGENTS_MD = `# Agent Instructions
 

package/build/tools/dispatch.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { isInitialized, getDb, isSingleEngine } from "../db.js";
-import { dispatchReview, dispatchBuilder, formatResult } from "../dispatch.js";
+import { dispatchReview, dispatchBuilder, dispatchArchitect, formatResult } from "../dispatch.js";
 const NOT_SETUP = { content: [{ type: "text", text: "Project not set up. Call setup_project first." }] };
 const SINGLE_MODE = { content: [{ type: "text", text: "Dispatch tools are only available in 'both' engine mode. In single-engine mode, you handle both roles directly." }] };
 export function registerDispatchTools(server) {
@@ -58,6 +58,22 @@ export function registerDispatchTools(server) {
         }
         return { content: [{ type: "text", text }] };
     });
+    server.tool("invoke_architect", "Invoke Claude Code (Architect) to create an HLD and tasks for the user's request. Use this when no tasks exist in 'both' mode.", {
+        request: z.string().describe("Description of what the user wants built. Pass the user's original request."),
+    }, async ({ request }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        if (isSingleEngine()) {
+            return { content: [{ type: "text", text: "In single-engine mode, YOU are the architect. Create the HLD and tasks yourself with set_context and create_task." }] };
+        }
+        const result = dispatchArchitect(request);
+        let text = `Invoking Architect (Claude Code) to design and create tasks for: "${request.slice(0, 100)}${request.length > 100 ? "..." : ""}"\n`;
+        text += formatResult(result);
+        if (result.dispatched) {
+            text += `\n\nThe Architect is working in the background. It will create an HLD and tasks, then auto-notify you when done. Call get_my_status periodically to check for new tasks.`;
+        }
+        return { content: [{ type: "text", text }] };
+    });
     server.tool("run_loop", "Run the full implement-review-fix loop for all tasks. Dispatches agents and polls until done or max rounds reached.", {
         max_rounds: z.number().optional().describe("Max review rounds per task (default: 3)"),
         max_tasks: z.number().optional().describe("Max tasks to process (default: all)"),

package/build/tools/setup.js

@@ -8,11 +8,11 @@ export function registerSetupTools(server) {
     const role = getRole();
     server.tool("setup_project", "Initialize agent collaboration for this project. Creates the database, config files, hooks, and rules.", {
         strategy: z.string().optional().describe("Strategy ID (default: architect-builder). Call list_strategies to see options."),
-        engine_mode: z.enum(["both", "cursor-only", "claude-code-only"]).optional().describe("Engine mode (default: cursor-only)"),
+        engine_mode: z.enum(["both", "cursor-only", "claude-code-only"]).describe("REQUIRED. Engine mode: 'both' (Cursor builds, Claude Code reviews), 'cursor-only' (Cursor does everything), or 'claude-code-only'."),
         project_name: z.string().optional().describe("Project name (default: current directory name)"),
     }, async ({ strategy, engine_mode, project_name }) => {
         const strategyId = strategy || getDefaultStrategyId();
-        const mode = engine_mode || "cursor-only";
+        const mode = engine_mode;
         const projName = project_name || path.basename(process.cwd());
         const def = getStrategyDef(strategyId);
         if (!def) {

package/build/tools/status.js

@@ -15,7 +15,7 @@ function buildToolList(access, single) {
         tools.push("save_plan");
     tools.push("get_task", "get_context", "get_review_feedback", "get_project_overview", "log_activity");
     if (!single)
-        tools.push("trigger_review", "notify_builder", "run_loop");
+        tools.push("trigger_review", "notify_builder", "invoke_architect", "run_loop");
     tools.push("archive_epic", "list_epics", "get_epic", "get_codebase_context");
     tools.push("list_strategies", "get_active_strategy", "set_strategy", "set_engine_mode");
     return tools.join(", ");
@@ -28,20 +28,19 @@ export function registerStatusTools(server) {
                         type: "text",
                         text: [
                             "SETUP_NEEDED: This project hasn't been configured for agent collaboration yet.\n",
-                            "Ask the user which setup they'd like:\n",
-                            "1. Strategy (default: architect-builder):",
-                            "   - architect-builder — One designs, the other builds",
+                            "You MUST ask the user TWO questions before calling setup_project:\n",
+                            "1. Engine mode (REQUIRED — ask the user explicitly):",
+                            "   - cursor-only: You handle everything alone (design + implement + review)",
+                            "   - both: Cursor implements, Claude Code designs and reviews (recommended for quality)",
+                            "   - claude-code-only: Claude Code handles everything alone\n",
+                            "2. Strategy:",
+                            "   - architect-builder — One agent designs, the other builds",
                             "   - tdd-red-green — One writes tests, the other makes them pass",
                             "   - writer-reviewer — One writes code, the other critiques",
                             "   - parallel-specialist — Domain split, cross-review",
                             "   - planner-executor — Detailed specs, mechanical execution",
                             "   - sequential-pipeline — Multi-stage quality review\n",
-                            "2. Engine mode (default: cursor-only):",
-                            "   - cursor-only: You handle everything (design + implement + review)",
-                            "   - both: Cursor implements, Claude Code reviews",
-                            "   - claude-code-only: Claude Code handles everything\n",
-                            "After getting their choices, call setup_project(strategy, engine_mode).",
-                            "If they just say 'go with defaults' or similar, use architect-builder + cursor-only.\n",
+                            "Then call setup_project(strategy, engine_mode) with BOTH values.\n",
                             "Available tools before setup: get_my_status, setup_project, list_strategies, get_dashboard_info",
                         ].join("\n"),
                     }],
@@ -100,7 +99,7 @@ export function registerStatusTools(server) {
             if (single) {
                 return text(header, `No tasks on the board.${historyHint} You have all tools — start by creating tasks with create_task(...).`);
             }
-            return text(header, `STOP: No tasks exist.${historyHint} Do NOT write code directly. The architect agent must create tasks first.`);
+            return text(header, `No tasks exist.${historyHint} Call invoke_architect("describe what the user wants built") to have Claude Code create the HLD and tasks. Pass the user's original request as the argument.`);
         }
         return text(header, "All tasks are done. Consider archiving this work with archive_epic(\"<name>\") to clear the board for the next feature. Or create new tasks if there are more requirements.");
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-collab-mcp",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "MCP server for multi-agent coordination between Cursor and Claude Code. Strategies, task management, review loops, and a live dashboard.",
   "type": "module",
   "main": "build/index.js",