nightshift-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,2433 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+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 { spawnAgent, spawnAgentBackground, getAvailableAgents, getAgentStatus, } from "./agent-spawner.js";
+import { toolRegistry } from "./tool-registry.js";
+import { allTools, toolCounts } from "./tools/index.js";
+// Get project path from environment or command line argument
+const PROJECT_PATH = process.env.ROBOT_CHAT_PROJECT_PATH || process.argv[2];
+if (!PROJECT_PATH) {
+    console.error("Error: Project path required. Set ROBOT_CHAT_PROJECT_PATH environment variable or pass as argument.");
+    console.error("Usage: nightshift-mcp <project-path>");
+    console.error("   or: ROBOT_CHAT_PROJECT_PATH=/path/to/project nightshift-mcp");
+    process.exit(1);
+}
+/**
+ * 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)
+ */
+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);
+// Tool execution context
+const toolContext = {
+    chatManager,
+    ralphManager,
+    workflowManager,
+    projectPath: PROJECT_PATH,
+};
+// Register all tools with the registry
+toolRegistry.registerAll(allTools);
+// Create MCP server
+const server = new McpServer({
+    name: "nightshift",
+    version: "1.0.0",
+});
+// Valid message types for schema validation
+const MESSAGE_TYPES = [
+    "FAILOVER_NEEDED",
+    "FAILOVER_CLAIMED",
+    "TASK_COMPLETE",
+    "STATUS_UPDATE",
+    "HANDOFF",
+    "INFO",
+    "ERROR",
+    "QUESTION",
+    "ANSWER",
+    "TASK_ASSIGNMENT",
+    "ITERATION_START",
+    "STORY_COMPLETE",
+    "STORY_CLAIMED",
+    "READY_TO_TEST",
+    "BUG_CLAIMED",
+    "BUG_FIXED",
+];
+// ============================================
+// Meta-Tools (Context-Optimized)
+// ============================================
+/**
+ * Register meta-tools for context optimization
+ */
+function registerMetaTools() {
+    // nightshift - Universal dispatcher
+    server.tool("nightshift", "Execute any NightShift action. Use nightshift_help for available actions.", {
+        action: z.string().describe("Action name (e.g., 'claim_story', 'read_prd', 'spawn_agent')"),
+        params: z.record(z.any()).optional().describe("Action parameters as key-value pairs"),
+    }, async ({ action, params }) => {
+        const result = await toolRegistry.execute(action, params || {}, toolContext);
+        return result;
+    });
+    // nightshift_help - Dynamic documentation
+    server.tool("nightshift_help", "Get help on NightShift actions and their parameters.", {
+        action: z.string().optional().describe("Specific action name for detailed help"),
+        category: z.string().optional().describe("Filter by category: chat, prd, workflow, agents, progress, bugs, savepoints, utility"),
+    }, async ({ action, category }) => {
+        const help = toolRegistry.generateHelp(action, category);
+        return {
+            content: [{ type: "text", text: help }],
+        };
+    });
+}
+// ============================================
+// Individual Tool Registration (Legacy)
+// ============================================
+const AGENT_TYPES = ["claude", "codex", "gemini", "vibe"];
+/**
+ * Register all individual tools for backwards compatibility
+ */
+function registerIndividualTools() {
+    // Tool: read_robot_chat
+    server.tool("read_robot_chat", "Read recent messages from the robot chat file. Returns structured data with agent name, timestamp, message type, and content.", {
+        limit: z
+            .number()
+            .optional()
+            .describe("Maximum number of messages to return (default: 20)"),
+        agent: z
+            .string()
+            .optional()
+            .describe("Filter messages by agent name (e.g., 'Claude', 'Codex', 'Gemini')"),
+        type: z
+            .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,
+            };
+        }
+    });
+    // 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.", {
+        agent: z
+            .string()
+            .describe("Your agent name (e.g., 'Claude', 'Codex', 'Gemini')"),
+        type: z
+            .enum(MESSAGE_TYPES)
+            .describe("Message type (e.g., 'STATUS_UPDATE', 'FAILOVER_NEEDED', 'TASK_COMPLETE')"),
+        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,
+            };
+        }
+    });
+    // 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,
+            };
+        }
+    });
+    // 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.", {
+        agent: z
+            .string()
+            .describe("Your agent name (the one claiming the failover)"),
+        originalAgent: z
+            .string()
+            .describe("The agent who requested the failover"),
+        task: z
+            .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,
+            };
+        }
+    });
+    // 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,
+            };
+        }
+    });
+    // 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,
+            };
+        }
+    });
+    // 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.", {
+        cursor: z
+            .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,
+            };
+        }
+    });
+    // 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.", {
+        keepRecent: z
+            .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,
+            };
+        }
+    });
+    // ============================================
+    // Agent Spawning Tools
+    // ============================================
+    // Tool: list_available_agents
+    server.tool("list_available_agents", "Check which AI agent CLIs are installed and available to spawn. Returns list of available agents (claude, codex, gemini, vibe) with their status including whether they can actually run.", {}, async () => {
+        try {
+            const status = await getAgentStatus();
+            const available = await getAvailableAgents();
+            // Build a more informative response
+            const agentInfo = {};
+            for (const agent of AGENT_TYPES) {
+                agentInfo[agent] = {
+                    installed: status[agent].available,
+                    canRun: status[agent].canRun,
+                    reason: status[agent].reason,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            available: available.filter((a) => status[a].canRun),
+                            installed: available,
+                            unavailable: AGENT_TYPES.filter((a) => !available.includes(a)),
+                            details: agentInfo,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error checking agents: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: spawn_agent
+    server.tool("spawn_agent", "Spawn another AI agent (Claude, Codex, Gemini, or Vibe) as a subprocess to work on a task. The agent runs to completion and returns results. Use this to delegate work to other agents.", {
+        agent: z.enum(AGENT_TYPES).describe("Which agent to spawn (claude, codex, gemini, or vibe)"),
+        prompt: z.string().describe("The prompt/task to send to the agent"),
+        timeout: z
+            .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, or vibe)"),
+        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 }) => {
+        try {
+            // Read codebase context
+            const progress = ralphManager.readProgress();
+            const recentChat = chatManager.readMessages({ limit: 5 });
+            const prd = ralphManager.readPRD();
+            // Build research prompt optimized for Gemini's read-only capabilities
+            const researchPrompt = `You are a research and planning agent. Your task is to analyze and provide recommendations.
+
+## Task
+${task}
+
+${context ? `## Additional Context\n${context}\n` : ""}
+## Project Context
+${prd ? `Project: ${prd.projectName || prd.project || "Unknown"}\nDescription: ${prd.description}` : "No PRD found."}
+
+## Progress/Learnings from Previous Work
+${progress ? progress.substring(0, 2000) : "No previous progress."}
+
+## Recent Agent Communication
+${recentChat.map((m) => `[${m.agent}] ${m.type}: ${m.content.substring(0, 200)}`).join("\n")}
+
+## Instructions
+1. Analyze the codebase and gather relevant information
+2. Use read_file, glob, and other read-only tools to explore
+3. Provide clear findings and actionable recommendations
+4. Structure your response as:
+   - **Summary**: Brief overview of findings
+   - **Details**: Detailed analysis
+   - **Recommendations**: Specific actionable suggestions
+   - **Considerations**: Trade-offs or things to watch out for
+
+5. Post your findings via nightshift write_robot_chat with type INFO
+
+Focus on analysis and recommendations. Do NOT attempt to write or modify files.`;
+            // Post delegation to chat
+            await chatManager.writeMessage({
+                agent: "NightShift",
+                type: "TASK_ASSIGNMENT",
+                content: `Research task delegated to Gemini:\n${task}`,
+            });
+            if (background) {
+                const result = spawnAgentBackground({
+                    agent: "gemini",
+                    prompt: researchPrompt,
+                    projectPath: PROJECT_PATH,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                status: "delegated",
+                                agent: "gemini",
+                                task,
+                                background: true,
+                                pid: result.pid,
+                                outputFile: result.outputFile,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            else {
+                const result = await spawnAgent({
+                    agent: "gemini",
+                    prompt: researchPrompt,
+                    projectPath: PROJECT_PATH,
+                    timeout: 5 * 60 * 1000, // 5 minutes for research
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                status: result.success ? "completed" : "failed",
+                                agent: "gemini",
+                                task,
+                                findings: result.output,
+                                error: result.error,
+                            }, null, 2),
+                        },
+                    ],
+                    isError: !result.success,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                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)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // 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,
+            };
+        }
+    });
+    // =============================================================================
+    // Workflow Management Tools
+    // =============================================================================
+    // Tool: init_workflow
+    server.tool("init_workflow", "Initialize a new workflow with project goal and phases. Creates workflow.json for tracking state.", {
+        projectGoal: z.string().describe("High-level goal of the project"),
+        phases: z.array(z.enum(["research", "decisions", "planning", "build", "test", "report", "complete"]))
+            .optional()
+            .describe("Custom phases (default: research, decisions, planning, build, test, report)"),
+    }, async ({ projectGoal, phases }) => {
+        try {
+            const state = await workflowManager.initWorkflow(projectGoal, phases);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Workflow initialized!\n\nProject Goal: ${projectGoal}\nPhases: ${state.phases.map(p => p.name).join(" → ")}\nCurrent Phase: ${state.currentPhase}\n\nWorkflow file: ${workflowManager.getWorkflowPath()}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error initializing workflow: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: get_workflow_state
+    server.tool("get_workflow_state", "Get the current workflow state including phase, assignments, and decisions.", {}, async () => {
+        try {
+            const state = workflowManager.readWorkflow();
+            if (!state) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No workflow initialized. Use init_workflow to start a new workflow.",
+                        },
+                    ],
+                };
+            }
+            const summary = workflowManager.getWorkflowSummary();
+            const activeAssignments = workflowManager.getActiveAssignments();
+            let response = `# Workflow State\n\n`;
+            response += `**Project Goal:** ${state.projectGoal}\n`;
+            response += `**Current Phase:** ${state.currentPhase}\n`;
+            response += `**Progress:** ${summary?.phaseProgress}\n\n`;
+            response += `## Phases\n`;
+            for (const phase of state.phases) {
+                const status = phase.status === "completed" ? "✓" : phase.status === "in_progress" ? "→" : "○";
+                response += `${status} ${phase.name}`;
+                if (phase.startedAt)
+                    response += ` (started: ${phase.startedAt})`;
+                if (phase.completedAt)
+                    response += ` (completed: ${phase.completedAt})`;
+                response += `\n`;
+            }
+            response += `\n## Active Assignments\n`;
+            const assignmentEntries = Object.entries(activeAssignments);
+            if (assignmentEntries.length === 0) {
+                response += `No active assignments.\n`;
+            }
+            else {
+                for (const [storyId, assignment] of assignmentEntries) {
+                    response += `- ${storyId}: ${assignment.agent} (since ${assignment.claimedAt})\n`;
+                }
+            }
+            response += `\n## Decisions (${state.decisions.length} total)\n`;
+            if (state.decisions.length === 0) {
+                response += `No decisions recorded yet.\n`;
+            }
+            else {
+                for (const decision of state.decisions.slice(-5)) {
+                    response += `- ${decision.id}: ${decision.topic} → ${decision.chosen} (by ${decision.decidedBy})\n`;
+                }
+                if (state.decisions.length > 5) {
+                    response += `... and ${state.decisions.length - 5} more\n`;
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error reading workflow: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: advance_phase
+    server.tool("advance_phase", "Advance to the next workflow phase. Use when current phase's exit criteria are met.", {}, async () => {
+        try {
+            const result = await workflowManager.advancePhase();
+            if (!result) {
+                const currentPhase = workflowManager.getCurrentPhase();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: currentPhase
+                                ? `Already at final phase: ${currentPhase}. Cannot advance further.`
+                                : "No workflow initialized. Use init_workflow first.",
+                        },
+                    ],
+                    isError: !currentPhase,
+                };
+            }
+            // Post to chat about phase change
+            await chatManager.writeMessage({
+                agent: "Workflow",
+                type: "STATUS_UPDATE",
+                content: `Phase advanced: ${result.previousPhase} → ${result.newPhase}`,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Phase advanced!\n\nPrevious: ${result.previousPhase}\nCurrent: ${result.newPhase}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error advancing phase: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: set_phase
+    server.tool("set_phase", "Set the workflow to a specific phase (for manual control or recovery).", {
+        phase: z.enum(["research", "decisions", "planning", "build", "test", "report", "complete"])
+            .describe("Target phase to set"),
+    }, async ({ phase }) => {
+        try {
+            const success = await workflowManager.setPhase(phase);
+            if (!success) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Failed to set phase. Ensure workflow is initialized and phase is valid.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Post to chat about phase change
+            await chatManager.writeMessage({
+                agent: "Workflow",
+                type: "STATUS_UPDATE",
+                content: `Phase manually set to: ${phase}`,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Phase set to: ${phase}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error setting phase: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: record_decision
+    server.tool("record_decision", "Record a strategic decision made during the project. Helps track rationale for future reference.", {
+        topic: z.string().describe("What the decision is about (e.g., 'Authentication method')"),
+        options: z.array(z.string()).describe("Options that were considered"),
+        chosen: z.string().describe("The option that was chosen"),
+        rationale: z.string().describe("Why this option was chosen"),
+        decidedBy: z.string().describe("Agent or person who made the decision"),
+    }, async ({ topic, options, chosen, rationale, decidedBy }) => {
+        try {
+            const decision = await workflowManager.recordDecision(topic, options, chosen, rationale, decidedBy);
+            if (!decision) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Failed to record decision. Ensure workflow is initialized with init_workflow first.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Post to chat about decision
+            await chatManager.writeMessage({
+                agent: decidedBy,
+                type: "INFO",
+                content: `Decision recorded: ${decision.id}\nTopic: ${topic}\nChosen: ${chosen}\nRationale: ${rationale}`,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Decision recorded!\n\nID: ${decision.id}\nTopic: ${topic}\nOptions: ${options.join(", ")}\nChosen: ${chosen}\nRationale: ${rationale}\nDecided by: ${decidedBy}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error recording decision: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: get_decisions
+    server.tool("get_decisions", "Get all recorded decisions, optionally filtered by topic.", {
+        topic: z.string().optional().describe("Filter decisions by topic (partial match)"),
+    }, async ({ topic }) => {
+        try {
+            const decisions = topic
+                ? workflowManager.getDecisionsByTopic(topic)
+                : workflowManager.getDecisions();
+            if (decisions.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: topic
+                                ? `No decisions found matching topic: ${topic}`
+                                : "No decisions recorded yet.",
+                        },
+                    ],
+                };
+            }
+            let response = `# Recorded Decisions (${decisions.length})\n\n`;
+            for (const d of decisions) {
+                response += `## ${d.id}: ${d.topic}\n`;
+                response += `- **Options:** ${d.options.join(", ")}\n`;
+                response += `- **Chosen:** ${d.chosen}\n`;
+                response += `- **Rationale:** ${d.rationale}\n`;
+                response += `- **Decided by:** ${d.decidedBy} at ${d.decidedAt}\n\n`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting decisions: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: get_active_assignments
+    server.tool("get_active_assignments", "Get all stories currently being worked on by agents.", {}, async () => {
+        try {
+            const assignments = workflowManager.getActiveAssignments();
+            const entries = Object.entries(assignments);
+            if (entries.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No active assignments. All agents are free to claim stories.",
+                        },
+                    ],
+                };
+            }
+            let response = `# Active Assignments\n\n`;
+            for (const [storyId, assignment] of entries) {
+                response += `- **${storyId}**: ${assignment.agent} (since ${assignment.claimedAt})\n`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting assignments: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: clear_assignment
+    server.tool("clear_assignment", "Clear a story assignment (for abandonment/failover scenarios).", {
+        storyId: z.string().describe("The story ID to clear assignment for"),
+    }, async ({ storyId }) => {
+        try {
+            const cleared = await workflowManager.clearAssignment(storyId);
+            if (!cleared) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No active assignment found for story ${storyId}.`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Assignment cleared for story ${storyId}. It can now be claimed by another agent.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error clearing assignment: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // =============================================================================
+    // Story Management Tools
+    // =============================================================================
+    // Tool: claim_story
+    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,
+            };
+        }
+    });
+    // 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.", {
+        agent: z.string().describe("Your agent name"),
+        storyId: z.string().describe("The story ID to mark complete"),
+        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,
+            };
+        }
+    });
+    // =============================================================================
+    // 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,
+            };
+        }
+    });
+    // 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,
+            };
+        }
+    });
+    // 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,
+            };
+        }
+    });
+    // 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.", {
+        agent: z.string().describe("Your agent name"),
+        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,
+            };
+        }
+    });
+    // =============================================================================
+    // Savepoint Tools
+    // =============================================================================
+    // Tool: create_savepoint
+    server.tool("create_savepoint", "Create a manual savepoint (git commit + tag). Use for checkpoints during work.", {
+        label: z.string().describe("Label for the savepoint (e.g., 'auth-working', 'pre-refactor')"),
+        message: z.string().optional().describe("Optional commit message"),
+    }, async ({ label, message }) => {
+        try {
+            const result = ralphManager.createSavepoint(label, message);
+            if (!result.success) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Failed to create savepoint: ${result.error}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Savepoint created: ${result.tag}\n\nRollback with: rollback_savepoint("${label}")`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error creating savepoint: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: list_savepoints
+    server.tool("list_savepoints", "List all savepoints (git tags with savepoint/ prefix).", {}, async () => {
+        try {
+            const savepoints = ralphManager.listSavepoints();
+            if (savepoints.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No savepoints found.",
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Savepoints:\n${savepoints.map((s) => `  - ${s}`).join("\n")}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error listing savepoints: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: rollback_savepoint
+    server.tool("rollback_savepoint", "Rollback to a previous savepoint. WARNING: This discards all changes after the savepoint.", {
+        label: z.string().describe("Savepoint label to rollback to (e.g., 'US-001' or 'auth-working')"),
+    }, async ({ label }) => {
+        try {
+            const result = ralphManager.rollbackToSavepoint(label);
+            if (!result.success) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Failed to rollback: ${result.error}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Notify via chat
+            await chatManager.writeMessage({
+                agent: "NightShift",
+                type: "INFO",
+                content: `Rolled back to savepoint: ${label}`,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Rolled back to savepoint/${label}\n\nAll changes after this point have been discarded.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error rolling back: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // =============================================================================
+    // Setup & Debug Tools
+    // =============================================================================
+    // Tool: nightshift_setup
+    server.tool("nightshift_setup", "Get setup instructions and check project configuration for NightShift MCP. Use this to understand how to configure agents or troubleshoot setup issues.", {
+        showExamples: z.boolean().optional().describe("Include example prd.json and bugs.json templates"),
+    }, async ({ showExamples }) => {
+        try {
+            const checks = [];
+            const issues = [];
+            const suggestions = [];
+            // Check project path
+            checks.push(`Project path: ${PROJECT_PATH}`);
+            // Check for prd.json
+            if (ralphManager.hasPRD()) {
+                const summary = ralphManager.getCompletionSummary();
+                checks.push(`✓ prd.json found (${summary.complete}/${summary.total} stories complete)`);
+            }
+            else {
+                issues.push("✗ No prd.json found");
+                suggestions.push("Create prd.json with user stories to enable task management");
+            }
+            // Check for bugs.json
+            if (ralphManager.hasBugs()) {
+                const summary = ralphManager.getBugsSummary();
+                checks.push(`✓ bugs.json found (${summary.fixed}/${summary.total} bugs fixed)`);
+            }
+            else {
+                checks.push("○ No bugs.json (optional - create when testing finds issues)");
+            }
+            // Check for .robot-chat directory
+            const chatPath = chatManager.getChatFilePath();
+            if (fs.existsSync(chatPath)) {
+                checks.push("✓ Chat file exists");
+            }
+            else {
+                checks.push("○ Chat file will be created on first message");
+            }
+            // Check for .gitignore entry
+            const gitignorePath = path.join(PROJECT_PATH, ".gitignore");
+            if (fs.existsSync(gitignorePath)) {
+                const gitignore = fs.readFileSync(gitignorePath, "utf-8");
+                if (gitignore.includes(".robot-chat")) {
+                    checks.push("✓ .robot-chat in .gitignore");
+                }
+                else {
+                    issues.push("✗ .robot-chat not in .gitignore");
+                    suggestions.push("Add '.robot-chat/' to .gitignore to prevent committing chat logs");
+                }
+            }
+            else {
+                issues.push("✗ No .gitignore file");
+                suggestions.push("Create .gitignore and add '.robot-chat/'");
+            }
+            // Check git repo
+            try {
+                const { execSync } = await import("child_process");
+                execSync("git rev-parse --git-dir", { cwd: PROJECT_PATH, stdio: "pipe" });
+                checks.push("✓ Git repository initialized");
+            }
+            catch {
+                issues.push("✗ Not a git repository");
+                suggestions.push("Initialize git with 'git init' for savepoints to work");
+            }
+            // Check available agents
+            const agents = await getAvailableAgents();
+            if (agents.length > 0) {
+                checks.push(`✓ Available agents: ${agents.join(", ")}`);
+            }
+            else {
+                issues.push("✗ No agents available");
+                suggestions.push("Install at least one agent CLI (claude, codex, gemini, or vibe)");
+            }
+            // Build response
+            let response = `# NightShift Setup Status\n\n`;
+            response += `## Checks\n${checks.join("\n")}\n\n`;
+            if (issues.length > 0) {
+                response += `## Issues\n${issues.join("\n")}\n\n`;
+            }
+            if (suggestions.length > 0) {
+                response += `## Suggestions\n${suggestions.map(s => `- ${s}`).join("\n")}\n\n`;
+            }
+            response += `## Agent Configuration\n\n`;
+            response += `**Claude Code** (~/.claude.json):\n\`\`\`json
+{
+  "mcpServers": {
+    "nightshift": {
+      "command": "nightshift-mcp",
+      "args": ["${PROJECT_PATH}"]
+    }
+  }
+}
+\`\`\`\n\n`;
+            response += `**Codex** (~/.codex/config.toml):\n\`\`\`toml
+[mcp_servers.nightshift]
+command = "nightshift-mcp"
+args = ["${PROJECT_PATH}"]
+\`\`\`\n\n`;
+            if (showExamples) {
+                response += `## Example Templates\n\n`;
+                response += `**prd.json**:\n\`\`\`json
+{
+  "project": "MyProject",
+  "description": "Project description",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "First feature",
+      "description": "Implement the first feature",
+      "acceptanceCriteria": [
+        "Criteria 1",
+        "Criteria 2"
+      ],
+      "priority": 1,
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}
+\`\`\`\n\n`;
+                response += `**bugs.json**:\n\`\`\`json
+{
+  "project": "MyProject",
+  "bugs": [
+    {
+      "id": "BUG-001",
+      "title": "Bug description",
+      "description": "Detailed bug description",
+      "stepsToReproduce": [
+        "Step 1",
+        "Step 2"
+      ],
+      "priority": 1,
+      "fixed": false
+    }
+  ]
+}
+\`\`\`\n`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting setup info: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: nightshift_debug
+    server.tool("nightshift_debug", "Diagnose issues with NightShift MCP. Checks file permissions, validates JSON files, reviews recent errors, and provides troubleshooting guidance.", {}, async () => {
+        try {
+            const diagnostics = [];
+            const errors = [];
+            const fixes = [];
+            diagnostics.push(`# NightShift Debug Report\n`);
+            diagnostics.push(`Timestamp: ${new Date().toISOString()}`);
+            diagnostics.push(`Project: ${PROJECT_PATH}\n`);
+            // 1. Check file system
+            diagnostics.push(`## File System Checks`);
+            // Check project directory exists and is writable
+            try {
+                fs.accessSync(PROJECT_PATH, fs.constants.W_OK);
+                diagnostics.push(`✓ Project directory is writable`);
+            }
+            catch {
+                errors.push(`✗ Project directory is not writable`);
+                fixes.push(`Check permissions on ${PROJECT_PATH}`);
+            }
+            // Check .robot-chat directory
+            const robotChatDir = path.join(PROJECT_PATH, ".robot-chat");
+            if (fs.existsSync(robotChatDir)) {
+                try {
+                    fs.accessSync(robotChatDir, fs.constants.W_OK);
+                    diagnostics.push(`✓ .robot-chat directory is writable`);
+                }
+                catch {
+                    errors.push(`✗ .robot-chat directory is not writable`);
+                    fixes.push(`Run: chmod 755 ${robotChatDir}`);
+                }
+            }
+            else {
+                diagnostics.push(`○ .robot-chat directory doesn't exist (will be created)`);
+            }
+            // 2. Validate JSON files
+            diagnostics.push(`\n## JSON Validation`);
+            // Validate prd.json
+            if (ralphManager.hasPRD()) {
+                try {
+                    const prd = ralphManager.readPRD();
+                    if (prd && prd.userStories && Array.isArray(prd.userStories)) {
+                        diagnostics.push(`✓ prd.json is valid (${prd.userStories.length} stories)`);
+                        // Check for common issues
+                        const storiesWithoutId = prd.userStories.filter(s => !s.id);
+                        if (storiesWithoutId.length > 0) {
+                            errors.push(`✗ ${storiesWithoutId.length} stories missing 'id' field`);
+                            fixes.push(`Add unique 'id' to each story (e.g., "US-001")`);
+                        }
+                        const storiesWithoutPriority = prd.userStories.filter(s => s.priority === undefined);
+                        if (storiesWithoutPriority.length > 0) {
+                            errors.push(`✗ ${storiesWithoutPriority.length} stories missing 'priority' field`);
+                            fixes.push(`Add 'priority' number to each story (lower = higher priority)`);
+                        }
+                    }
+                    else {
+                        errors.push(`✗ prd.json missing 'userStories' array`);
+                        fixes.push(`Add "userStories": [] to prd.json`);
+                    }
+                }
+                catch (e) {
+                    errors.push(`✗ prd.json parse error: ${e instanceof Error ? e.message : String(e)}`);
+                    fixes.push(`Check prd.json for JSON syntax errors`);
+                }
+            }
+            else {
+                diagnostics.push(`○ No prd.json found`);
+            }
+            // Validate bugs.json
+            if (ralphManager.hasBugs()) {
+                try {
+                    const bugs = ralphManager.readBugs();
+                    if (bugs && bugs.bugs && Array.isArray(bugs.bugs)) {
+                        diagnostics.push(`✓ bugs.json is valid (${bugs.bugs.length} bugs)`);
+                    }
+                    else {
+                        errors.push(`✗ bugs.json missing 'bugs' array`);
+                        fixes.push(`Add "bugs": [] to bugs.json`);
+                    }
+                }
+                catch (e) {
+                    errors.push(`✗ bugs.json parse error: ${e instanceof Error ? e.message : String(e)}`);
+                    fixes.push(`Check bugs.json for JSON syntax errors`);
+                }
+            }
+            // 3. Check daemon lock
+            diagnostics.push(`\n## Daemon Status`);
+            const lockFile = path.join(robotChatDir, "daemon.lock");
+            if (fs.existsSync(lockFile)) {
+                try {
+                    const pid = fs.readFileSync(lockFile, "utf-8").trim();
+                    try {
+                        process.kill(parseInt(pid), 0);
+                        diagnostics.push(`⚠ Daemon is running (PID: ${pid})`);
+                    }
+                    catch {
+                        errors.push(`✗ Stale daemon lock file (PID ${pid} not running)`);
+                        fixes.push(`Remove stale lock: rm ${lockFile}`);
+                    }
+                }
+                catch {
+                    diagnostics.push(`○ No daemon running`);
+                }
+            }
+            else {
+                diagnostics.push(`○ No daemon running`);
+            }
+            // 4. Check recent chat errors
+            diagnostics.push(`\n## Recent Chat Activity`);
+            try {
+                const recentMessages = chatManager.readMessages({ limit: 10 });
+                const errorMessages = recentMessages.filter(m => m.type === "ERROR");
+                const failovers = recentMessages.filter(m => m.type === "FAILOVER_NEEDED");
+                diagnostics.push(`Messages in last 10: ${recentMessages.length}`);
+                if (errorMessages.length > 0) {
+                    errors.push(`✗ ${errorMessages.length} ERROR messages in recent chat`);
+                    errorMessages.forEach(m => {
+                        diagnostics.push(`  - [${m.agent}] ${m.content.substring(0, 100)}...`);
+                    });
+                }
+                if (failovers.length > 0) {
+                    diagnostics.push(`⚠ ${failovers.length} FAILOVER_NEEDED messages`);
+                    const unclaimed = chatManager.findUnclaimedFailovers();
+                    if (unclaimed.length > 0) {
+                        errors.push(`✗ ${unclaimed.length} unclaimed failovers need attention`);
+                        fixes.push(`Claim failovers with claim_failover tool`);
+                    }
+                }
+            }
+            catch {
+                diagnostics.push(`○ No chat history yet`);
+            }
+            // 5. Agent availability
+            diagnostics.push(`\n## Agent Status`);
+            const status = await getAgentStatus();
+            for (const [agent, info] of Object.entries(status)) {
+                if (info.canRun) {
+                    diagnostics.push(`✓ ${agent}: available`);
+                }
+                else if (info.available) {
+                    errors.push(`✗ ${agent}: installed but cannot run`);
+                    if (info.reason) {
+                        fixes.push(`${agent}: ${info.reason}`);
+                    }
+                }
+                else {
+                    diagnostics.push(`○ ${agent}: not installed`);
+                }
+            }
+            // 6. Git status
+            diagnostics.push(`\n## Git Status`);
+            try {
+                const { execSync } = await import("child_process");
+                execSync("git rev-parse --git-dir", { cwd: PROJECT_PATH, stdio: "pipe" });
+                diagnostics.push(`✓ Git repository`);
+                // Check for uncommitted changes
+                const gitStatus = execSync("git status --porcelain", {
+                    cwd: PROJECT_PATH,
+                    encoding: "utf-8",
+                }).trim();
+                if (gitStatus) {
+                    const lines = gitStatus.split("\n").length;
+                    diagnostics.push(`⚠ ${lines} uncommitted changes`);
+                }
+                else {
+                    diagnostics.push(`✓ Working directory clean`);
+                }
+                // List savepoints
+                const savepoints = ralphManager.listSavepoints();
+                diagnostics.push(`Savepoints: ${savepoints.length}`);
+            }
+            catch {
+                errors.push(`✗ Not a git repository`);
+                fixes.push(`Initialize git: git init`);
+            }
+            // Build response
+            let response = diagnostics.join("\n");
+            if (errors.length > 0) {
+                response += `\n\n## Errors Found (${errors.length})\n${errors.join("\n")}`;
+            }
+            if (fixes.length > 0) {
+                response += `\n\n## Suggested Fixes\n${fixes.map((f, i) => `${i + 1}. ${f}`).join("\n")}`;
+            }
+            if (errors.length === 0) {
+                response += `\n\n✅ No issues found. NightShift is ready to use.`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error running diagnostics: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+// ANSI color codes
+const colors = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    cyan: "\x1b[36m",
+    yellow: "\x1b[33m",
+    green: "\x1b[32m",
+    red: "\x1b[31m",
+    magenta: "\x1b[35m",
+    blue: "\x1b[34m",
+    white: "\x1b[37m",
+    bgBlue: "\x1b[44m",
+};
+// Agent installation instructions
+const AGENT_INSTALL_HINTS = {
+    claude: "npm install -g @anthropic-ai/claude-code",
+    codex: "npm install -g @openai/codex",
+    gemini: "npm install -g @google/gemini-cli",
+    vibe: "pip install mistral-vibe",
+};
+// Agent descriptions for the welcome screen
+const AGENT_ROLES = {
+    claude: "orchestration, complex logic",
+    codex: "code generation, implementation",
+    gemini: "research, planning, review",
+    vibe: "follows detailed specs",
+};
+// Print welcome banner to stderr
+async function printWelcomeBanner() {
+    const c = colors;
+    const status = await getAgentStatus();
+    const agents = Object.entries(status);
+    const installed = agents.filter(([_, s]) => s.canRun).map(([name]) => name);
+    const asciiArt = `
+${c.blue}${c.bold}
+  ███╗   ██╗██╗ ██████╗ ██╗  ██╗████████╗███████╗██╗  ██╗███████╗████████╗
+  ████╗  ██║██║██╔════╝ ██║  ██║╚══██╔══╝██╔════╝██║  ██║██╔════╝╚══██╔══╝
+  ██╔██╗ ██║██║██║  ███╗███████║   ██║   ███████╗███████║█████╗     ██║
+  ██║╚██╗██║██║██║   ██║██╔══██║   ██║   ╚════██║██╔══██║██╔══╝     ██║
+  ██║ ╚████║██║╚██████╔╝██║  ██║   ██║   ███████║██║  ██║██║        ██║
+  ╚═╝  ╚═══╝╚═╝ ╚═════╝ ╚═╝  ╚═╝   ╚═╝   ╚══════╝╚═╝  ╚═╝╚═╝        ╚═╝${c.reset}
+
+${c.dim}              The responsible kind of multi-agent chaos.${c.reset}
+`;
+    const projectInfo = `
+${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)
+`;
+    const agentSection = `
+${c.green}${c.bold}  🤖 Agents${c.reset}  ${c.dim}(${installed.length}/${agents.length} available)${c.reset}
+${agents.map(([name, s]) => {
+        const icon = s.canRun ? `${c.green}✓${c.reset}` : `${c.red}✗${c.reset}`;
+        const nameStr = s.canRun ? `${c.bold}${name}${c.reset}` : `${c.dim}${name}${c.reset}`;
+        const roleStr = `${c.dim}${AGENT_ROLES[name]}${c.reset}`;
+        const installHint = !s.available ? `\n       ${c.dim}└─ ${AGENT_INSTALL_HINTS[name]}${c.reset}` : '';
+        return `     ${icon} ${nameStr.padEnd(20)} ${roleStr}${installHint}`;
+    }).join('\n')}
+`;
+    // Check if .robot-chat is in .gitignore
+    let gitignoreWarning = '';
+    try {
+        const gitignorePath = path.join(PROJECT_PATH, '.gitignore');
+        if (fs.existsSync(gitignorePath)) {
+            const gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8');
+            if (!gitignoreContent.includes('.robot-chat')) {
+                gitignoreWarning = `\n${c.yellow}  ⚠️  Consider adding .robot-chat/ to your .gitignore${c.reset}\n`;
+            }
+        }
+        else {
+            gitignoreWarning = `\n${c.yellow}  ⚠️  No .gitignore found - consider adding .robot-chat/ to prevent committing chat logs${c.reset}\n`;
+        }
+    }
+    catch {
+        // Ignore errors reading .gitignore
+    }
+    const footer = `
+${c.cyan}─────────────────────────────────────────────────────────────────────────────${c.reset}
+${c.dim}  Ready for multi-agent collaboration!${c.reset}
+`;
+    console.error(asciiArt + projectInfo + agentSection + gitignoreWarning + footer);
+}
+// Register tools based on mode
+function registerTools() {
+    switch (REGISTRATION_MODE) {
+        case "minimal":
+            // Only meta-tools (2 tools, ~200 tokens)
+            registerMetaTools();
+            break;
+        case "legacy":
+            // Only individual tools (39 tools, ~2,300 tokens)
+            registerIndividualTools();
+            break;
+        case "hybrid":
+        default:
+            // Both meta-tools and individual tools (41 tools)
+            registerMetaTools();
+            registerIndividualTools();
+            break;
+    }
+}
+// Start the server
+async function main() {
+    registerTools();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    await printWelcomeBanner();
+}
+main().catch((error) => {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map