@promptprojectmanager/mcp-server 4.4.3 → 4.5.1

package/dist/index.js

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
+import {
+  isProcessRunning,
+  isWatcherRunning,
+  readPid,
+  readStatus,
+  removePid,
+  writeStatus
+} from "./chunk-POSCT6WJ.js";
 
 // src/index.ts
 import minimist from "minimist";
@@ -68,19 +76,19 @@ function parseUpdateArgs(args) {
   if (!ticketSlug || !content) return null;
   return { ticketSlug, content };
 }
-function parseRunPromptArgs(args) {
+function parsePromptsRunArgs(args) {
   const parsed = args;
   const slug = typeof parsed?.slug === "string" ? parsed.slug : void 0;
   if (!slug) return null;
   return { slug };
 }
-function parseSystemPromptsArgs(args) {
+function parsePromptsListArgs(args) {
   const parsed = args;
   return {
     search: typeof parsed?.search === "string" ? parsed.search : void 0
   };
 }
-function parseSystemPromptsUpdateArgs(args) {
+function parsePromptsUpdateArgs(args) {
   const parsed = args;
   const slug = typeof parsed?.slug === "string" ? parsed.slug : void 0;
   if (!slug) return null;
@@ -90,6 +98,171 @@ function parseSystemPromptsUpdateArgs(args) {
     changeLogMessage: typeof parsed?.changeLogMessage === "string" ? parsed.changeLogMessage : void 0
   };
 }
+function parseWatcherStartArgs(args) {
+  const parsed = args;
+  return {
+    pollIntervalMs: typeof parsed?.pollIntervalMs === "number" ? parsed.pollIntervalMs : void 0,
+    maxParallel: typeof parsed?.maxParallel === "number" ? parsed.maxParallel : void 0,
+    ticketTimeout: typeof parsed?.ticketTimeout === "number" ? parsed.ticketTimeout : void 0,
+    enableNotifications: typeof parsed?.enableNotifications === "boolean" ? parsed.enableNotifications : void 0,
+    workingDirectory: typeof parsed?.workingDirectory === "string" ? parsed.workingDirectory : void 0
+  };
+}
+
+// src/watcher/watcher_controller.ts
+import { spawn } from "child_process";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+async function startWatcher(baseConfig, args) {
+  const workingDirectory = args?.workingDirectory ?? baseConfig.workingDirectory;
+  if (isWatcherRunning(workingDirectory)) {
+    const existingPid = readPid(workingDirectory);
+    const existingStatus = readStatus(workingDirectory);
+    return {
+      success: true,
+      message: "Watcher is already running",
+      pid: existingPid,
+      alreadyRunning: true,
+      config: existingStatus?.config
+    };
+  }
+  const config = {
+    projectSlug: baseConfig.projectSlug,
+    projectToken: baseConfig.projectToken,
+    convexUrl: baseConfig.convexUrl,
+    workingDirectory,
+    pollIntervalMs: args?.pollIntervalMs ?? 3e4,
+    maxParallel: args?.maxParallel ?? 1,
+    ticketTimeout: args?.ticketTimeout ?? 18e5,
+    enableNotifications: args?.enableNotifications ?? true
+  };
+  const configJson = JSON.stringify(config);
+  const configBase64 = Buffer.from(configJson).toString("base64");
+  const daemonPath = getDaemonPath();
+  try {
+    const child = spawn(process.execPath, [daemonPath, "--config", configBase64], {
+      detached: true,
+      stdio: ["ignore", "ignore", "ignore"],
+      cwd: workingDirectory
+    });
+    child.unref();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const pid = readPid(workingDirectory);
+    if (pid && isProcessRunning(pid)) {
+      return {
+        success: true,
+        message: "Watcher started successfully",
+        pid,
+        alreadyRunning: false,
+        config: {
+          projectSlug: config.projectSlug,
+          convexUrl: config.convexUrl,
+          pollIntervalMs: config.pollIntervalMs,
+          maxParallel: config.maxParallel,
+          ticketTimeout: config.ticketTimeout,
+          enableNotifications: config.enableNotifications,
+          workingDirectory: config.workingDirectory
+        }
+      };
+    } else {
+      return {
+        success: false,
+        message: "Daemon process started but failed to initialize. Check logs in .ppm/yolo/"
+      };
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      success: false,
+      message: `Failed to start watcher: ${errorMessage}`
+    };
+  }
+}
+async function stopWatcher(workingDirectory) {
+  const pid = readPid(workingDirectory);
+  if (!pid) {
+    return {
+      success: true,
+      message: "No watcher is running",
+      wasRunning: false
+    };
+  }
+  if (!isProcessRunning(pid)) {
+    removePid(workingDirectory);
+    const status = readStatus(workingDirectory);
+    if (status) {
+      writeStatus(workingDirectory, { ...status, state: "stopped" });
+    }
+    return {
+      success: true,
+      message: "Watcher was not running (cleaned up stale PID file)",
+      wasRunning: false
+    };
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    const maxWait = 5e3;
+    const checkInterval = 100;
+    let waited = 0;
+    while (waited < maxWait && isProcessRunning(pid)) {
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    if (isProcessRunning(pid)) {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+    removePid(workingDirectory);
+    const status = readStatus(workingDirectory);
+    if (status) {
+      writeStatus(workingDirectory, { ...status, state: "stopped" });
+    }
+    return {
+      success: true,
+      message: "Watcher stopped successfully",
+      wasRunning: true
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      success: false,
+      message: `Failed to stop watcher: ${errorMessage}`,
+      wasRunning: true
+    };
+  }
+}
+function getWatcherStatus(workingDirectory) {
+  const status = readStatus(workingDirectory);
+  if (!status) {
+    return {
+      success: true,
+      message: "No watcher has been started for this project"
+    };
+  }
+  if (status.state === "running" && status.pid) {
+    if (!isProcessRunning(status.pid)) {
+      const updatedStatus = { ...status, state: "stopped" };
+      writeStatus(workingDirectory, updatedStatus);
+      removePid(workingDirectory);
+      return {
+        success: true,
+        status: updatedStatus,
+        message: "Watcher process has stopped unexpectedly"
+      };
+    }
+  }
+  return {
+    success: true,
+    status
+  };
+}
+function getDaemonPath() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentFilePath);
+  return join(currentDir, "watcher_daemon.js");
+}
 
 // src/prompt-builder.ts
 var AmbiguousPromptError = class extends Error {
@@ -173,7 +346,6 @@ async function startServer(config, convexClientRaw) {
     config.projectToken
   );
   console.error(`[MCP] Project token mode: loaded ${accountScopedPrompts.length} prompts`);
-  const projectsForTickets = [{ slug: tokenProjectSlug, name: tokenProjectSlug }];
   console.error(`[MCP] Found ${accountScopedPrompts.length} account-scoped prompts (global tools)`);
   console.error(`[MCP] Ticket project scope: ${tokenProjectSlug} (token-scoped)`);
   if (accountScopedPrompts.length === 0) {
@@ -181,78 +353,100 @@ async function startServer(config, convexClientRaw) {
       "[MCP] WARNING: No prompts found. Create prompts in the 'prompts' section to expose them via MCP."
     );
   }
-  const projectSlugs = new Set(projectsForTickets.map((p) => p.slug));
-  const dynamicTicketTools = [];
-  for (const projectSlug of projectSlugs) {
-    dynamicTicketTools.push({
-      name: `${projectSlug}_tickets_work`,
+  const projectSlug = tokenProjectSlug;
+  const dynamicTicketTools = [
+    // Unified work command (replaces both tickets_open and tickets_work)
+    {
+      name: `tickets_work`,
       description: `Get work from the "${projectSlug}" project. With no args: gets next ticket from open queue. With ticket slug/number: opens or resumes that specific ticket.`,
       slashDescription: `Get next ticket from queue, or work on specific ticket by slug/number`,
       projectSlug,
       type: "work"
-    });
-    dynamicTicketTools.push({
-      name: `${projectSlug}_tickets_close`,
+    },
+    {
+      name: `tickets_close`,
       description: `Mark a working ticket as completed in the "${projectSlug}" project`,
       slashDescription: `Mark a working ticket as completed`,
       projectSlug,
       type: "close"
-    });
-    dynamicTicketTools.push({
-      name: `${projectSlug}_tickets_create`,
+    },
+    {
+      name: `tickets_create`,
       description: `Create a new ticket in the "${projectSlug}" project queue`,
       slashDescription: `Create a new ticket in the backlog queue`,
       projectSlug,
       type: "create"
-    });
-    dynamicTicketTools.push({
-      name: `${projectSlug}_tickets_search`,
+    },
+    {
+      name: `tickets_search`,
       description: `Search for tickets by content in the "${projectSlug}" project`,
       slashDescription: `Search for tickets by content`,
       projectSlug,
       type: "search"
-    });
-    dynamicTicketTools.push({
-      name: `${projectSlug}_tickets_get`,
+    },
+    {
+      name: `tickets_get`,
       description: `Get a specific ticket by number or slug from "${projectSlug}" (read-only)`,
       slashDescription: `Get a specific ticket by number or slug (read-only)`,
       projectSlug,
       type: "get"
-    });
-    dynamicTicketTools.push({
-      name: `${projectSlug}_tickets_list`,
+    },
+    {
+      name: `tickets_list`,
       description: `List active tickets in the "${projectSlug}" project (backlog + open + working)`,
       slashDescription: `List active tickets (backlog + open + working)`,
       projectSlug,
       type: "list"
-    });
-    dynamicTicketTools.push({
-      name: `${projectSlug}_tickets_update`,
+    },
+    {
+      name: `tickets_update`,
       description: `Update a ticket in the "${projectSlug}" project by appending content with timestamp`,
       slashDescription: `Update a ticket by appending content with timestamp`,
       projectSlug,
       type: "update"
-    });
-  }
-  console.error(`[MCP] Registering ${dynamicTicketTools.length} ticket tools for ${projectSlugs.size} project(s)...`);
-  const globalSystemTools = [
+    },
+    // YOLO watcher tools - autonomous ticket execution
     {
-      name: "system_run_prompt",
-      description: "Execute a prompt by slug. Use system_prompts to list available prompts.",
-      slashDescription: "Execute a prompt by slug. Use system_prompts to list available prompts."
+      name: `tickets_yolo_start`,
+      description: `Start the YOLO ticket watcher for "${projectSlug}". Polls for open tickets with yolo flag and spawns Terminal windows with Claude Code to execute them autonomously.`,
+      slashDescription: `Start YOLO watcher for autonomous ticket execution`,
+      projectSlug,
+      type: "yolo_start"
+    },
+    {
+      name: `tickets_yolo_stop`,
+      description: `Stop the YOLO ticket watcher for "${projectSlug}"`,
+      slashDescription: `Stop the YOLO watcher daemon`,
+      projectSlug,
+      type: "yolo_stop"
     },
     {
-      name: "system_prompts",
+      name: `tickets_yolo_status`,
+      description: `Get YOLO watcher status for "${projectSlug}"`,
+      slashDescription: `Check YOLO watcher status and metrics`,
+      projectSlug,
+      type: "yolo_status"
+    }
+  ];
+  console.error(`[MCP] Registering ${dynamicTicketTools.length} ticket tools...`);
+  const globalPromptTools = [
+    {
+      name: "prompts_run",
+      description: "Execute a prompt by slug. Use prompts_list to list available prompts.",
+      slashDescription: "Execute a prompt by slug. Use prompts_list to list available prompts."
+    },
+    {
+      name: "prompts_list",
       description: "List all available prompts",
       slashDescription: "List all available prompts"
     },
     {
-      name: "system_prompts_update",
+      name: "prompts_update",
       description: "Read or update a prompt. Without content: returns prompt with context and editing guidance. With content: saves new version.",
       slashDescription: "Read or update a prompt by slug"
     }
   ];
-  console.error(`[MCP] Registering ${globalSystemTools.length} global system tools...`);
+  console.error(`[MCP] Registering ${globalPromptTools.length} global prompt tools...`);
   const dynamicPromptTools = [];
   for (const prompt of accountScopedPrompts) {
     const folderPrefix = prompt.folderSlug ? `[${prompt.folderSlug}] ` : "";
@@ -295,16 +489,16 @@ async function startServer(config, convexClientRaw) {
       name: tt.name,
       description: tt.slashDescription
     }));
-    const systemPromptsSchemas = globalSystemTools.map((st) => ({
+    const promptToolSchemas = globalPromptTools.map((st) => ({
       name: st.name,
       description: st.slashDescription
     }));
     return {
       prompts: [
-        ...systemPromptsSchemas,
-        // system_prompts, system_run_prompt (global)
+        ...promptToolSchemas,
+        // prompts_run, prompts_list, prompts_update (global)
         ...ticketPromptSchemas
-        // project_tickets_* (project-scoped)
+        // tickets_* (token-scoped)
       ]
     };
   });
@@ -326,26 +520,25 @@ async function startServer(config, convexClientRaw) {
       };
     }
     const ticketTool = dynamicTicketTools.find((tt) => tt.name === promptName);
-    const ticketWorkMatch = promptName.match(/^(.+)_tickets_work\s+(.+)$/);
+    const ticketWorkMatch = promptName.match(/^tickets_work\s+(.+)$/);
     if (ticketTool || ticketWorkMatch) {
       let promptContent;
       let description;
       if (ticketWorkMatch) {
-        const projectSlug = ticketWorkMatch[1];
-        const ticketArg = ticketWorkMatch[2].trim();
+        const ticketArg = ticketWorkMatch[1].trim();
         description = `Work on ticket "${ticketArg}" from "${projectSlug}"`;
         promptContent = `Get work on ticket "${ticketArg}" from the "${projectSlug}" project.
 
-Call the \`${projectSlug}_tickets_work\` tool with ticketSlug: "${ticketArg}".
+Call the \`tickets_work\` tool with ticketSlug: "${ticketArg}".
 
 This will open the ticket if it's in the open queue, or resume it if already working.`;
       } else if (ticketTool.type === "work") {
         description = ticketTool.description;
         promptContent = `Get work from the "${ticketTool.projectSlug}" project.
 
-Call the \`${ticketTool.name}\` tool to get the next ticket from the open queue.
+Call the \`tickets_work\` tool to get the next ticket from the open queue.
 
-You can also specify a ticket: /ppm:${ticketTool.projectSlug}_tickets_work <number-or-slug>
+You can also specify a ticket: /ppm:tickets_work <number-or-slug>
 
 This unified command handles both opening new tickets and resuming in-progress work.`;
       } else if (ticketTool.type === "create") {
@@ -397,7 +590,7 @@ Call the \`${ticketTool.name}\` tool with the ticket number or slug.`;
         ]
       };
     }
-    if (promptName === "system_prompts") {
+    if (promptName === "prompts_list") {
       return {
         description: "List all available prompts",
         messages: [
@@ -407,14 +600,14 @@ Call the \`${ticketTool.name}\` tool with the ticket number or slug.`;
               type: "text",
               text: `List all available prompts.
 
-Call the \`system_prompts\` tool with optional \`search\` parameter to filter results.`
+Call the \`prompts_list\` tool with optional \`search\` parameter to filter results.`
             }
           }
         ]
       };
     }
-    const runPromptMatch = promptName.match(/^system_run_prompt\s+(.+)$/);
-    if (promptName === "system_run_prompt" || runPromptMatch) {
+    const runPromptMatch = promptName.match(/^prompts_run\s+(.+)$/);
+    if (promptName === "prompts_run" || runPromptMatch) {
       let promptContent;
       let description;
       if (runPromptMatch) {
@@ -422,19 +615,19 @@ Call the \`system_prompts\` tool with optional \`search\` parameter to filter re
         description = `Execute prompt "${promptSlug}"`;
         promptContent = `Execute the "${promptSlug}" prompt.
 
-Call the \`system_run_prompt\` tool with slug: "${promptSlug}".`;
+Call the \`prompts_run\` tool with slug: "${promptSlug}".`;
       } else {
         description = "Execute a prompt by slug";
         promptContent = `Execute a prompt by slug.
 
 ## Usage
-Call the \`system_run_prompt\` tool with the prompt slug.
+Call the \`prompts_run\` tool with the prompt slug.
 
 ## Available Prompts
-Use \`system_prompts\` to list all available prompts.
+Use \`prompts_list\` to list all available prompts.
 
 ## Example
-/ppm:system_run_prompt code-review
+/ppm:prompts_run code-review
 
 This will execute the "code-review" prompt.`;
       }
@@ -451,7 +644,7 @@ This will execute the "code-review" prompt.`;
         ]
       };
     }
-    throw new Error(`Unknown prompt: ${promptName}. Use system_run_prompt to execute prompts.`);
+    throw new Error(`Unknown prompt: ${promptName}. Use prompts_run to execute prompts.`);
   });
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     const tools = [
@@ -545,6 +738,45 @@ This will execute the "code-review" prompt.`;
             },
             required: ["ticketSlug", "content"]
           };
+        } else if (tt.type === "yolo_start") {
+          inputSchema = {
+            type: "object",
+            properties: {
+              pollIntervalMs: {
+                type: "number",
+                description: "Milliseconds between polls (default: 30000 = 30s)"
+              },
+              maxParallel: {
+                type: "number",
+                description: "Maximum concurrent ticket executions (default: 1)"
+              },
+              ticketTimeout: {
+                type: "number",
+                description: "Timeout for ticket execution in ms (default: 1800000 = 30 min)"
+              },
+              enableNotifications: {
+                type: "boolean",
+                description: "Show macOS notifications (default: true)"
+              },
+              workingDirectory: {
+                type: "string",
+                description: "Working directory for Claude Code sessions (default: current working directory)"
+              }
+            },
+            required: []
+          };
+        } else if (tt.type === "yolo_stop") {
+          inputSchema = {
+            type: "object",
+            properties: {},
+            required: []
+          };
+        } else if (tt.type === "yolo_status") {
+          inputSchema = {
+            type: "object",
+            properties: {},
+            required: []
+          };
         } else {
           inputSchema = {
             type: "object",
@@ -558,10 +790,10 @@ This will execute the "code-review" prompt.`;
           inputSchema
         };
       }),
-      // Global system_run_prompt tool
+      // Global prompts_run tool
       {
-        name: "system_run_prompt",
-        description: "Execute a prompt by slug. Use system_prompts to list available prompts.",
+        name: "prompts_run",
+        description: "Execute a prompt by slug. Use prompts_list to list available prompts.",
         inputSchema: {
           type: "object",
           properties: {
@@ -573,9 +805,9 @@ This will execute the "code-review" prompt.`;
           required: ["slug"]
         }
       },
-      // Global system_prompts tool
+      // Global prompts_list tool
       {
-        name: "system_prompts",
+        name: "prompts_list",
         description: "List all available prompts",
         inputSchema: {
           type: "object",
@@ -587,9 +819,9 @@ This will execute the "code-review" prompt.`;
           }
         }
       },
-      // Global system_prompts_update tool (CLI-based prompt editing)
+      // Global prompts_update tool (CLI-based prompt editing)
       {
-        name: "system_prompts_update",
+        name: "prompts_update",
         description: "Read or update a prompt. Without content: returns prompt with context and editing guidance. With content: saves new version.",
         inputSchema: {
           type: "object",
@@ -625,8 +857,8 @@ This will execute the "code-review" prompt.`;
   });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const toolName = request.params.name;
-    if (toolName === "system_run_prompt") {
-      const parsedArgs = parseRunPromptArgs(request.params.arguments);
+    if (toolName === "prompts_run") {
+      const parsedArgs = parsePromptsRunArgs(request.params.arguments);
       if (!parsedArgs) {
         return {
           content: [
@@ -634,7 +866,7 @@ This will execute the "code-review" prompt.`;
               type: "text",
               text: `Error: Missing 'slug' parameter. Provide prompt slug (e.g., 'code-review', 'plan').
 
-Use \`system_prompts\` to list available prompts.`
+Use \`prompts_list\` to list available prompts.`
             }
           ],
           isError: true
@@ -668,7 +900,7 @@ Use \`system_prompts\` to list available prompts.`
 
 ${suggestionsList}
 
-Example: \`system_run_prompt ${error.suggestions[0]}\``
+Example: \`prompts_run ${error.suggestions[0]}\``
               }
             ],
             isError: true
@@ -687,8 +919,8 @@ Example: \`system_run_prompt ${error.suggestions[0]}\``
         };
       }
     }
