agent-collab-mcp 1.2.0 → 1.3.1

package/build/dashboard.js

@@ -88,6 +88,9 @@ function apiEpicDetail(db, epicId) {
     const tasks = db.prepare("SELECT task_id, title, status, owner, context, acceptance, plan, reviews_json, created_at, updated_at FROM epic_tasks WHERE epic_id = ? ORDER BY task_id").all(epicId);
     return { ...epic, tasks };
 }
+function apiContextDocs(db) {
+    return db.prepare("SELECT key, content, updated_at FROM context_docs ORDER BY key").all();
+}
 function getProjectName(db) {
     const row = db.prepare("SELECT value FROM config WHERE key = 'project_name'").get();
     return row?.value ?? path.basename(process.cwd());
@@ -157,6 +160,9 @@ const server = http.createServer((req, res) => {
                 case "/api/project-name":
                     data = { name: getProjectName(db) };
                     break;
+                case "/api/context":
+                    data = apiContextDocs(db);
+                    break;
                 default:
                     res.writeHead(404);
                     res.end('{"error":"not found"}');
@@ -400,6 +406,18 @@ main{display:flex;flex-direction:column;gap:1.2rem;padding:1.5rem 2rem;max-width
 .review-issue{font-size:.75rem;color:var(--fg-1);padding:.2rem 0;font-family:var(--font-mono)}
 .review-issue .issue-loc{color:var(--accent)}
 
+/* ── Context Docs ───────────────────────────────────────── */
+.ctx-doc{background:var(--bg-2);border:1px solid var(--bg-3);border-radius:var(--radius-sm);
+  padding:.6rem .8rem;margin-bottom:.5rem}
+.ctx-doc .ctx-key{font-size:.7rem;font-weight:700;text-transform:uppercase;letter-spacing:.06em;
+  color:var(--accent);margin-bottom:.3rem;cursor:pointer;display:flex;align-items:center;gap:.3rem}
+.ctx-doc .ctx-key::before{content:'\\25B6';font-size:.5rem;transition:transform .2s}
+.ctx-doc.open .ctx-key::before{transform:rotate(90deg)}
+.ctx-doc .ctx-body{font-size:.75rem;color:var(--fg-1);line-height:1.5;display:none;
+  white-space:pre-wrap;word-break:break-word;max-height:200px;overflow-y:auto;margin-top:.3rem}
+.ctx-doc.open .ctx-body{display:block}
+.ctx-doc .ctx-updated{font-size:.55rem;color:var(--fg-2);font-family:var(--font-mono)}
+
 /* ── Epics ──────────────────────────────────────────────── */
 .epic-item{
   background:var(--bg-2);border:1px solid var(--bg-3);border-radius:var(--radius-sm);
@@ -438,6 +456,10 @@ main{display:flex;flex-direction:column;gap:1.2rem;padding:1.5rem 2rem;max-width
         <h3><span class="icon">&#9881;</span> Strategy</h3>
         <div id="strategy-content"></div>
       </div>
+      <div class="panel" id="context-panel">
+        <h3><span class="icon">&#128196;</span> Context Docs</h3>
+        <div id="context-docs"></div>
+      </div>
       <div class="panel" id="epics-panel">
         <h3><span class="icon">&#128230;</span> Archived Epics</h3>
         <div id="epics-list"></div>
@@ -602,6 +624,20 @@ document.getElementById('modal-overlay').addEventListener('click', function(e) {
 });
 document.addEventListener('keydown', function(e) { if (e.key === 'Escape') closeModal(); });
 
+function renderContextDocs(docs) {
+  const el = document.getElementById('context-docs');
+  if (!docs || docs.length === 0) {
+    el.innerHTML = '<div class="empty-state">No context docs yet</div>';
+    return;
+  }
+  el.innerHTML = docs.map(d =>
+    '<div class="ctx-doc" onclick="this.classList.toggle(\\'open\\')">'+
+      '<div class="ctx-key">'+escHtml(d.key).toUpperCase()+' <span class="ctx-updated">'+escHtml(d.updated_at||'')+'</span></div>'+
+      '<div class="ctx-body">'+escHtml(d.content)+'</div>'+
+    '</div>'
+  ).join('');
+}
+
 function renderEpics(epics) {
   const el = document.getElementById('epics-list');
   if (!epics || epics.length === 0) {
@@ -655,16 +691,18 @@ async function openEpic(id) {
 
 async function refresh() {
   try {
-    const [overview, tasks, activity, epics, proj] = await Promise.all([
+    const [overview, tasks, activity, epics, proj, ctxDocs] = await Promise.all([
       fetchJSON('/api/overview'),
       fetchJSON('/api/tasks'),
       fetchJSON('/api/activity?limit=30'),
       fetchJSON('/api/epics'),
       fetchJSON('/api/project-name'),
+      fetchJSON('/api/context'),
     ]);
     renderStats(overview);
     renderKanban(tasks);
     renderStrategy(overview);
+    renderContextDocs(ctxDocs);
     renderActivity(activity);
     renderEpics(epics);
     if (proj && proj.name) document.getElementById('h-project').textContent = proj.name;

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

@@ -20,7 +20,7 @@ else {
         instructions = [
             "This project hasn't been set up for agent collaboration yet.",
             "Call get_my_status to see setup instructions, or call setup_project directly.",
-            "Available tools: get_my_status, setup_project, list_strategies, get_dashboard_info.",
+            "All tools are visible but most require setup first.",
         ].join(" ");
     }
     else {
@@ -31,32 +31,16 @@ else {
     }
     const server = new McpServer({
         name: "agent-collab",
-        version: "1.2.0",
+        version: "1.3.1",
     }, { instructions });
     registerStatusTools(server);
     registerSetupTools(server);
-    if (initialized) {
-        registerTaskTools(server);
-        registerReviewTools(server);
-        registerContextTools(server);
-        registerStrategyTools(server);
-        registerDispatchTools(server);
-        registerEpicTools(server);
-    }
-    else {
-        const { getAllStrategies } = await import("./strategies.js");
-        server.tool("list_strategies", "List all available collaboration strategies.", {}, async () => {
-            const strategies = getAllStrategies();
-            let text = "Available strategies:\n\n";
-            for (const s of strategies) {
-                text += `## ${s.name} (${s.id})\n`;
-                text += `${s.description}\n`;
-                text += `Best for: ${s.best_for}\n`;
-                text += `Roles: ${s.roles.primary.name} (Primary) + ${s.roles.secondary.name} (Secondary)\n\n`;
-            }
-            return { content: [{ type: "text", text }] };
-        });
-    }
+    registerTaskTools(server);
+    registerReviewTools(server);
+    registerContextTools(server);
+    registerStrategyTools(server);
+    registerDispatchTools(server);
+    registerEpicTools(server);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     const role = getRole();
@@ -67,6 +51,6 @@ else {
         process.stderr.write(`agent-collab MCP started | strategy: ${strategy.name} | engine: ${engineMode} | role: ${roleConfig.name} (${role})\n`);
     }
     else {
-        process.stderr.write(`agent-collab MCP started | NOT INITIALIZED | awaiting setup_project\n`);
+        process.stderr.write(`agent-collab MCP started | NOT INITIALIZED | all tools visible, awaiting setup_project\n`);
     }
 }

package/build/templates.js

@@ -116,31 +116,22 @@ description: Agent collaboration protocol via MCP
 alwaysApply: true
 ---
 
-# Agent Collaboration
-
-You are part of a coordinated agent system. Your role depends on the active **collaboration strategy** and **engine mode**.
-All coordination goes through the **agent-collab** MCP server.
-
-In single-engine mode, you handle both Primary and Secondary roles with all tools available.
-
-## Before ANY work
-
-Call \`get_my_status\` from the agent-collab MCP. Follow its instructions exactly.
-Do NOT write code without first claiming a task via \`claim_task\`.
-
-## Common Workflow
-
-1. \`get_my_status\` — see what to do next
-2. \`claim_task(id)\` — claim it (sets to in-progress)
-3. \`get_task(id)\` — read full details
-4. Implement the task
-5. \`submit_for_review(id, summary)\` — submit for review
-6. \`get_my_status\` — check for next task or review feedback
-
-Some strategies give you additional tools (e.g., \`create_task\`, \`review_task\`, \`set_engine_mode\`).
-Call \`get_active_strategy\` to see your current role, engine mode, and available tools.
-
-Skipping this — even if the user says "just build it" — is a violation.
+# Agent Collaboration — Automated Workflow
+
+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 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 lists your available tools — only call tools listed there
 `;
 const AGENTS_MD = `# Agent Instructions
 
@@ -392,7 +383,7 @@ const CLAUDE_SETTINGS = `{
   "mcpServers": {
     "agent-collab": {
       "command": "npx",
-      "args": ["-y", "agent-collab-mcp"],
+      "args": ["agent-collab-mcp"],
       "env": {
         "AGENT_ROLE": "claude-code"
       }

package/build/tools/context.js

@@ -1,36 +1,45 @@
 import { z } from "zod";
-import { getDb, getRole, getToolAccess } from "../db.js";
+import { isInitialized, getDb, getRole, getToolAccess } from "../db.js";
+const NOT_SETUP = { content: [{ type: "text", text: "Project not set up. Call setup_project first." }] };
 export function registerContextTools(server) {
-    const access = getToolAccess();
-    const role = getRole();
     server.tool("get_context", "Get a project context document (PRD or HLD summary).", { key: z.enum(["prd", "hld"]).describe("Document key: 'prd' or 'hld'") }, async ({ key }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
         const db = getDb();
         const row = db.prepare("SELECT content, updated_at FROM context_docs WHERE key = ?").get(key);
         if (!row) {
-            const hint = access.context_write
+            const canWrite = getToolAccess().context_write;
+            const hint = canWrite
                 ? `Create one with set_context("${key}", ...).`
                 : "The other agent needs to create one first.";
             return { content: [{ type: "text", text: `No ${key.toUpperCase()} document found. ${hint}` }] };
         }
         return { content: [{ type: "text", text: `${key.toUpperCase()} (updated ${row.updated_at}):\n\n${row.content}` }] };
     });
-    if (access.context_write) {
-        server.tool("set_context", "Create or update a project context document (PRD or HLD).", {
-            key: z.enum(["prd", "hld"]).describe("Document key: 'prd' or 'hld'"),
-            content: z.string().describe("Document content (keep concise, max ~150 lines)"),
-        }, async ({ key, content }) => {
-            const db = getDb();
-            db.prepare(`
-          INSERT INTO context_docs (key, content, updated_at)
-          VALUES (?, ?, datetime('now'))
-          ON CONFLICT(key) DO UPDATE SET content = excluded.content, updated_at = datetime('now')
-        `).run(key, content);
-            db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Updated ${key.toUpperCase()} document`);
-            return { content: [{ type: "text", text: `${key.toUpperCase()} document saved.` }] };
-        });
-    }
+    server.tool("set_context", "Create or update a project context document (PRD or HLD).", {
+        key: z.enum(["prd", "hld"]).describe("Document key: 'prd' or 'hld'"),
+        content: z.string().describe("Document content (keep concise, max ~150 lines)"),
+    }, async ({ key, content }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        if (!getToolAccess().context_write) {
+            return { content: [{ type: "text", text: "set_context is not available for your current role." }] };
+        }
+        const db = getDb();
+        const role = getRole();
+        db.prepare(`
+        INSERT INTO context_docs (key, content, updated_at)
+        VALUES (?, ?, datetime('now'))
+        ON CONFLICT(key) DO UPDATE SET content = excluded.content, updated_at = datetime('now')
+      `).run(key, content);
+        db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Updated ${key.toUpperCase()} document`);
+        return { content: [{ type: "text", text: `${key.toUpperCase()} document saved.` }] };
+    });
     server.tool("log_activity", "Log an activity entry.", { action: z.string().describe("Short description of what was done") }, async ({ action }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
         const db = getDb();
+        const role = getRole();
         db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, action);
         return { content: [{ type: "text", text: "Logged." }] };
     });

package/build/tools/dispatch.js

@@ -1,13 +1,16 @@
 import { z } from "zod";
-import { getDb, getRole, isSingleEngine } from "../db.js";
-import { dispatchReview, dispatchBuilder, formatResult } from "../dispatch.js";
+import { isInitialized, getDb, isSingleEngine } from "../db.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) {
-    if (isSingleEngine())
-        return;
-    const role = getRole();
     server.tool("trigger_review", "Invoke the reviewer agent to review tasks. Auto-spawns the counterpart CLI in the background.", {
         task_id: z.string().optional().describe("Specific task ID to review, or omit to review all tasks in 'review' status"),
     }, async ({ task_id }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        if (isSingleEngine())
+            return SINGLE_MODE;
         const db = getDb();
         let taskIds;
         if (task_id) {
@@ -37,6 +40,10 @@ export function registerDispatchTools(server) {
     server.tool("notify_builder", "Invoke the builder agent to pick up assigned tasks. Auto-spawns the counterpart CLI in the background.", {
         message: z.string().optional().describe("Optional context message for the builder"),
     }, async ({ message }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        if (isSingleEngine())
+            return SINGLE_MODE;
         const db = getDb();
         const assigned = db.prepare("SELECT id FROM tasks WHERE status = 'assigned' ORDER BY id").all();
         if (assigned.length === 0) {
@@ -51,11 +58,31 @@ 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)"),
         timeout_seconds: z.number().optional().describe("Timeout per agent invocation in seconds (default: 300)"),
     }, async ({ max_rounds, max_tasks, timeout_seconds }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        if (isSingleEngine())
+            return SINGLE_MODE;
         const maxR = max_rounds ?? 3;
         const maxT = max_tasks ?? 999;
         const timeout = (timeout_seconds ?? 300) * 1000;

package/build/tools/epic.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { getDb, getRole, getActiveStrategy, getEngineMode, nextEpicId } from "../db.js";
+import { isInitialized, getDb, getRole, getActiveStrategy, getEngineMode, nextEpicId } from "../db.js";
+const NOT_SETUP = { content: [{ type: "text", text: "Project not set up. Call setup_project first." }] };
 export function registerEpicTools(server) {
     const role = getRole();
     server.tool("archive_epic", "Archive all current tasks into a named epic. Clears the board for new work. Past epics remain accessible for context.", {
@@ -8,6 +9,8 @@ export function registerEpicTools(server) {
         include_incomplete: z.boolean().optional().describe("If true, archive even if some tasks aren't done (default: false)"),
         confirm: z.boolean().optional().describe("Set to true to confirm the archive"),
     }, async ({ name, description, include_incomplete, confirm }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
         const db = getDb();
         const tasks = db.prepare("SELECT * FROM tasks ORDER BY CAST(SUBSTR(id, 3) AS INTEGER)").all();
         if (tasks.length === 0) {
@@ -75,6 +78,8 @@ export function registerEpicTools(server) {
         return { content: [{ type: "text", text }] };
     });
     server.tool("list_epics", "List all archived epics with summaries. Shows project history.", {}, async () => {
+        if (!isInitialized())
+            return NOT_SETUP;
         const db = getDb();
         const epics = db.prepare("SELECT id, name, description, task_count, strategy, engine_mode, archived_at FROM epics ORDER BY CAST(SUBSTR(id, 3) AS INTEGER)").all();
         if (epics.length === 0) {
@@ -90,6 +95,8 @@ export function registerEpicTools(server) {
         return { content: [{ type: "text", text }] };
     });
     server.tool("get_epic", "Get full details of an archived epic: tasks, reviews, context, activity.", { epic_id: z.string().describe("Epic ID, e.g. E-001") }, async ({ epic_id }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
         const db = getDb();
         const epic = db.prepare("SELECT * FROM epics WHERE id = ?").get(epic_id);
         if (!epic) {
@@ -120,6 +127,8 @@ export function registerEpicTools(server) {
         return { content: [{ type: "text", text }] };
     });
     server.tool("get_codebase_context", "Get current HLD/PRD plus summaries of all past epics. Call this before starting new work to understand the codebase history.", {}, async () => {
+        if (!isInitialized())
+            return NOT_SETUP;
         const db = getDb();
         const contextDocs = db.prepare("SELECT key, content, updated_at FROM context_docs").all();
         const epics = db.prepare("SELECT id, name, summary, task_count, archived_at FROM epics ORDER BY CAST(SUBSTR(id, 3) AS INTEGER)").all();

package/build/tools/reviews.js

@@ -1,9 +1,10 @@
 import { z } from "zod";
-import { getDb, getRole, getToolAccess } from "../db.js";
+import { isInitialized, getDb, getRole, getToolAccess } from "../db.js";
+const NOT_SETUP = { content: [{ type: "text", text: "Project not set up. Call setup_project first." }] };
 export function registerReviewTools(server) {
-    const access = getToolAccess();
-    const role = getRole();
     server.tool("get_review_feedback", "Get the latest review feedback for a task.", { task_id: z.string().describe("Task ID") }, async ({ task_id }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
         const db = getDb();
         const review = db.prepare("SELECT round, verdict, issues, notes, created_at FROM reviews WHERE task_id = ? ORDER BY round DESC LIMIT 1").get(task_id);
         if (!review) {
@@ -28,58 +29,62 @@ export function registerReviewTools(server) {
         }
         return { content: [{ type: "text", text }] };
     });
-    if (access.review_write) {
-        server.tool("review_task", "Write a review verdict for a task. Sets status to 'done' or 'changes-requested'.", {
-            task_id: z.string().describe("Task ID to review"),
-            verdict: z.enum(["approved", "changes-requested"]).describe("Review verdict"),
-            issues: z.array(z.object({
-                file: z.string().optional().describe("File path"),
-                line: z.number().optional().describe("Line number"),
-                description: z.string().describe("Issue description and how to fix"),
-                severity: z.enum(["critical", "warning", "note"]).optional().describe("Issue severity"),
-            })).optional().describe("List of issues found"),
-            notes: z.string().optional().describe("General feedback or positive observations"),
-        }, async ({ task_id, verdict, issues, notes }) => {
-            const db = getDb();
-            const task = db.prepare("SELECT * FROM tasks WHERE id = ?").get(task_id);
-            if (!task) {
-                return { content: [{ type: "text", text: `Task ${task_id} not found.` }] };
-            }
-            if (task.status !== "review") {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Cannot review ${task_id}: status is "${task.status}". Only "review" tasks can be reviewed.`
-                        }]
-                };
-            }
-            const lastReview = db.prepare("SELECT round FROM reviews WHERE task_id = ? ORDER BY round DESC LIMIT 1").get(task_id);
-            const round = (lastReview?.round || 0) + 1;
-            const newStatus = verdict === "approved" ? "done" : "changes-requested";
-            db.prepare(`
-          INSERT INTO reviews (task_id, round, verdict, issues, notes)
-          VALUES (?, ?, ?, ?, ?)
-        `).run(task_id, round, verdict, issues ? JSON.stringify(issues) : null, notes || null);
-            db.prepare("UPDATE tasks SET status = ?, updated_at = datetime('now') WHERE id = ?").run(newStatus, task_id);
-            db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Reviewed ${task_id} round ${round}: ${verdict}`);
-            if (verdict === "approved") {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `${task_id} APPROVED (round ${round}). Status set to done.${notes ? " Notes: " + notes : ""}`
-                        }]
-                };
-            }
-            let text = `${task_id} needs changes (round ${round}). Status set to changes-requested.\n`;
-            if (issues && issues.length > 0) {
-                text += "\nIssues to fix:\n";
-                for (const issue of issues) {
-                    text += `  - [${issue.file || "general"}${issue.line ? ":" + issue.line : ""}] ${issue.description}\n`;
-                }
+    server.tool("review_task", "Write a review verdict for a task. Sets status to 'done' or 'changes-requested'.", {
+        task_id: z.string().describe("Task ID to review"),
+        verdict: z.enum(["approved", "changes-requested"]).describe("Review verdict"),
+        issues: z.array(z.object({
+            file: z.string().optional().describe("File path"),
+            line: z.number().optional().describe("Line number"),
+            description: z.string().describe("Issue description and how to fix"),
+            severity: z.enum(["critical", "warning", "note"]).optional().describe("Issue severity"),
+        })).optional().describe("List of issues found"),
+        notes: z.string().optional().describe("General feedback or positive observations"),
+    }, async ({ task_id, verdict, issues, notes }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        if (!getToolAccess().review_write) {
+            return { content: [{ type: "text", text: "review_task is not available for your current role. Call get_my_status to see your available tools." }] };
+        }
+        const db = getDb();
+        const role = getRole();
+        const task = db.prepare("SELECT * FROM tasks WHERE id = ?").get(task_id);
+        if (!task) {
+            return { content: [{ type: "text", text: `Task ${task_id} not found.` }] };
+        }
+        if (task.status !== "review") {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Cannot review ${task_id}: status is "${task.status}". Only "review" tasks can be reviewed.`
+                    }]
+            };
+        }
+        const lastReview = db.prepare("SELECT round FROM reviews WHERE task_id = ? ORDER BY round DESC LIMIT 1").get(task_id);
+        const round = (lastReview?.round || 0) + 1;
+        const newStatus = verdict === "approved" ? "done" : "changes-requested";
+        db.prepare(`
+        INSERT INTO reviews (task_id, round, verdict, issues, notes)
+        VALUES (?, ?, ?, ?, ?)
+      `).run(task_id, round, verdict, issues ? JSON.stringify(issues) : null, notes || null);
+        db.prepare("UPDATE tasks SET status = ?, updated_at = datetime('now') WHERE id = ?").run(newStatus, task_id);
+        db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Reviewed ${task_id} round ${round}: ${verdict}`);
+        if (verdict === "approved") {
+            return {
+                content: [{
+                        type: "text",
+                        text: `${task_id} APPROVED (round ${round}). Status set to done.${notes ? " Notes: " + notes : ""}`
+                    }]
+            };
+        }
+        let text = `${task_id} needs changes (round ${round}). Status set to changes-requested.\n`;
+        if (issues && issues.length > 0) {
+            text += "\nIssues to fix:\n";
+            for (const issue of issues) {
+                text += `  - [${issue.file || "general"}${issue.line ? ":" + issue.line : ""}] ${issue.description}\n`;
             }
-            if (notes)
-                text += `\nNotes: ${notes}`;
-            return { content: [{ type: "text", text }] };
-        });
-    }
+        }
+        if (notes)
+            text += `\nNotes: ${notes}`;
+        return { content: [{ type: "text", text }] };
+    });
 }

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

@@ -1,4 +1,25 @@
 import { isInitialized, getDb, getActiveStrategy, getEngineMode, getMyRoleConfig, isSingleEngine } from "../db.js";
+function buildToolList(access, single) {
+    const tools = [];
+    if (access.task_create)
+        tools.push("create_task");
+    if (access.task_claim)
+        tools.push("claim_task");
+    if (access.task_submit)
+        tools.push("submit_for_review");
+    if (access.review_write)
+        tools.push("review_task");
+    if (access.context_write)
+        tools.push("set_context");
+    if (access.save_plan)
+        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", "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(", ");
+}
 export function registerStatusTools(server) {
     server.tool("get_my_status", "Get your next action. Call this FIRST before any work.", {}, async () => {
         if (!isInitialized()) {
@@ -7,20 +28,20 @@ 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.",
+                            "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"),
                     }],
             };
@@ -31,7 +52,8 @@ export function registerStatusTools(server) {
         const roleConfig = getMyRoleConfig();
         const single = isSingleEngine();
         const access = roleConfig.tools;
-        const header = `[Strategy: ${strategy.name}] [Engine: ${engineMode}] [Role: ${roleConfig.name}]\n`;
+        const toolLine = `Your tools: ${buildToolList(access, single)}\n`;
+        const header = `[Strategy: ${strategy.name}] [Engine: ${engineMode}] [Role: ${roleConfig.name}]\n${toolLine}`;
         const inProgress = db.prepare("SELECT id, title FROM tasks WHERE status = 'in-progress' LIMIT 1").get();
         if (inProgress) {
             return text(header, `RESUME: Task ${inProgress.id} "${inProgress.title}" is in-progress. Call get_task("${inProgress.id}") for details and continue working.`);
@@ -77,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.");
     });
@@ -91,8 +113,9 @@ export function registerStatusTools(server) {
         const counts = db.prepare("SELECT status, COUNT(*) as cnt FROM tasks GROUP BY status").all();
         const total = counts.reduce((s, r) => s + r.cnt, 0);
         const recent = db.prepare("SELECT timestamp, agent, action FROM activity_log ORDER BY id DESC LIMIT 5").all();
+        const epicCount = db.prepare("SELECT COUNT(*) as cnt FROM epics").get().cnt;
         let out = `Strategy: ${strategy.name} | Engine mode: ${engineMode}\n`;
-        out += `Project: ${total} tasks total\n`;
+        out += `Project: ${total} tasks total | ${epicCount} archived epic(s)\n`;
         for (const r of counts) {
             out += `  ${r.status}: ${r.cnt}\n`;
         }

package/build/tools/strategy.js

@@ -1,11 +1,20 @@
 import { z } from "zod";
-import { getDb, getRole, getActiveStrategy, getEngineMode, getMyRoleConfig, setActiveStrategy, setEngineMode, isSingleEngine } from "../db.js";
+import { isInitialized, getDb, getRole, getActiveStrategy, getEngineMode, getMyRoleConfig, setActiveStrategy, setEngineMode, isSingleEngine } from "../db.js";
 import { getAllStrategies, getStrategyDef } from "../strategies.js";
+const NOT_SETUP = { content: [{ type: "text", text: "Project not set up. Call setup_project first." }] };
 export function registerStrategyTools(server) {
-    const role = getRole();
-    const engineMode = getEngineMode();
     server.tool("list_strategies", "List all available collaboration strategies with descriptions.", {}, async () => {
         const strategies = getAllStrategies();
+        if (!isInitialized()) {
+            let text = "Available strategies:\n\n";
+            for (const s of strategies) {
+                text += `## ${s.name} (${s.id})\n`;
+                text += `${s.description}\n`;
+                text += `Best for: ${s.best_for}\n`;
+                text += `Roles: ${s.roles.primary.name} (Primary) + ${s.roles.secondary.name} (Secondary)\n\n`;
+            }
+            return { content: [{ type: "text", text }] };
+        }
         const active = getActiveStrategy();
         const mode = getEngineMode();
         let text = `Active strategy: ${active.id} — ${active.name}\n`;
@@ -30,6 +39,8 @@ export function registerStrategyTools(server) {
         return { content: [{ type: "text", text }] };
     });
     server.tool("get_active_strategy", "Get the current collaboration strategy, engine mode, and your role.", {}, async () => {
+        if (!isInitialized())
+            return NOT_SETUP;
         const strategy = getActiveStrategy();
         const mode = getEngineMode();
         const roleConfig = getMyRoleConfig();
@@ -49,67 +60,78 @@ export function registerStrategyTools(server) {
         }
         return { content: [{ type: "text", text }] };
     });
-    const canChangeConfig = role === "claude-code" || isSingleEngine() || role === "unknown";
-    if (canChangeConfig) {
-        server.tool("set_strategy", "Change the collaboration strategy. Affects how agents work together.", {
-            strategy_id: z.string().describe("Strategy ID from list_strategies"),
-            confirm: z.boolean().describe("Set to true to confirm the change"),
-        }, async ({ strategy_id, confirm }) => {
-            const def = getStrategyDef(strategy_id);
-            if (!def) {
-                const ids = getAllStrategies().map(s => s.id).join(", ");
-                return { content: [{ type: "text", text: `Unknown strategy "${strategy_id}". Available: ${ids}` }] };
-            }
-            if (!confirm) {
-                let text = `About to switch to: ${def.name}\n\n`;
-                text += `${def.description}\n\n`;
-                text += `Primary role: ${def.roles.primary.name}\n`;
-                text += `Secondary role: ${def.roles.secondary.name}\n\n`;
-                text += `Call set_strategy("${strategy_id}", confirm=true) to apply.\n`;
-                text += `NOTE: Agents need to restart their MCP connections to pick up the new roles.`;
-                return { content: [{ type: "text", text }] };
-            }
-            const db = getDb();
-            setActiveStrategy(db, strategy_id);
-            db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Changed strategy to: ${def.name} (${strategy_id})`);
-            return {
-                content: [{
-                        type: "text",
-                        text: `Strategy changed to: ${def.name} (${strategy_id}). Restart MCP connections to apply.`
-                    }]
-            };
-        });
-        server.tool("set_engine_mode", "Change which engines are active: 'both', 'cursor-only', or 'claude-code-only'.", {
-            mode: z.enum(["both", "cursor-only", "claude-code-only"]).describe("Engine mode"),
-            confirm: z.boolean().describe("Set to true to confirm"),
-        }, async ({ mode, confirm }) => {
-            const current = getEngineMode();
-            if (!confirm) {
-                let text = `Current engine mode: ${current}\n`;
-                text += `Switching to: ${mode}\n\n`;
-                if (mode === "both") {
-                    text += "Both engines active: cursor → Primary role, claude-code → Secondary role.\n";
-                    text += "Each engine sees only its role's tools.\n";
-                }
-                else {
-                    text += `Single engine (${mode}): one agent handles BOTH Primary and Secondary roles.\n`;
-                    text += "All tools are available. Self-review is used.\n";
-                }
-                text += `\nCall set_engine_mode("${mode}", confirm=true) to apply.`;
-                return { content: [{ type: "text", text }] };
-            }
-            const db = getDb();
-            setEngineMode(db, mode);
-            db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Changed engine mode to: ${mode}`);
-            let text = `Engine mode changed to: ${mode}.\n`;
+    server.tool("set_strategy", "Change the collaboration strategy. Affects how agents work together.", {
+        strategy_id: z.string().describe("Strategy ID from list_strategies"),
+        confirm: z.boolean().describe("Set to true to confirm the change"),
+    }, async ({ strategy_id, confirm }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        const role = getRole();
+        const canChange = role === "claude-code" || isSingleEngine() || role === "unknown";
+        if (!canChange) {
+            return { content: [{ type: "text", text: "set_strategy is only available to the secondary role or in single-engine mode." }] };
+        }
+        const def = getStrategyDef(strategy_id);
+        if (!def) {
+            const ids = getAllStrategies().map(s => s.id).join(", ");
+            return { content: [{ type: "text", text: `Unknown strategy "${strategy_id}". Available: ${ids}` }] };
+        }
+        if (!confirm) {
+            let text = `About to switch to: ${def.name}\n\n`;
+            text += `${def.description}\n\n`;
+            text += `Primary role: ${def.roles.primary.name}\n`;
+            text += `Secondary role: ${def.roles.secondary.name}\n\n`;
+            text += `Call set_strategy("${strategy_id}", confirm=true) to apply.\n`;
+            text += `NOTE: Agents need to restart their MCP connections to pick up the new roles.`;
+            return { content: [{ type: "text", text }] };
+        }
+        const db = getDb();
+        setActiveStrategy(db, strategy_id);
+        db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Changed strategy to: ${def.name} (${strategy_id})`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Strategy changed to: ${def.name} (${strategy_id}). Restart MCP connections to apply.`
+                }]
+        };
+    });
+    server.tool("set_engine_mode", "Change which engines are active: 'both', 'cursor-only', or 'claude-code-only'.", {
+        mode: z.enum(["both", "cursor-only", "claude-code-only"]).describe("Engine mode"),
+        confirm: z.boolean().describe("Set to true to confirm"),
+    }, async ({ mode, confirm }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        const role = getRole();
+        const canChange = role === "claude-code" || isSingleEngine() || role === "unknown";
+        if (!canChange) {
+            return { content: [{ type: "text", text: "set_engine_mode is only available to the secondary role or in single-engine mode." }] };
+        }
+        const current = getEngineMode();
+        if (!confirm) {
+            let text = `Current engine mode: ${current}\n`;
+            text += `Switching to: ${mode}\n\n`;
             if (mode === "both") {
-                text += "Update .cursor/mcp.json (AGENT_ROLE=cursor) and .claude/settings.json (AGENT_ROLE=claude-code).\n";
+                text += "Both engines active: cursor → Primary role, claude-code → Secondary role.\n";
+                text += "Each engine sees only its role's tools.\n";
             }
             else {
-                text += `Only the ${mode.replace("-only", "")} config file is needed.\n`;
+                text += `Single engine (${mode}): one agent handles BOTH Primary and Secondary roles.\n`;
+                text += "All tools are available. Self-review is used.\n";
             }
-            text += "Restart MCP connections to apply.";
+            text += `\nCall set_engine_mode("${mode}", confirm=true) to apply.`;
             return { content: [{ type: "text", text }] };
-        });
-    }
+        }
+        const db = getDb();
+        setEngineMode(db, mode);
+        db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Changed engine mode to: ${mode}`);
+        let text = `Engine mode changed to: ${mode}.\n`;
+        if (mode === "both") {
+            text += "Update .cursor/mcp.json (AGENT_ROLE=cursor) and .claude/settings.json (AGENT_ROLE=claude-code).\n";
+        }
+        else {
+            text += `Only the ${mode.replace("-only", "")} config file is needed.\n`;
+        }
+        text += "Restart MCP connections to apply.";
+        return { content: [{ type: "text", text }] };
+    });
 }

package/build/tools/tasks.js

@@ -1,10 +1,12 @@
 import { z } from "zod";
-import { getDb, getRole, getToolAccess, getDefaultOwner, nextTaskId, isSingleEngine } from "../db.js";
+import { isInitialized, getDb, getRole, getToolAccess, getDefaultOwner, nextTaskId, isSingleEngine } from "../db.js";
 import { dispatchReview, dispatchBuilder, formatResult } from "../dispatch.js";
+const NOT_SETUP = { content: [{ type: "text", text: "Project not set up. Call setup_project first." }] };
+const NO_ACCESS = (tool) => ({ content: [{ type: "text", text: `${tool} is not available for your current role. Call get_my_status to see your available tools.` }] });
 export function registerTaskTools(server) {
-    const access = getToolAccess();
-    const role = getRole();
     server.tool("get_task", "Get full details for a task including latest review.", { task_id: z.string().describe("Task ID, e.g. T-001") }, async ({ task_id }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
         const db = getDb();
         const task = db.prepare("SELECT * FROM tasks WHERE id = ?").get(task_id);
         if (!task) {
@@ -37,109 +39,120 @@ export function registerTaskTools(server) {
         }
         return { content: [{ type: "text", text }] };
     });
-    if (access.task_create) {
-        server.tool("create_task", "Create a new task. Owner defaults based on engine mode.", {
-            title: z.string().describe("Short task title"),
-            context: z.string().describe("2-3 lines of context from HLD"),
-            acceptance: z.string().describe("Criteria that define done"),
-            depends_on: z.string().optional().describe("Comma-separated task IDs this depends on"),
-            owner: z.enum(["cursor", "claude-code"]).optional().describe("Task owner (defaults based on engine mode)"),
-            notify_builder: z.boolean().optional().describe("If true, auto-invoke the builder agent to start working. Use on the last task in a batch."),
-        }, async ({ title, context, acceptance, depends_on, owner, notify_builder: shouldNotify }) => {
-            const db = getDb();
-            const id = nextTaskId(db);
-            const taskOwner = owner || getDefaultOwner();
-            db.prepare(`
-          INSERT INTO tasks (id, title, status, owner, depends_on, context, acceptance)
-          VALUES (?, ?, 'assigned', ?, ?, ?, ?)
-        `).run(id, title, taskOwner, depends_on || null, context, acceptance);
-            db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Created task ${id}: ${title} (owner: ${taskOwner})`);
-            let text = `Created ${id}: "${title}" (assigned to ${taskOwner}).`;
-            if (shouldNotify && !isSingleEngine()) {
-                const assigned = db.prepare("SELECT id FROM tasks WHERE status = 'assigned' ORDER BY id").all();
-                const result = dispatchBuilder(assigned.map(t => t.id), `${assigned.length} task(s) are ready for you.`);
-                text += `\nBuilder notification: ${formatResult(result)}`;
-            }
-            return { content: [{ type: "text", text }] };
-        });
-    }
-    if (access.task_claim) {
-        server.tool("claim_task", "Claim a task and set it to in-progress. Works on 'assigned' or 'changes-requested' tasks.", { task_id: z.string().describe("Task ID to claim, e.g. T-001") }, async ({ task_id }) => {
-            const db = getDb();
-            const task = db.prepare("SELECT * FROM tasks WHERE id = ?").get(task_id);
-            if (!task) {
-                return { content: [{ type: "text", text: `Task ${task_id} not found.` }] };
-            }
-            if (task.status !== "assigned" && task.status !== "changes-requested") {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Cannot claim ${task_id}: status is "${task.status}". Only "assigned" or "changes-requested" tasks can be claimed.`
-                        }]
-                };
-            }
-            db.prepare("UPDATE tasks SET status = 'in-progress', updated_at = datetime('now') WHERE id = ?").run(task_id);
-            db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Claimed task ${task_id}`);
-            let text = `Claimed ${task_id}: "${task.title}" — now in-progress.\n\nContext:\n${task.context || "(none)"}\n\nAcceptance:\n${task.acceptance || "(none)"}`;
-            if (task.status === "changes-requested") {
-                const review = db.prepare("SELECT issues, notes FROM reviews WHERE task_id = ? ORDER BY round DESC LIMIT 1").get(task_id);
-                if (review?.issues) {
-                    text += "\n\nReview issues to fix:\n";
-                    try {
-                        const issues = JSON.parse(review.issues);
-                        for (const issue of issues) {
-                            text += `  - [${issue.file || "general"}${issue.line ? ":" + issue.line : ""}] ${issue.description}\n`;
-                        }
-                    }
-                    catch {
-                        text += `  ${review.issues}\n`;
+    server.tool("create_task", "Create a new task. Owner defaults based on engine mode.", {
+        title: z.string().describe("Short task title"),
+        context: z.string().describe("2-3 lines of context from HLD"),
+        acceptance: z.string().describe("Criteria that define done"),
+        depends_on: z.string().optional().describe("Comma-separated task IDs this depends on"),
+        owner: z.enum(["cursor", "claude-code"]).optional().describe("Task owner (defaults based on engine mode)"),
+        notify_builder: z.boolean().optional().describe("If true, auto-invoke the builder agent to start working. Use on the last task in a batch."),
+    }, async ({ title, context, acceptance, depends_on, owner, notify_builder: shouldNotify }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        if (!getToolAccess().task_create)
+            return NO_ACCESS("create_task");
+        const db = getDb();
+        const role = getRole();
+        const id = nextTaskId(db);
+        const taskOwner = owner || getDefaultOwner();
+        db.prepare(`
+        INSERT INTO tasks (id, title, status, owner, depends_on, context, acceptance)
+        VALUES (?, ?, 'assigned', ?, ?, ?, ?)
+      `).run(id, title, taskOwner, depends_on || null, context, acceptance);
+        db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Created task ${id}: ${title} (owner: ${taskOwner})`);
+        let text = `Created ${id}: "${title}" (assigned to ${taskOwner}).`;
+        if (shouldNotify && !isSingleEngine()) {
+            const assigned = db.prepare("SELECT id FROM tasks WHERE status = 'assigned' ORDER BY id").all();
+            const result = dispatchBuilder(assigned.map(t => t.id), `${assigned.length} task(s) are ready for you.`);
+            text += `\nBuilder notification: ${formatResult(result)}`;
+        }
+        return { content: [{ type: "text", text }] };
+    });
+    server.tool("claim_task", "Claim a task and set it to in-progress. Works on 'assigned' or 'changes-requested' tasks.", { task_id: z.string().describe("Task ID to claim, e.g. T-001") }, async ({ task_id }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        if (!getToolAccess().task_claim)
+            return NO_ACCESS("claim_task");
+        const db = getDb();
+        const role = getRole();
+        const task = db.prepare("SELECT * FROM tasks WHERE id = ?").get(task_id);
+        if (!task) {
+            return { content: [{ type: "text", text: `Task ${task_id} not found.` }] };
+        }
+        if (task.status !== "assigned" && task.status !== "changes-requested") {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Cannot claim ${task_id}: status is "${task.status}". Only "assigned" or "changes-requested" tasks can be claimed.`
+                    }]
+            };
+        }
+        db.prepare("UPDATE tasks SET status = 'in-progress', updated_at = datetime('now') WHERE id = ?").run(task_id);
+        db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Claimed task ${task_id}`);
+        let text = `Claimed ${task_id}: "${task.title}" — now in-progress.\n\nContext:\n${task.context || "(none)"}\n\nAcceptance:\n${task.acceptance || "(none)"}`;
+        if (task.status === "changes-requested") {
+            const review = db.prepare("SELECT issues, notes FROM reviews WHERE task_id = ? ORDER BY round DESC LIMIT 1").get(task_id);
+            if (review?.issues) {
+                text += "\n\nReview issues to fix:\n";
+                try {
+                    const issues = JSON.parse(review.issues);
+                    for (const issue of issues) {
+                        text += `  - [${issue.file || "general"}${issue.line ? ":" + issue.line : ""}] ${issue.description}\n`;
                     }
                 }
+                catch {
+                    text += `  ${review.issues}\n`;
+                }
             }
-            return { content: [{ type: "text", text }] };
-        });
-    }
-    if (access.save_plan) {
-        server.tool("save_plan", "Save your implementation plan for a task.", {
-            task_id: z.string().describe("Task ID"),
-            plan: z.string().describe("Your implementation plan"),
-        }, async ({ task_id, plan }) => {
-            const db = getDb();
-            const task = db.prepare("SELECT status FROM tasks WHERE id = ?").get(task_id);
-            if (!task) {
-                return { content: [{ type: "text", text: `Task ${task_id} not found.` }] };
-            }
-            db.prepare("UPDATE tasks SET plan = ?, updated_at = datetime('now') WHERE id = ?").run(plan, task_id);
-            return { content: [{ type: "text", text: `Plan saved for ${task_id}. Proceed with implementation.` }] };
-        });
-    }
-    if (access.task_submit) {
-        server.tool("submit_for_review", "Mark a task as complete and submit for review.", {
-            task_id: z.string().describe("Task ID"),
-            summary: z.string().describe("1-3 line summary of what was done"),
-        }, async ({ task_id, summary }) => {
-            const db = getDb();
-            const task = db.prepare("SELECT status FROM tasks WHERE id = ?").get(task_id);
-            if (!task) {
-                return { content: [{ type: "text", text: `Task ${task_id} not found.` }] };
-            }
-            if (task.status !== "in-progress") {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Cannot submit ${task_id}: status is "${task.status}". Only "in-progress" tasks can be submitted.`
-                        }]
-                };
-            }
-            db.prepare("UPDATE tasks SET status = 'review', updated_at = datetime('now') WHERE id = ?").run(task_id);
-            db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Submitted ${task_id} for review: ${summary}`);
-            let text = `${task_id} submitted for review.`;
-            if (!isSingleEngine()) {
-                const result = dispatchReview([task_id]);
-                text += ` Reviewer: ${formatResult(result)}`;
-            }
-            text += ` Call get_my_status to see your next action.`;
-            return { content: [{ type: "text", text }] };
-        });
-    }
+        }
+        return { content: [{ type: "text", text }] };
+    });
+    server.tool("save_plan", "Save your implementation plan for a task.", {
+        task_id: z.string().describe("Task ID"),
+        plan: z.string().describe("Your implementation plan"),
+    }, async ({ task_id, plan }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        if (!getToolAccess().save_plan)
+            return NO_ACCESS("save_plan");
+        const db = getDb();
+        const task = db.prepare("SELECT status FROM tasks WHERE id = ?").get(task_id);
+        if (!task) {
+            return { content: [{ type: "text", text: `Task ${task_id} not found.` }] };
+        }
+        db.prepare("UPDATE tasks SET plan = ?, updated_at = datetime('now') WHERE id = ?").run(plan, task_id);
+        return { content: [{ type: "text", text: `Plan saved for ${task_id}. Proceed with implementation.` }] };
+    });
+    server.tool("submit_for_review", "Mark a task as complete and submit for review.", {
+        task_id: z.string().describe("Task ID"),
+        summary: z.string().describe("1-3 line summary of what was done"),
+    }, async ({ task_id, summary }) => {
+        if (!isInitialized())
+            return NOT_SETUP;
+        if (!getToolAccess().task_submit)
+            return NO_ACCESS("submit_for_review");
+        const db = getDb();
+        const role = getRole();
+        const task = db.prepare("SELECT status FROM tasks WHERE id = ?").get(task_id);
+        if (!task) {
+            return { content: [{ type: "text", text: `Task ${task_id} not found.` }] };
+        }
+        if (task.status !== "in-progress") {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Cannot submit ${task_id}: status is "${task.status}". Only "in-progress" tasks can be submitted.`
+                    }]
+            };
+        }
+        db.prepare("UPDATE tasks SET status = 'review', updated_at = datetime('now') WHERE id = ?").run(task_id);
+        db.prepare("INSERT INTO activity_log (agent, action) VALUES (?, ?)").run(role, `Submitted ${task_id} for review: ${summary}`);
+        let text = `${task_id} submitted for review.`;
+        if (!isSingleEngine()) {
+            const result = dispatchReview([task_id]);
+            text += ` Reviewer: ${formatResult(result)}`;
+        }
+        text += ` Call get_my_status to see your next action.`;
+        return { content: [{ type: "text", text }] };
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-collab-mcp",
-  "version": "1.2.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",