nightshift-mcp 2.0.1 → 2.1.0

package/dist/index.js

@@ -4,45 +4,58 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
-import { ChatManager } from "./chat-manager.js";
-import { RalphManager } from "./ralph-manager.js";
-import { WorkflowManager } from "./workflow-manager.js";
-import { ContextStore } from "./context-store.js";
-import { TraceManager } from "./trace-manager.js";
 import { spawnAgent, spawnAgentBackground, getAvailableAgents, getAgentStatus, initAgentRegistry, } from "./agent-spawner.js";
 import { toolRegistry } from "./tool-registry.js";
 import { allTools, toolCounts } from "./tools/index.js";
+import { createProjectManagers, getProjectFilesReport, validateProjectPath, } from "./project-context.js";
 // Get project path from environment, command line argument, or default to current directory
-const PROJECT_PATH = process.env.ROBOT_CHAT_PROJECT_PATH || process.argv[2] || process.cwd();
+let PROJECT_PATH = process.env.ROBOT_CHAT_PROJECT_PATH || process.argv[2] || process.cwd();
 /**
  * Tool registration mode:
- * - 'minimal': Only nightshift + nightshift_help (2 tools, ~200 tokens)
- * - 'hybrid': Meta-tools + individual tools (41 tools) - default for backwards compat
- * - 'legacy': Only individual tools (39 tools, ~2,300 tokens)
+ * - 'minimal': Meta-tools + set_project_path (3 tools, ~250 tokens)
+ * - 'hybrid': Meta-tools + individual tools + set_project_path - default
+ * - 'legacy': Individual tools + set_project_path
  */
 const REGISTRATION_MODE = (process.env.NIGHTSHIFT_TOOLS || "hybrid");
-const chatManager = new ChatManager(PROJECT_PATH);
-const ralphManager = new RalphManager(PROJECT_PATH);
-const workflowManager = new WorkflowManager(PROJECT_PATH);
-// Initialize agent registry for cross-session persistence
-initAgentRegistry(PROJECT_PATH);
-const contextStore = new ContextStore(PROJECT_PATH);
-const traceManager = new TraceManager(PROJECT_PATH);
+let chatManager;
+let ralphManager;
+let workflowManager;
+let contextStore;
+let traceManager;
 // Tool execution context
-const toolContext = {
-    chatManager,
-    ralphManager,
-    workflowManager,
-    contextStore,
-    traceManager,
-    projectPath: PROJECT_PATH,
-};
+const toolContext = {};
+function syncToolContext() {
+    toolContext.chatManager = chatManager;
+    toolContext.ralphManager = ralphManager;
+    toolContext.workflowManager = workflowManager;
+    toolContext.contextStore = contextStore;
+    toolContext.traceManager = traceManager;
+    toolContext.projectPath = PROJECT_PATH;
+}
+function reinitializeProjectState(projectPath) {
+    const resolvedPath = validateProjectPath(projectPath);
+    const files = getProjectFilesReport(resolvedPath);
+    const managers = createProjectManagers(resolvedPath);
+    PROJECT_PATH = managers.projectPath;
+    chatManager = managers.chatManager;
+    ralphManager = managers.ralphManager;
+    workflowManager = managers.workflowManager;
+    contextStore = managers.contextStore;
+    traceManager = managers.traceManager;
+    initAgentRegistry(PROJECT_PATH);
+    syncToolContext();
+    return {
+        projectPath: PROJECT_PATH,
+        files,
+    };
+}
+reinitializeProjectState(PROJECT_PATH);
 // Register all tools with the registry
 toolRegistry.registerAll(allTools);
 // Create MCP server
 const server = new McpServer({
     name: "nightshift",
-    version: "1.0.0",
+    version: "2.1.0",
 });
 // Valid message types for schema validation
 const MESSAGE_TYPES = [
@@ -89,6 +102,38 @@ function registerMetaTools() {
         };
     });
 }