-    if (toolName === "system_prompts") {
-      const { search: searchTerm } = parseSystemPromptsArgs(request.params.arguments);
+    if (toolName === "prompts_list") {
+      const { search: searchTerm } = parsePromptsListArgs(request.params.arguments);
       let filteredPrompts = [...accountScopedPrompts];
       if (searchTerm) {
         const lowerSearch = searchTerm.toLowerCase();
@@ -716,8 +948,8 @@ No prompts found.`
         ]
       };
     }
-    if (toolName === "system_prompts_update") {
-      const parsedArgs = parseSystemPromptsUpdateArgs(request.params.arguments);
+    if (toolName === "prompts_update") {
+      const parsedArgs = parsePromptsUpdateArgs(request.params.arguments);
       if (!parsedArgs) {
         return {
           content: [
@@ -726,8 +958,8 @@ No prompts found.`
               text: `Error: Missing 'slug' parameter. Provide prompt slug to read or update.
 
 Usage:
-- Read mode: system_prompts_update { slug: "my-prompt" }
-- Write mode: system_prompts_update { slug: "my-prompt", content: "new content..." }`
+- Read mode: prompts_update { slug: "my-prompt" }
+- Write mode: prompts_update { slug: "my-prompt", content: "new content..." }`
             }
           ],
           isError: true
@@ -797,7 +1029,7 @@ ${JSON.stringify(readResult.context, null, 2)}
 ${readResult.editingGuidance}
 
 ---
-_To update this prompt, call system_prompts_update with content parameter._`
+_To update this prompt, call prompts_update with content parameter._`
               }
             ]
           };
@@ -823,7 +1055,7 @@ Updated: ${writeResult.updatedAt}`
         };
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        console.error(`[MCP] system_prompts_update error:`, error);
+        console.error(`[MCP] prompts_update error:`, error);
         return {
           content: [
             {
@@ -1274,6 +1506,132 @@ _Ticket content has been appended with your update._`
             isError: true
           };
         }
+      } else if (ticketTool.type === "yolo_start") {
+        const args = parseWatcherStartArgs(request.params.arguments);
+        const workingDirectory = args.workingDirectory ?? process.cwd();
+        try {
+          const result = await startWatcher(
+            {
+              projectSlug: ticketTool.projectSlug,
+              projectToken: config.projectToken,
+              convexUrl: config.convexUrl,
+              workingDirectory
+            },
+            args
+          );
+          if (result.success) {
+            const statusLines = [
+              result.alreadyRunning ? `\u2139\uFE0F Watcher is already running (PID: ${result.pid})` : `\u2705 Watcher started (PID: ${result.pid})`
+            ];
+            if (result.config) {
+              statusLines.push("");
+              statusLines.push("**Configuration:**");
+              statusLines.push(`  Poll Interval: ${result.config.pollIntervalMs / 1e3}s`);
+              statusLines.push(`  Max Parallel: ${result.config.maxParallel}`);
+              statusLines.push(`  Ticket Timeout: ${result.config.ticketTimeout / 1e3 / 60} min`);
+              statusLines.push(`  Notifications: ${result.config.enableNotifications ? "enabled" : "disabled"}`);
+              statusLines.push(`  Working Directory: ${result.config.workingDirectory}`);
+            }
+            statusLines.push("");
+            statusLines.push("_The watcher will poll for open tickets with the YOLO flag and spawn Claude Code terminals to execute them._");
+            statusLines.push("_Use `tickets_yolo_status` to check progress, `tickets_yolo_stop` to stop._");
+            return {
+              content: [{ type: "text", text: statusLines.join("\n") }]
+            };
+          } else {
+            return {
+              content: [{ type: "text", text: `\u274C ${result.message}` }],
+              isError: true
+            };
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          console.error(`[MCP] tickets_yolo_start error:`, error);
+          return {
+            content: [{ type: "text", text: `Error starting watcher: ${errorMessage}` }],
+            isError: true
+          };
+        }
+      } else if (ticketTool.type === "yolo_stop") {
+        const workingDirectory = process.cwd();
+        try {
+          const result = await stopWatcher(workingDirectory);
+          if (result.success) {
+            return {
+              content: [{
+                type: "text",
+                text: result.wasRunning ? `\u2705 Watcher stopped successfully` : `\u2139\uFE0F ${result.message}`
+              }]
+            };
+          } else {
+            return {
+              content: [{ type: "text", text: `\u274C ${result.message}` }],
+              isError: true
+            };
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          console.error(`[MCP] tickets_yolo_stop error:`, error);
+          return {
+            content: [{ type: "text", text: `Error stopping watcher: ${errorMessage}` }],
+            isError: true
+          };
+        }
+      } else if (ticketTool.type === "yolo_status") {
+        const workingDirectory = process.cwd();
+        try {
+          const result = getWatcherStatus(workingDirectory);
+          if (!result.status) {
+            return {
+              content: [{ type: "text", text: `\u2139\uFE0F ${result.message ?? "No watcher status available"}` }]
+            };
+          }
+          const status = result.status;
+          const lines = [
+            `# YOLO Watcher Status: ${status.projectSlug}`,
+            "",
+            `**State:** ${status.state.toUpperCase()}`
+          ];
+          if (status.pid) {
+            lines.push(`**PID:** ${status.pid}`);
+          }
+          if (status.startedAt) {
+            lines.push(`**Started:** ${status.startedAt}`);
+          }
+          if (status.lastPollAt) {
+            lines.push(`**Last Poll:** ${status.lastPollAt}`);
+          }
+          lines.push(`**Tickets Processed:** ${status.ticketsProcessed}`);
+          if (status.currentlyExecuting && status.currentlyExecuting.length > 0) {
+            lines.push("");
+            lines.push("**Currently Executing:**");
+            for (const exec of status.currentlyExecuting) {
+              const displayName = exec.ticketNumber ? `#${exec.ticketNumber} ${exec.ticketSlug}` : exec.ticketSlug;
+              lines.push(`  \u2022 ${displayName} (started: ${exec.startedAt})`);
+            }
+          }
+          if (status.lastError) {
+            lines.push("");
+            lines.push(`**Last Error:** ${status.lastError}`);
+          }
+          if (status.config) {
+            lines.push("");
+            lines.push("**Configuration:**");
+            lines.push(`  Poll Interval: ${status.config.pollIntervalMs / 1e3}s`);
+            lines.push(`  Max Parallel: ${status.config.maxParallel}`);
+            lines.push(`  Working Directory: ${status.config.workingDirectory}`);
+          }
+          return {
+            content: [{ type: "text", text: lines.join("\n") }]
+          };
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          console.error(`[MCP] tickets_yolo_status error:`, error);
+          return {
+            content: [{ type: "text", text: `Error getting watcher status: ${errorMessage}` }],
+            isError: true
+          };
+        }
       }
     }
     const promptTool = dynamicPromptTools.find((pt) => pt.name === toolName);
@@ -1297,7 +1655,7 @@ _Ticket content has been appended with your update._`
         };
       }
     }
-    throw new Error(`Unknown tool: ${toolName}. Use system_run_prompt to execute prompts by name, or check available tools.`);
+    throw new Error(`Unknown tool: ${toolName}. Use prompts_run to execute prompts by name, or check available tools.`);
   });
   const transport = new StdioServerTransport();
   await server.connect(transport);