+function registerProjectPathTool() {
+    server.tool("set_project_path", "Set the active project path for this MCP server session and reinitialize all project managers.", {
+        projectPath: z.string().describe("Absolute or relative path to the project directory"),
+    }, async ({ projectPath }) => {
+        try {
+            const result = reinitializeProjectState(projectPath);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            message: "Project path updated successfully.",
+                            projectPath: result.projectPath,
+                            files: result.files,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error setting project path: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
 // ============================================
 // Individual Tool Registration (Legacy)
 // ============================================
@@ -111,50 +156,12 @@ function registerIndividualTools() {
             .enum(MESSAGE_TYPES)
             .optional()
             .describe("Filter messages by type"),
-    }, async ({ limit, agent, type }) => {
-        try {
-            const messages = chatManager.readMessages({
-                limit: limit ?? 20,
-                agent,
-                type: type,
-            });
-            if (messages.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No messages found in robot chat.",
-                        },
-                    ],
-                };
-            }
-            const formatted = messages.map((m) => ({
-                agent: m.agent,
-                timestamp: m.timestamp,
-                type: m.type,
-                content: m.content,
-                lineNumber: m.lineNumber,
-            }));
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(formatted, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error reading chat: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+        projectPath: z
+            .string()
+            .optional()
+            .describe("Optional project path override for this call only"),
+    }, async ({ limit, agent, type, projectPath }) => {
+        return toolRegistry.execute("read_robot_chat", { limit, agent, type, projectPath }, toolContext);
     });
     // Tool: write_robot_chat
     server.tool("write_robot_chat", "Write a message to the robot chat file. The message will be formatted with your agent name, current timestamp, and message type.", {
@@ -167,76 +174,18 @@ function registerIndividualTools() {
         content: z
             .string()
             .describe("Message content. For FAILOVER_NEEDED, include: Status, Current Task, Progress, Files Modified."),
-    }, async ({ agent, type, content }) => {
-        try {
-            const message = await chatManager.writeMessage({
-                agent,
-                type: type,
-                content,
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Message written successfully:\n\n${message.raw}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error writing message: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+        projectPath: z
+            .string()
+            .optional()
+            .describe("Optional project path override for this call only"),
+    }, async ({ agent, type, content, projectPath }) => {
+        return toolRegistry.execute("write_robot_chat", { agent, type, content, projectPath }, toolContext);
     });
     // Tool: check_failovers
-    server.tool("check_failovers", "Find unclaimed FAILOVER_NEEDED messages. Use this to see if another agent needs help continuing a task.", {}, async () => {
-        try {
-            const failovers = chatManager.findUnclaimedFailovers();
-            if (failovers.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No unclaimed failovers found.",
-                        },
-                    ],
-                };
-            }
-            const formatted = failovers.map((f) => ({
-                requestingAgent: f.requestingAgent,
-                timestamp: f.message.timestamp,
-                task: f.task || "Not specified",
-                progress: f.progress || "Not specified",
-                filesModified: f.filesModified || [],
-                fullContent: f.message.content,
-            }));
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Found ${failovers.length} unclaimed failover(s):\n\n${JSON.stringify(formatted, null, 2)}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error checking failovers: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+    server.tool("check_failovers", "Find unclaimed FAILOVER_NEEDED messages. Use this to see if another agent needs help continuing a task.", {
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ projectPath }) => {
+        return toolRegistry.execute("check_failovers", { projectPath }, toolContext);
     });
     // Tool: claim_failover
     server.tool("claim_failover", "Claim a failover request by posting a FAILOVER_CLAIMED message. Use this after checking for failovers with check_failovers.", {
@@ -250,89 +199,24 @@ function registerIndividualTools() {
             .string()
             .optional()
             .describe("Description of the task you're continuing (optional)"),
-    }, async ({ agent, originalAgent, task }) => {
-        try {
-            const message = await chatManager.claimFailover(agent, originalAgent, task);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Failover claimed successfully:\n\n${message.raw}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error claiming failover: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+        projectPath: z
+            .string()
+            .optional()
+            .describe("Optional project path override for this call only"),
+    }, async ({ agent, originalAgent, task, projectPath }) => {
+        return toolRegistry.execute("claim_failover", { agent, originalAgent, task, projectPath }, toolContext);
     });
     // Tool: get_chat_path
-    server.tool("get_chat_path", "Get the path to the robot chat file. Useful for debugging or manual inspection.", {}, async () => {
-        try {
-            const chatPath = chatManager.getChatFilePath();
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Robot chat file: ${chatPath}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error getting chat path: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+    server.tool("get_chat_path", "Get the path to the robot chat file. Useful for debugging or manual inspection.", {
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ projectPath }) => {
+        return toolRegistry.execute("get_chat_path", { projectPath }, toolContext);
     });
     // Tool: list_agents
-    server.tool("list_agents", "List all agents who have posted to the chat, with their last activity time and message count.", {}, async () => {
-        try {
-            const agents = chatManager.listAgents();
-            if (agents.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No agents have posted yet.",
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(agents, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error listing agents: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+    server.tool("list_agents", "List all agents who have posted to the chat, with their last activity time and message count.", {
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ projectPath }) => {
+        return toolRegistry.execute("list_agents", { projectPath }, toolContext);
     });
     // Tool: watch_chat
     server.tool("watch_chat", "Get new messages since a specific cursor (line number). Use this for polling/watching the chat. Returns new messages and the updated cursor.", {
@@ -340,56 +224,12 @@ function registerIndividualTools() {
             .number()
             .optional()
             .describe("Line number cursor from previous watch call. Omit to get current cursor without messages."),
-    }, async ({ cursor }) => {
-        try {
-            const currentCursor = chatManager.getLastLineNumber();
-            // If no cursor provided, just return current cursor position
-            if (cursor === undefined) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                cursor: currentCursor,
-                                messages: [],
-                                info: "Use this cursor value in your next watch_chat call to get new messages.",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            const newMessages = chatManager.getMessagesSince(cursor);
-            const formatted = newMessages.map((m) => ({
-                agent: m.agent,
-                timestamp: m.timestamp,
-                type: m.type,
-                content: m.content,
-                lineNumber: m.lineNumber,
-            }));
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            cursor: currentCursor,
-                            messageCount: newMessages.length,
-                            messages: formatted,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error watching chat: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+        projectPath: z
+            .string()
+            .optional()
+            .describe("Optional project path override for this call only"),
+    }, async ({ cursor, projectPath }) => {
+        return toolRegistry.execute("watch_chat", { cursor, projectPath }, toolContext);
     });
     // Tool: archive_chat
     server.tool("archive_chat", "Archive old messages to a separate file, keeping only recent messages in the main chat. Useful for managing chat file size.", {
@@ -397,39 +237,12 @@ function registerIndividualTools() {
             .number()
             .optional()
             .describe("Number of recent messages to keep in main chat (default: 50)"),
-    }, async ({ keepRecent }) => {
-        try {
-            const result = await chatManager.archiveMessages(keepRecent ?? 50);
-            if (result.archived === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No messages to archive. Chat file is small enough.",
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Archived ${result.archived} messages to: ${result.archiveFile}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error archiving chat: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+        projectPath: z
+            .string()
+            .optional()
+            .describe("Optional project path override for this call only"),
+    }, async ({ keepRecent, projectPath }) => {
+        return toolRegistry.execute("archive_chat", { keepRecent, projectPath }, toolContext);
     });
     // ============================================
     // Agent Spawning Tools
@@ -482,236 +295,34 @@ function registerIndividualTools() {
             .number()
             .optional()
             .describe("Timeout in seconds (default: 300 = 5 minutes)"),
-    }, async ({ agent, prompt, timeout }) => {
-        try {
-            // Post to chat that we're spawning an agent
-            chatManager.writeMessage({
-                agent: "NightShift",
-                type: "INFO",
-                content: `Spawning ${agent} agent to work on task...`,
-            });
-            const result = await spawnAgent({
-                agent: agent,
-                prompt,
-                projectPath: PROJECT_PATH,
-                timeout: timeout ? timeout * 1000 : undefined,
-            });
-            // Post result to chat
-            chatManager.writeMessage({
-                agent: "NightShift",
-                type: result.success ? "INFO" : "ERROR",
-                content: `${agent} agent ${result.success ? "completed" : "failed"}: ${result.output.substring(0, 500)}${result.output.length > 500 ? "..." : ""}`,
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: result.success,
-                            agent,
-                            output: result.output,
-                            exitCode: result.exitCode,
-                            error: result.error,
-                        }, null, 2),
-                    },
-                ],
-                isError: !result.success,
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error spawning agent: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // Tool: spawn_agent_background
-    server.tool("spawn_agent_background", "Spawn an AI agent in the background (non-blocking). Returns immediately with the output file path. Use this when you want agents to work in parallel.", {
-        agent: z.enum(AGENT_TYPES).describe("Which agent to spawn (claude, codex, gemini, vibe, or goose)"),
-        prompt: z.string().describe("The prompt/task to send to the agent"),
-    }, async ({ agent, prompt }) => {
-        try {
-            const result = spawnAgentBackground({
-                agent: agent,
-                prompt,
-                projectPath: PROJECT_PATH,
-            });
-            // Post to chat
-            chatManager.writeMessage({
-                agent: "NightShift",
-                type: "INFO",
-                content: `Spawned ${agent} in background (PID: ${result.pid})\nOutput: ${result.outputFile}`,
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            agent,
-                            pid: result.pid,
-                            outputFile: result.outputFile,
-                            status: "running in background",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error spawning background agent: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // Tool: delegate_story
-    server.tool("delegate_story", "Delegate a user story to another AI agent. Claims the story, spawns the agent with full context, and tracks completion. The spawned agent works autonomously.", {
-        agent: z.enum(AGENT_TYPES).describe("Which agent to delegate to"),
-        storyId: z.string().optional().describe("Specific story ID (defaults to next available)"),
-        background: z.boolean().optional().describe("Run in background (default: false)"),
-    }, async ({ agent, storyId, background }) => {
-        try {
-            // Get the story
-            let story;
-            if (storyId) {
-                const prd = ralphManager.readPRD();
-                story = prd?.userStories.find((s) => s.id === storyId && !s.passes);
-            }
-            else {
-                story = ralphManager.getNextStory();
-            }
-            if (!story) {
-                const summary = ralphManager.getCompletionSummary();
-                if (summary.incomplete === 0) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: "<promise>COMPLETE</promise>\nAll stories are complete!",
-                            },
-                        ],
-                    };
-                }
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: storyId ? `Story ${storyId} not found or already complete.` : "No stories available.",
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            // Read progress for context
-            const progress = ralphManager.readProgress();
-            const recentChat = chatManager.readMessages({ limit: 5 });
-            // Build delegation prompt
-            const delegationPrompt = `You are an autonomous coding agent. Complete this user story:
-
-## Story: ${story.id} - ${story.title}
-
-${story.description}
-
-### Acceptance Criteria:
-${story.acceptanceCriteria.map((c) => `- ${c}`).join("\n")}
-
-### Context from Progress File:
-${progress ? progress.substring(0, 2000) : "No previous progress."}
-
-### Recent Chat:
-${recentChat.map((m) => `[${m.agent}] ${m.type}: ${m.content.substring(0, 200)}`).join("\n")}
-
-### Instructions:
-1. Implement the acceptance criteria
-2. Run quality checks (typecheck, lint, test)
-3. Commit with message: "feat: ${story.id} - ${story.title}"
-4. Use the nightshift MCP tools to:
-   - Post STATUS_UPDATE messages as you work
-   - Use complete_story when done (include learnings)
-   - Post FAILOVER_NEEDED if you hit limits
-
-Begin implementation now.`;
-            // Post delegation to chat
-            chatManager.writeMessage({
-                agent: "NightShift",
-                type: "TASK_ASSIGNMENT",
-                content: `Delegating ${story.id} to ${agent}:\n${story.title}`,
-            });
-            if (background) {
-                const result = spawnAgentBackground({
-                    agent: agent,
-                    prompt: delegationPrompt,
-                    projectPath: PROJECT_PATH,
-                });
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                status: "delegated",
-                                agent,
-                                story: story.id,
-                                title: story.title,
-                                background: true,
-                                pid: result.pid,
-                                outputFile: result.outputFile,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            else {
-                const result = await spawnAgent({
-                    agent: agent,
-                    prompt: delegationPrompt,
-                    projectPath: PROJECT_PATH,
-                    timeout: 10 * 60 * 1000, // 10 minutes for story work
-                });
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                status: result.success ? "completed" : "failed",
-                                agent,
-                                story: story.id,
-                                title: story.title,
-                                output: result.output,
-                                error: result.error,
-                            }, null, 2),
-                        },
-                    ],
-                    isError: !result.success,
-                };
-            }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error delegating story: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // Tool: delegate_research
-    server.tool("delegate_research", "Delegate a research or planning task to Gemini. Gemini excels at read-only tasks: codebase analysis, architecture planning, code review, and documentation. Returns findings that can inform implementation decisions.", {
-        task: z.string().describe("The research/planning task (e.g., 'Analyze authentication patterns in codebase', 'Review PR for security issues', 'Plan architecture for feature X')"),
-        context: z.string().optional().describe("Additional context to provide"),
-        background: z.boolean().optional().describe("Run in background (default: false)"),
-    }, async ({ task, context, background }) => {
+        role: z.string().optional().describe("Agent role for audit trail (e.g., 'planner', 'coder', 'fixer', 'verifier', 'reviewer')"),
+        storyId: z.string().optional().describe("Story ID being worked on (for run log tracking)"),
+    }, async ({ agent, prompt, timeout, role, storyId }) => {
+        return toolRegistry.execute("spawn_agent", { agent, prompt, timeout, role, storyId }, toolContext);
+    });
+    // Tool: spawn_agent_background
+    server.tool("spawn_agent_background", "Spawn an AI agent in the background (non-blocking). Returns immediately with the output file path. Use this when you want agents to work in parallel.", {
+        agent: z.enum(AGENT_TYPES).describe("Which agent to spawn (claude, codex, gemini, vibe, or goose)"),
+        prompt: z.string().describe("The prompt/task to send to the agent"),
+        role: z.string().optional().describe("Agent role for audit trail (e.g., 'planner', 'coder', 'fixer', 'verifier')"),
+    }, async ({ agent, prompt, role }) => {
+        return toolRegistry.execute("spawn_agent_background", { agent, prompt, role }, toolContext);
+    });
+    // Tool: delegate_story
+    server.tool("delegate_story", "Delegate a user story to another AI agent. Claims the story, spawns the agent with full context, and tracks completion. The spawned agent works autonomously.", {
+        agent: z.enum(AGENT_TYPES).describe("Which agent to delegate to"),
+        storyId: z.string().optional().describe("Specific story ID (defaults to next available)"),
+        background: z.boolean().optional().describe("Run in background (default: false)"),
+        role: z.string().optional().describe("Agent role for audit trail (default: 'implementer')"),
+    }, async ({ agent, storyId, background, role }) => {
+        return toolRegistry.execute("delegate_story", { agent, storyId, background, role }, toolContext);
+    });
+    // Tool: delegate_research
+    server.tool("delegate_research", "Delegate a research or planning task to Gemini. Gemini excels at read-only tasks: codebase analysis, architecture planning, code review, and documentation. Returns findings that can inform implementation decisions.", {
+        task: z.string().describe("The research/planning task (e.g., 'Analyze authentication patterns in codebase', 'Review PR for security issues', 'Plan architecture for feature X')"),
+        context: z.string().optional().describe("Additional context to provide"),
+        background: z.boolean().optional().describe("Run in background (default: false)"),
+    }, async ({ task, context, background }) => {
         try {
             // Read codebase context
             const progress = ralphManager.readProgress();
@@ -803,261 +414,61 @@ Focus on analysis and recommendations. Do NOT attempt to write or modify files.`
                 content: [
                     {
                         type: "text",
-                        text: `Error delegating research: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // ============================================
-    // Ralph PRD/Progress Tools
-    // ============================================
-    // Tool: read_prd
-    server.tool("read_prd", "Read the PRD (Product Requirements Document) file. Returns structured task list with user stories and their completion status.", {}, async () => {
-        try {
-            if (!ralphManager.hasPRD()) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No prd.json found in project. Create one to use Ralph-style task management.",
-                        },
-                    ],
-                };
-            }
-            const prd = ralphManager.readPRD();
-            const summary = ralphManager.getCompletionSummary();
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({ prd, summary }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error reading PRD: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // Tool: get_next_story
-    server.tool("get_next_story", "Get the next user story to work on (highest priority incomplete story). Use this to claim your next task.", {}, async () => {
-        try {
-            const story = ralphManager.getNextStory();
-            if (!story) {
-                const summary = ralphManager.getCompletionSummary();
-                if (summary.total === 0) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: "No PRD found or no stories defined.",
-                            },
-                        ],
-                    };
-                }
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "<promise>COMPLETE</promise>\nAll stories are complete!",
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(story, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error getting next story: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // Tool: mark_story_complete
-    server.tool("mark_story_complete", "Mark a user story as complete (sets passes: true). Use after successfully implementing and testing a story.", {
-        storyId: z.string().describe("The story ID to mark complete (e.g., 'US-001')"),
-        notes: z.string().optional().describe("Optional notes about the implementation"),
-    }, async ({ storyId, notes }) => {
-        try {
-            const story = ralphManager.markStoryComplete(storyId, notes);
-            if (!story) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Story ${storyId} not found in PRD.`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            const summary = ralphManager.getCompletionSummary();
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Story ${storyId} marked complete!\n\nProgress: ${summary.complete}/${summary.total} (${summary.percentComplete}%)${summary.incomplete === 0 ? "\n\n<promise>COMPLETE</promise>\nAll stories are complete!" : ""}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error marking story complete: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // Tool: get_incomplete_stories
-    server.tool("get_incomplete_stories", "Get all incomplete stories from the PRD, sorted by priority.", {}, async () => {
-        try {
-            const stories = ralphManager.getIncompleteStories();
-            if (stories.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No incomplete stories found. All done!",
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(stories, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error getting incomplete stories: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // Tool: read_progress
-    server.tool("read_progress", "Read the progress.txt file containing learnings and patterns from previous iterations.", {}, async () => {
-        try {
-            const content = ralphManager.readProgress();
-            if (!content) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No progress.txt found. One will be created when you append progress.",
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: content,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error reading progress: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // Tool: append_progress
-    server.tool("append_progress", "Append a progress entry to progress.txt. Include what was implemented, files changed, and learnings for future iterations.", {
-        content: z.string().describe("Progress entry content including: what was implemented, files changed, learnings/gotchas discovered"),
-    }, async ({ content }) => {
-        try {
-            ralphManager.appendProgress(content);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Progress entry added successfully.",
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error appending progress: ${error instanceof Error ? error.message : String(error)}`,
+                        text: `Error delegating research: ${error instanceof Error ? error.message : String(error)}`,
                     },
                 ],
                 isError: true,
             };
         }
     });
+    // ============================================
+    // Ralph PRD/Progress Tools
+    // ============================================
+    // Tool: read_prd
+    server.tool("read_prd", "Read the PRD (Product Requirements Document) file. Returns structured task list with user stories and their completion status.", {
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ projectPath }) => {
+        return toolRegistry.execute("read_prd", { projectPath }, toolContext);
+    });
+    // Tool: get_next_story
+    server.tool("get_next_story", "Get the next user story to work on (highest priority incomplete story). Use this to claim your next task.", {
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ projectPath }) => {
+        return toolRegistry.execute("get_next_story", { projectPath }, toolContext);
+    });
+    // Tool: mark_story_complete
+    server.tool("mark_story_complete", "Mark a user story as complete (sets passes: true). Use after successfully implementing and testing a story.", {
+        storyId: z.string().describe("The story ID to mark complete (e.g., 'US-001')"),
+        notes: z.string().optional().describe("Optional notes about the implementation"),
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ storyId, notes, projectPath }) => {
+        return toolRegistry.execute("mark_story_complete", { storyId, notes, projectPath }, toolContext);
+    });
+    // Tool: get_incomplete_stories
+    server.tool("get_incomplete_stories", "Get all incomplete stories from the PRD, sorted by priority.", {
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ projectPath }) => {
+        return toolRegistry.execute("get_incomplete_stories", { projectPath }, toolContext);
+    });
+    // Tool: read_progress
+    server.tool("read_progress", "Read the progress.txt file containing learnings and patterns from previous iterations.", {
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ projectPath }) => {
+        return toolRegistry.execute("read_progress", { projectPath }, toolContext);
+    });
+    // Tool: append_progress
+    server.tool("append_progress", "Append a progress entry to progress.txt. Include what was implemented, files changed, and learnings for future iterations.", {
+        content: z.string().describe("Progress entry content including: what was implemented, files changed, learnings/gotchas discovered"),
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ content, projectPath }) => {
+        return toolRegistry.execute("append_progress", { content, projectPath }, toolContext);
+    });
     // Tool: add_codebase_pattern
     server.tool("add_codebase_pattern", "Add a reusable pattern to the Codebase Patterns section of progress.txt. Use for general patterns future iterations should know.", {
         pattern: z.string().describe("A reusable pattern (e.g., 'Use sql<number> template for aggregations')"),
-    }, async ({ pattern }) => {
-        try {
-            ralphManager.addCodebasePattern(pattern);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Pattern added: ${pattern}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error adding pattern: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ pattern, projectPath }) => {
+        return toolRegistry.execute("add_codebase_pattern", { pattern, projectPath }, toolContext);
     });
     // =============================================================================
     // Workflow Management Tools
@@ -1429,6 +840,12 @@ Focus on analysis and recommendations. Do NOT attempt to write or modify files.`
             };
         }
     });
+    // Tool: get_run_stats
+    server.tool("get_run_stats", "Get token usage and performance stats from the run log.", {
+        limit: z.number().optional().describe("Number of recent runs to show in detail (default: 10)"),
+    }, async ({ limit }) => {
+        return toolRegistry.execute("get_run_stats", { limit }, toolContext);
+    });
     // =============================================================================
     // Story Management Tools
     // =============================================================================
@@ -1436,78 +853,9 @@ Focus on analysis and recommendations. Do NOT attempt to write or modify files.`
     server.tool("claim_story", "Claim a story to work on and notify other agents via chat. Combines getting next story and posting STORY_CLAIMED message.", {
         agent: z.string().describe("Your agent name (e.g., 'Claude', 'Codex', 'Gemini')"),
         storyId: z.string().optional().describe("Specific story ID to claim (optional - defaults to next available)"),
-    }, async ({ agent, storyId }) => {
-        try {
-            let story;
-            if (storyId) {
-                const prd = ralphManager.readPRD();
-                story = prd?.userStories.find((s) => s.id === storyId && !s.passes);
-                if (!story) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Story ${storyId} not found or already complete.`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-            }
-            else {
-                story = ralphManager.getNextStory();
-            }
-            if (!story) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "<promise>COMPLETE</promise>\nAll stories are complete!",
-                        },
-                    ],
-                };
-            }
-            // Assign in workflow state (atomic operation to prevent race conditions)
-            const assignResult = await workflowManager.assignStory(story.id, agent);
-            if (!assignResult.success) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: assignResult.existingAgent
-                                ? `Story ${story.id} is already being worked on by ${assignResult.existingAgent}.`
-                                : assignResult.error || `Failed to assign story ${story.id} - it may have been claimed by another agent.`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            // Post claim message to chat
-            await chatManager.writeMessage({
-                agent,
-                type: "STORY_CLAIMED",
-                content: `Claiming story: ${story.id} - ${story.title}\n\nDescription: ${story.description}\n\nAcceptance Criteria:\n${story.acceptanceCriteria.map((c) => `- ${c}`).join("\n")}`,
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Claimed story ${story.id}: ${story.title}\n\n${JSON.stringify(story, null, 2)}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error claiming story: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ agent, storyId, projectPath }) => {
+        return toolRegistry.execute("claim_story", { agent, storyId, projectPath }, toolContext);
     });
     // Tool: complete_story
     server.tool("complete_story", "Mark a story complete and notify other agents via chat. Combines marking complete and posting STORY_COMPLETE message.", {
@@ -1516,241 +864,32 @@ Focus on analysis and recommendations. Do NOT attempt to write or modify files.`
         summary: z.string().describe("Brief summary of what was implemented"),
         filesModified: z.array(z.string()).optional().describe("List of files modified"),
         learnings: z.string().optional().describe("Learnings/gotchas for future iterations"),
-    }, async ({ agent, storyId, summary, filesModified, learnings }) => {
-        try {
-            // Validate that this agent owns the story assignment
-            const isOwner = workflowManager.isAgentOwner(storyId, agent);
-            const existingAssignment = workflowManager.isStoryAssigned(storyId);
-            if (existingAssignment && !isOwner) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Cannot complete story ${storyId} - it is assigned to ${existingAssignment.agent}, not ${agent}.`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            const story = ralphManager.markStoryComplete(storyId, summary);
-            if (!story) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Story ${storyId} not found.`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            // Mark assignment as completed in workflow state
-            await workflowManager.completeAssignment(storyId);
-            // Build progress entry
-            let progressEntry = `Story: ${storyId} - ${story.title}\nAgent: ${agent}\n\n${summary}`;
-            if (filesModified && filesModified.length > 0) {
-                progressEntry += `\n\nFiles Modified:\n${filesModified.map((f) => `- ${f}`).join("\n")}`;
-            }
-            if (learnings) {
-                progressEntry += `\n\n**Learnings for future iterations:**\n${learnings}`;
-            }
-            // Append to progress file
-            ralphManager.appendProgress(progressEntry);
-            // Post completion message to chat
-            let chatContent = `Completed: ${storyId} - ${story.title}\n\n${summary}`;
-            if (filesModified && filesModified.length > 0) {
-                chatContent += `\n\nFiles: ${filesModified.join(", ")}`;
-            }
-            await chatManager.writeMessage({
-                agent,
-                type: "STORY_COMPLETE",
-                content: chatContent,
-            });
-            // Auto-create savepoint
-            const savepoint = ralphManager.createSavepoint(storyId, `Completed: ${storyId} - ${story.title}`);
-            const prdSummary = ralphManager.getCompletionSummary();
-            const allWorkDone = ralphManager.isAllWorkComplete();
-            // If all work is done, notify READY_TO_TEST
-            if (allWorkDone) {
-                await chatManager.writeMessage({
-                    agent: "NightShift",
-                    type: "READY_TO_TEST",
-                    content: `All stories and bugs complete!\n\nStories: ${prdSummary.complete}/${prdSummary.total}\n\nReady for human review and testing.`,
-                });
-            }
-            let response = `Story ${storyId} completed!\n\nProgress: ${prdSummary.complete}/${prdSummary.total} (${prdSummary.percentComplete}%)`;
-            if (savepoint.success) {
-                response += `\nSavepoint: ${savepoint.tag}`;
-            }
-            if (allWorkDone) {
-                response += "\n\n<promise>COMPLETE</promise>\nAll work complete! Ready to test.";
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: response,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error completing story: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ agent, storyId, summary, filesModified, learnings, projectPath }) => {
+        return toolRegistry.execute("complete_story", { agent, storyId, summary, filesModified, learnings, projectPath }, toolContext);
     });
     // =============================================================================
     // Bug Management Tools
     // =============================================================================
     // Tool: read_bugs
-    server.tool("read_bugs", "Read the bugs.json file. Returns list of bugs with their fixed status.", {}, async () => {
-        try {
-            if (!ralphManager.hasBugs()) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No bugs.json found. Create one to track bugs.",
-                        },
-                    ],
-                };
-            }
-            const bugList = ralphManager.readBugs();
-            const summary = ralphManager.getBugsSummary();
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({ bugs: bugList, summary }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error reading bugs: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+    server.tool("read_bugs", "Read the bugs.json file. Returns list of bugs with their fixed status.", {
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ projectPath }) => {
+        return toolRegistry.execute("read_bugs", { projectPath }, toolContext);
     });
     // Tool: get_next_bug
-    server.tool("get_next_bug", "Get the next bug to fix (highest priority unfixed bug).", {}, async () => {
-        try {
-            const bug = ralphManager.getNextBug();
-            if (!bug) {
-                const summary = ralphManager.getBugsSummary();
-                if (summary.total === 0) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: "No bugs.json found or no bugs defined.",
-                            },
-                        ],
-                    };
-                }
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "All bugs are fixed!",
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(bug, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error getting next bug: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+    server.tool("get_next_bug", "Get the next bug to fix (highest priority unfixed bug).", {
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ projectPath }) => {
+        return toolRegistry.execute("get_next_bug", { projectPath }, toolContext);
     });
     // Tool: claim_bug
     server.tool("claim_bug", "Claim a bug to work on and notify other agents via chat.", {
         agent: z.string().describe("Your agent name"),
         bugId: z.string().optional().describe("Specific bug ID to claim (optional - defaults to next available)"),
-    }, async ({ agent, bugId }) => {
-        try {
-            let bug;
-            if (bugId) {
-                bug = ralphManager.getBug(bugId);
-                if (!bug || bug.fixed) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Bug ${bugId} not found or already fixed.`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-            }
-            else {
-                bug = ralphManager.getNextBug();
-            }
-            if (!bug) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No unfixed bugs available.",
-                        },
-                    ],
-                };
-            }
-            // Post claim message to chat
-            await chatManager.writeMessage({
-                agent,
-                type: "BUG_CLAIMED",
-                content: `Claiming bug: ${bug.id} - ${bug.title}\n\nDescription: ${bug.description}${bug.stepsToReproduce ? `\n\nSteps to reproduce:\n${bug.stepsToReproduce.map((s) => `- ${s}`).join("\n")}` : ""}`,
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Claimed bug ${bug.id}: ${bug.title}\n\n${JSON.stringify(bug, null, 2)}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error claiming bug: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ agent, bugId, projectPath }) => {
+        return toolRegistry.execute("claim_bug", { agent, bugId, projectPath }, toolContext);
     });
     // Tool: mark_bug_fixed
     server.tool("mark_bug_fixed", "Mark a bug as fixed, create savepoint, and notify via chat. If all work is done, sends READY_TO_TEST.", {
@@ -1758,76 +897,9 @@ Focus on analysis and recommendations. Do NOT attempt to write or modify files.`
         bugId: z.string().describe("The bug ID to mark fixed"),
         summary: z.string().describe("Brief summary of the fix"),
         filesModified: z.array(z.string()).optional().describe("List of files modified"),
-    }, async ({ agent, bugId, summary, filesModified }) => {
-        try {
-            const bug = ralphManager.markBugFixed(bugId, summary);
-            if (!bug) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Bug ${bugId} not found.`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            // Log to progress
-            let progressEntry = `Bug Fixed: ${bugId} - ${bug.title}\nAgent: ${agent}\n\n${summary}`;
-            if (filesModified && filesModified.length > 0) {
-                progressEntry += `\n\nFiles Modified:\n${filesModified.map((f) => `- ${f}`).join("\n")}`;
-            }
-            ralphManager.appendProgress(progressEntry);
-            // Post to chat
-            let chatContent = `Fixed: ${bugId} - ${bug.title}\n\n${summary}`;
-            if (filesModified && filesModified.length > 0) {
-                chatContent += `\n\nFiles: ${filesModified.join(", ")}`;
-            }
-            await chatManager.writeMessage({
-                agent,
-                type: "BUG_FIXED",
-                content: chatContent,
-            });
-            // Auto-create savepoint
-            const savepoint = ralphManager.createSavepoint(bugId, `Fixed: ${bugId} - ${bug.title}`);
-            const bugsSummary = ralphManager.getBugsSummary();
-            const allWorkDone = ralphManager.isAllWorkComplete();
-            // If all work is done, notify READY_TO_TEST
-            if (allWorkDone) {
-                const prdSummary = ralphManager.getCompletionSummary();
-                await chatManager.writeMessage({
-                    agent: "NightShift",
-                    type: "READY_TO_TEST",
-                    content: `All stories and bugs complete!\n\nStories: ${prdSummary.complete}/${prdSummary.total}\nBugs: ${bugsSummary.fixed}/${bugsSummary.total}\n\nReady for human review and testing.`,
-                });
-            }
-            let response = `Bug ${bugId} fixed!\n\nBugs: ${bugsSummary.fixed}/${bugsSummary.total} (${bugsSummary.percentFixed}%)`;
-            if (savepoint.success) {
-                response += `\nSavepoint: ${savepoint.tag}`;
-            }
-            if (allWorkDone) {
-                response += "\n\n<promise>COMPLETE</promise>\nAll work complete! Ready to test.";
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: response,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error marking bug fixed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+        projectPath: z.string().optional().describe("Optional project path override for this call only"),
+    }, async ({ agent, bugId, summary, filesModified, projectPath }) => {
+        return toolRegistry.execute("mark_bug_fixed", { agent, bugId, summary, filesModified, projectPath }, toolContext);
     });
     // =============================================================================
     // Savepoint Tools
@@ -1962,7 +1034,7 @@ Focus on analysis and recommendations. Do NOT attempt to write or modify files.`
             const issues = [];
             const suggestions = [];
             // Check project path
-            checks.push(`Project path: ${PROJECT_PATH}`);
+            checks.push(`Current project path: ${PROJECT_PATH}`);
             // Check for prd.json
             if (ralphManager.hasPRD()) {
                 const summary = ralphManager.getCompletionSummary();
@@ -2118,7 +1190,7 @@ args = ["${PROJECT_PATH}"]
             const fixes = [];
             diagnostics.push(`# NightShift Debug Report\n`);
             diagnostics.push(`Timestamp: ${new Date().toISOString()}`);
-            diagnostics.push(`Project: ${PROJECT_PATH}\n`);
+            diagnostics.push(`Current project path: ${PROJECT_PATH}\n`);
             // 1. Check file system
             diagnostics.push(`## File System Checks`);
             // Check project directory exists and is writable
@@ -2371,7 +1443,7 @@ ${c.dim}              The responsible kind of multi-agent chaos.${c.reset}
 ${c.yellow}${c.bold}  ⚡ Project${c.reset}
      ${c.dim}Path:${c.reset} ${PROJECT_PATH}
      ${c.dim}Chat:${c.reset} .robot-chat/chat.txt
-     ${c.dim}Mode:${c.reset} ${REGISTRATION_MODE} (${toolCounts.total} actions via ${REGISTRATION_MODE === "minimal" ? "2" : REGISTRATION_MODE === "legacy" ? toolCounts.total : toolCounts.total + 2} tools)
+     ${c.dim}Mode:${c.reset} ${REGISTRATION_MODE} (${toolCounts.total} actions via ${REGISTRATION_MODE === "minimal" ? "3" : REGISTRATION_MODE === "legacy" ? toolCounts.total + 1 : toolCounts.total + 3} tools)
 `;
     const agentSection = `
 ${c.green}${c.bold}  🤖 Agents${c.reset}  ${c.dim}(${installed.length}/${agents.length} available)${c.reset}
@@ -2408,18 +1480,19 @@ ${c.dim}  Ready for multi-agent collaboration!${c.reset}
 }
 // Register tools based on mode
 function registerTools() {
+    registerProjectPathTool();
     switch (REGISTRATION_MODE) {
         case "minimal":
-            // Only meta-tools (2 tools, ~200 tokens)
+            // Meta-tools + set_project_path
             registerMetaTools();
             break;
         case "legacy":
-            // Only individual tools (39 tools, ~2,300 tokens)
+            // Individual tools + set_project_path
             registerIndividualTools();
             break;
         case "hybrid":
         default:
-            // Both meta-tools and individual tools (41 tools)
+            // Meta-tools + individual tools + set_project_path
             registerMetaTools();
             registerIndividualTools();
             break;