@promptprojectmanager/mcp-server 4.9.4 → 4.9.6

package/dist/index.js

@@ -22,6 +22,313 @@ import {
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 
+// src/auth/agent-resolver.ts
+function buildAuthArgs(config) {
+  return { projectToken: config.projectToken };
+}
+function resolveAgent(paramAgent) {
+  if (paramAgent) return paramAgent;
+  const envAgent = process.env.PPM_AGENT_NAME;
+  if (envAgent) return envAgent;
+  return void 0;
+}
+
+// src/auth/token-validator.ts
+async function validateProjectToken(client, token) {
+  try {
+    const typedClient = client;
+    const result = await typedClient.query(
+      "projects:validateProjectToken",
+      { token }
+    );
+    if (result && result.valid) {
+      return {
+        valid: true,
+        projectId: result.projectId,
+        projectSlug: result.projectSlug,
+        ownerId: result.ownerId
+      };
+    }
+    return { valid: false, error: "Invalid project token" };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+
+// src/tools/registry.ts
+function getTicketToolDefinitions(projectSlug) {
+  return [
+    {
+      name: "tickets_work",
+      type: "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.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          ticketSlug: {
+            type: "string",
+            description: "Optional: Ticket number (e.g., '102') or full slug. If not provided, gets next ticket from open queue."
+          },
+          agent: {
+            type: "string",
+            description: "Optional: Agent slug to filter queue. Overrides PPM_AGENT_NAME env var. Omit for owner mode (no filtering)."
+          }
+        },
+        required: []
+      }
+    },
+    {
+      name: "tickets_close",
+      type: "close",
+      description: `Mark a working ticket as completed in the "${projectSlug}" project. If a hook is configured, first call returns instructions - then call again with metadata.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          ticketSlug: {
+            type: "string",
+            description: "Ticket number (e.g., '102') or full slug (e.g., '102-fix-auth')"
+          },
+          metadata: {
+            type: "object",
+            description: "Optional: Key-value metadata to store with the closed ticket (e.g., evaluation scores, completion notes).",
+            additionalProperties: {
+              oneOf: [{ type: "string" }, { type: "number" }, { type: "boolean" }]
+            }
+          }
+        },
+        required: ["ticketSlug"]
+      }
+    },
+    {
+      name: "tickets_pause",
+      type: "pause",
+      description: `Pause a working ticket and return to queue. Before calling, review the full session context and generate comprehensive checkpoint content that enables seamless handoff to another agent. Include: completed tasks with specifics, key decisions and rationale, sticking points and resolutions, user preferences discovered, remaining work with file:line references, and open questions.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          ticketSlug: {
+            type: "string",
+            description: "Ticket number (e.g., '102') or full slug (e.g., '102-fix-auth')"
+          },
+          content: {
+            type: "string",
+            description: "Comprehensive checkpoint for handoff. Review the session and include: ## Progress (completed tasks with specifics, decisions made and why) ## Context (user preferences, edge cases discovered, key feedback received) ## Remaining (specific next steps, file:line references if applicable) ## Blockers (unresolved issues, open questions). This enables the next agent to continue seamlessly."
+          }
+        },
+        required: ["ticketSlug", "content"]
+      }
+    },
+    {
+      name: "tickets_create",
+      type: "create",
+      description: `Create a new ticket in the "${projectSlug}" project queue`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          content: {
+            type: "string",
+            description: "The generated ticket content. First line should be a clear descriptive title (becomes the slug). Body contains tasks, description, context as needed."
+          },
+          agent: {
+            type: "string",
+            description: "Optional: Agent slug to assign ticket to. Overrides PPM_AGENT_NAME env var. Omit for unassigned."
+          }
+        },
+        required: ["content"]
+      }
+    },
+    {
+      name: "tickets_search",
+      type: "search",
+      description: `Search for tickets by content in the "${projectSlug}" project`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query (min 3 characters)"
+          },
+          agent: {
+            type: "string",
+            description: "Optional: Agent slug to filter results. Overrides PPM_AGENT_NAME env var. Omit for all tickets."
+          }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "tickets_get",
+      type: "get",
+      description: `Get a specific ticket by number or slug from "${projectSlug}" (read-only)`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          ticketSlug: {
+            type: "string",
+            description: "Ticket number (e.g., '102') or full slug"
+          }
+        },
+        required: ["ticketSlug"]
+      }
+    },
+    {
+      name: "tickets_list",
+      type: "list",
+      description: `List active tickets in the "${projectSlug}" project (backlog + open + working)`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          agent: {
+            type: "string",
+            description: "Optional: Agent slug to filter tickets. Overrides PPM_AGENT_NAME env var. Omit for all tickets."
+          }
+        },
+        required: []
+      }
+    },
+    {
+      name: "tickets_update",
+      type: "update",
+      description: `Update a ticket in the "${projectSlug}" project by appending content with timestamp`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          ticketSlug: {
+            type: "string",
+            description: "Ticket number (e.g., '102') or full slug (e.g., '102-fix-auth')"
+          },
+          content: {
+            type: "string",
+            description: "Update content to append to the ticket (markdown supported)"
+          },
+          agent: {
+            type: "string",
+            description: "Optional: Reassign ticket to this agent. Use empty string '' to unassign."
+          }
+        },
+        required: ["ticketSlug", "content"]
+      }
+    }
+  ];
+}
+function getMemoryToolDefinitions() {
+  return [
+    {
+      name: "memories_load",
+      type: "load",
+      description: `Load project memories: returns all rules (always) + relevant history (by query or recent). Use [MEMORY_LOAD] in prompts for automatic loading.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Optional: search query to filter agent memories. If not provided, returns recent memories."
+          }
+        },
+        required: []
+      }
+    },
+    {
+      name: "memories_load_extreme",
+      type: "load_extreme",
+      description: `Load project memories with FULL ticket context. Returns all matching memories, and for each memory linked to a ticket, includes the complete ticket content (tasks, updates, decisions). Use when you need deep historical context about past work.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Optional: search query to filter agent memories. If not provided, returns recent memories."
+          }
+        },
+        required: []
+      }
+    },
+    {
+      name: "memories_add",
+      type: "add",
+      description: `Record a project memory. Optionally links to working ticket if exactly one exists. Use for key decisions, patterns discovered, or important context.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          content: {
+            type: "string",
+            description: "Memory content to record. Be concise and focused on key decisions, patterns, or context."
+          }
+        },
+        required: ["content"]
+      }
+    },
+    {
+      name: "memories_list_all",
+      type: "list_all",
+      description: `List ALL project memories (rules and agent history). Returns complete memory list with IDs for review/cleanup. Use for memory audits or before bulk operations.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          typeFilter: {
+            type: "string",
+            enum: ["all", "user", "agent"],
+            description: "Optional: Filter by memory type. 'user' = rules, 'agent' = history. Default: 'all'"
+          }
+        },
+        required: []
+      }
+    }
+  ];
+}
+function getPromptToolDefinitions() {
+  return [
+    {
+      name: "prompts_run",
+      description: "Execute a prompt by slug. Use prompts_list to list available prompts.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          slug: {
+            type: "string",
+            description: "Prompt slug to execute (e.g., 'code-review', 'plan')"
+          }
+        },
+        required: ["slug"]
+      }
+    },
+    {
+      name: "prompts_list",
+      description: "List all available prompts",
+      inputSchema: {
+        type: "object",
+        properties: {
+          search: {
+            type: "string",
+            description: "Optional search term to filter prompts by name or description (case-insensitive)"
+          }
+        }
+      }
+    },
+    {
+      name: "prompts_update",
+      description: "Read or update a prompt, snippet, or template. Without content: returns resource with context. With content: saves new version.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          slug: {
+            type: "string",
+            description: "Resource slug to read or update. Searches prompts first, then snippets, then templates. Supports fuzzy matching."
+          },
+          content: {
+            type: "string",
+            description: "New resource content (omit for read-only mode)"
+          }
+        },
+        required: ["slug"]
+      }
+    }
+  ];
+}
+
 // src/types.ts
 function isAccessDenied(result) {
   return typeof result === "object" && result !== null && "accessDenied" in result && result.accessDenied === true;
@@ -205,1636 +512,1176 @@ async function fetchAndExecuteAccountScopedPrompt(promptSlug, config, convexClie
   };
 }
 
-// src/server.ts
-function buildAuthArgs(config) {
-  return { projectToken: config.projectToken };
-}
-function resolveAgent(paramAgent) {
-  if (paramAgent) return paramAgent;
-  const envAgent = process.env.PPM_AGENT_NAME;
-  if (envAgent) return envAgent;
-  return void 0;
-}
-var SYSTEM_TOOLS = [
-  // All tools are now project-scoped (see dynamic*Tools arrays below)
-];
-async function startServer(config, convexClientRaw) {
-  const convexClient = convexClientRaw;
-  console.error("[MCP] Validating project token...");
-  const validation = await validateProjectToken(convexClient, config.projectToken);
-  if (!validation.valid) {
-    throw new Error(`Invalid project token: ${validation.error}`);
-  }
-  const tokenProjectSlug = validation.projectSlug;
-  console.error(`[MCP] Project token validated for project "${tokenProjectSlug}"`);
-  console.error("[MCP] Fetching prompt metadata...");
-  const accountScopedPrompts = await fetchAccountScopedPromptMetadataByToken(
-    convexClient,
-    config.projectToken
-  );
-  console.error(`[MCP] Project token mode: loaded ${accountScopedPrompts.length} prompts`);
-  console.error(`[MCP] Found ${accountScopedPrompts.length} account-scoped prompts (global tools)`);
-  console.error(`[MCP] Ticket project scope: ${tokenProjectSlug} (token-scoped)`);
-  if (accountScopedPrompts.length === 0) {
-    console.error(
-      "[MCP] WARNING: No prompts found. Create prompts in the 'prompts' section to expose them via MCP."
-    );
-  }
-  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"
-    },
-    {
-      name: `tickets_close`,
-      description: `Mark a working ticket as completed in the "${projectSlug}" project. If a hook is configured, first call returns instructions - then call again with metadata.`,
-      slashDescription: `Mark a working ticket as completed`,
-      projectSlug,
-      type: "close"
-    },
-    {
-      name: `tickets_pause`,
-      description: `Pause a working ticket and return to queue. Before calling, review the full session context and generate comprehensive checkpoint content that enables seamless handoff to another agent. Include: completed tasks with specifics, key decisions and rationale, sticking points and resolutions, user preferences discovered, remaining work with file:line references, and open questions.`,
-      slashDescription: `Pause working ticket with checkpoint content (working \u2192 open)`,
-      projectSlug,
-      type: "pause"
-    },
-    {
-      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"
-    },
-    {
-      name: `tickets_search`,
-      description: `Search for tickets by content in the "${projectSlug}" project`,
-      slashDescription: `Search for tickets by content`,
-      projectSlug,
-      type: "search"
-    },
-    {
-      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"
-    },
-    {
-      name: `tickets_list`,
-      description: `List active tickets in the "${projectSlug}" project (backlog + open + working)`,
-      slashDescription: `List active tickets (backlog + open + working)`,
-      projectSlug,
-      type: "list"
-    },
-    {
-      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...`);
-  const dynamicMemoryTools = [
-    {
-      name: `memories_load`,
-      description: `Load project memories: returns all rules (always) + relevant history (by query or recent). Use [MEMORY_LOAD] in prompts for automatic loading.`,
-      slashDescription: `Load project memories (rules + history)`,
-      projectSlug,
-      type: "load"
-    },
-    {
-      name: `memories_load_extreme`,
-      description: `Load project memories with FULL ticket context. Returns all matching memories, and for each memory linked to a ticket, includes the complete ticket content (tasks, updates, decisions). Use when you need deep historical context about past work.`,
-      slashDescription: `Load memories with full ticket context`,
-      projectSlug,
-      type: "load_extreme"
-    },
-    {
-      name: `memories_add`,
-      description: `Record a project memory. Optionally links to working ticket if exactly one exists. Use for key decisions, patterns discovered, or important context.`,
-      slashDescription: `Add memory to project (auto-links to working ticket if one exists)`,
-      projectSlug,
-      type: "add"
-    },
-    {
-      name: `memories_list_all`,
-      description: `List ALL project memories (rules and agent history). Returns complete memory list with IDs for review/cleanup. Use for memory audits or before bulk operations.`,
-      slashDescription: `List all memories with IDs for review`,
-      projectSlug,
-      type: "list_all"
-    }
-  ];
-  console.error(`[MCP] Registering ${dynamicMemoryTools.length} memory 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: "prompts_update",
-      description: "Read or update a prompt, snippet, or template. Without content: returns resource with context. With content: saves new version.",
-      slashDescription: "Read or update a prompt, snippet, or template by slug"
-    }
-  ];
-  console.error(`[MCP] Registering ${globalPromptTools.length} global prompt tools...`);
-  const dynamicPromptTools = [];
-  for (const prompt of accountScopedPrompts) {
-    const folderPrefix = prompt.folderPath ? `[${prompt.folderPath}] ` : "";
-    const baseDescription = prompt.description || `Execute the "${prompt.slug}" prompt`;
-    dynamicPromptTools.push({
-      name: prompt.slug,
-      // Global tool name, no project prefix
-      description: folderPrefix + baseDescription,
-      promptSlug: prompt.slug
-    });
+// src/handlers/prompts.ts
+async function handlePromptsRun(args, config, convexClient) {
+  const parsedArgs = parsePromptsRunArgs(args);
+  if (!parsedArgs) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: Missing 'slug' parameter. Provide prompt slug (e.g., 'code-review', 'plan').
+
+Use \`prompts_list\` to list available prompts.`
+        }
+      ],
+      isError: true
+    };
   }
-  console.error(`[MCP] Registering ${dynamicPromptTools.length} per-prompt tools (global)...`);
-  const promptNames = /* @__PURE__ */ new Set();
-  const duplicates = [];
-  accountScopedPrompts.forEach((p) => {
-    if (promptNames.has(p.slug)) {
-      duplicates.push(p.slug);
-    }
-    promptNames.add(p.slug);
-  });
-  if (duplicates.length > 0) {
-    console.error(
-      `[MCP] WARNING: Duplicate prompt slugs detected: ${duplicates.join(", ")}. Only the first occurrence will be registered.`
+  const { slug: promptSlug } = parsedArgs;
+  try {
+    const result = await fetchAndExecuteAccountScopedPrompt(
+      promptSlug,
+      config,
+      convexClient
     );
-  }
-  const server = new Server(
-    {
-      name: "ppm-mcp-server",
-      version: "3.1.0"
-    },
-    {
-      capabilities: {
-        prompts: {},
-        tools: {}
-      }
-    }
-  );
-  server.setRequestHandler(ListPromptsRequestSchema, async () => {
-    const ticketPromptSchemas = dynamicTicketTools.map((tt) => ({
-      name: tt.name,
-      description: tt.slashDescription
-    }));
-    const memoryPromptSchemas = dynamicMemoryTools.map((mt) => ({
-      name: mt.name,
-      description: mt.slashDescription
-    }));
-    const promptToolSchemas = globalPromptTools.map((st) => ({
-      name: st.name,
-      description: st.slashDescription
-    }));
+    const promptText = result.messages.map((msg) => msg.content.text).join("\n\n");
     return {
-      prompts: [
-        ...promptToolSchemas,
-        // prompts_run, prompts_list, prompts_update (global)
-        ...ticketPromptSchemas,
-        // tickets_* (token-scoped)
-        ...memoryPromptSchemas
-        // memories_* (token-scoped)
+      content: [
+        {
+          type: "text",
+          text: promptText
+        }
       ]
     };
-  });
-  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    const promptName = request.params.name;
-    const systemTool = SYSTEM_TOOLS.find((st) => st.name === promptName);
-    if (systemTool) {
+  } catch (error) {
+    if (error instanceof AmbiguousPromptError) {
+      const suggestionsList = error.suggestions.map((s) => `  \u2022 ${s}`).join("\n");
+      console.error(`[MCP] prompts_run ambiguous match:`, error.suggestions);
       return {
-        description: systemTool.description,
-        messages: [
+        content: [
           {
-            role: "user",
-            content: {
-              type: "text",
-              text: systemTool.promptContent
-            }
+            type: "text",
+            text: `Multiple prompts match "${promptSlug}". Please specify one of:
+
+${suggestionsList}
+
+Example: \`prompts_run ${error.suggestions[0]}\``
           }
-        ]
+        ],
+        isError: true
       };
     }
-    const ticketTool = dynamicTicketTools.find((tt) => tt.name === promptName);
-    const ticketWorkMatch = promptName.match(/^tickets_work\s+(.+)$/);
-    if (ticketTool || ticketWorkMatch) {
-      let promptContent;
-      let description;
-      if (ticketWorkMatch) {
-        const ticketArg = ticketWorkMatch[1].trim();
-        description = `Work on ticket "${ticketArg}" from "${projectSlug}"`;
-        promptContent = `Get work on ticket "${ticketArg}" from the "${projectSlug}" project.
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] prompts_run error:`, error);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error executing prompt "${promptSlug}": ${errorMessage}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function handlePromptsList(args, _config, _convexClient, accountScopedPrompts) {
+  const { search: searchTerm } = parsePromptsListArgs(args);
+  let filteredPrompts = [...accountScopedPrompts];
+  if (searchTerm) {
+    const lowerSearch = searchTerm.toLowerCase();
+    filteredPrompts = filteredPrompts.filter(
+      (p) => p.slug.toLowerCase().includes(lowerSearch) || p.description?.toLowerCase().includes(lowerSearch)
+    );
+  }
+  filteredPrompts.sort((a, b) => a.slug.localeCompare(b.slug));
+  const userPromptList = filteredPrompts.map((p) => {
+    const desc = p.description || "No description";
+    return `\u2022 ${p.slug}
+  Description: ${desc}`;
+  }).join("\n\n");
+  const summary = searchTerm ? `Found ${filteredPrompts.length} prompt(s) matching "${searchTerm}":` : `Available prompts (${filteredPrompts.length} total):`;
+  return {
+    content: [
+      {
+        type: "text",
+        text: userPromptList ? `${summary}
 
-Call the \`tickets_work\` tool with ticketSlug: "${ticketArg}".
+${userPromptList}` : `${summary}
 
-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.
+No prompts found.`
+      }
+    ]
+  };
+}
+async function handlePromptsUpdate(args, config, convexClient) {
+  const parsedArgs = parsePromptsUpdateArgs(args);
+  if (!parsedArgs) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: Missing 'slug' parameter. Provide prompt slug to read or update.
 
-Call the \`tickets_work\` tool to get the next ticket from the open queue.
+Usage:
+- Read mode: prompts_update { slug: "my-prompt" }
+- Write mode: prompts_update { slug: "my-prompt", content: "new content..." }`
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const typedClient = convexClient;
+    const result = await typedClient.mutation(
+      "mcp_prompts:updateMcpPrompt",
+      {
+        ...buildAuthArgs(config),
+        promptSlug: parsedArgs.slug,
+        content: parsedArgs.content
+      }
+    );
+    if (!result.success) {
+      const errorResult = result;
+      if (errorResult.suggestions) {
+        const suggestionsList = errorResult.suggestions.map((s) => `  \u2022 ${s}`).join("\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${errorResult.error}
 
-You can also specify a ticket: /ppm:tickets_work <number-or-slug>
+Did you mean one of these?
+${suggestionsList}`
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: errorResult.error }],
+        isError: true
+      };
+    }
+    if (result.mode === "read") {
+      const readResult = result;
+      const matchNote = readResult.matchType !== "exact" ? `
+_Note: Matched via ${readResult.matchType} match_` : "";
+      const aiTagNotice = readResult.hasAiTags ? `
 
-This unified command handles both opening new tickets and resuming in-progress work.`;
-      } else if (ticketTool.type === "create") {
-        description = ticketTool.description;
-        promptContent = `Create a new ticket in the "${ticketTool.projectSlug}" project queue.
+## \u26A1 AI Tags Detected
+This ${readResult.resourceType} contains AI tags that need processing: **${readResult.aiTags?.join(", ")}**
 
-## How This Works
-The user provides **instructions** (not raw content). You interpret those instructions to generate the ticket.
+Process these tags by reading the instructions in each tag, generating appropriate content, and saving the result with the content parameter.` : "";
+      const versionInfo = readResult.version !== void 0 ? ` (v${readResult.version})` : "";
+      const resourceLabel = readResult.resourceType.charAt(0).toUpperCase() + readResult.resourceType.slice(1);
+      const contextSection = readResult.context ? `
 
-## Instructions
-1. **Read the user's request** - they may reference a file, ask you to summarize a session, or describe what they want
-2. **Process the input** - read files, extract relevant sections, summarize as needed
-3. **Generate ticket content** with a clear, descriptive title as the first line
-4. **Call the tool** with the generated content
+## Available Resources
+\`\`\`json
+${JSON.stringify(readResult.context, null, 2)}
+\`\`\`` : "";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `# ${resourceLabel}: ${readResult.slug}${versionInfo}${matchNote}${aiTagNotice}
 
-## Content Format
-\`\`\`
-[Clear descriptive title - this becomes the slug]
+## Description
+${readResult.description || "No description"}
 
-[Body content - tasks, description, context, etc.]
+## Content
 \`\`\`
+${readResult.content}
+\`\`\`${contextSection}
 
-## Examples
-- "create a ticket from /path/to/plan.md" \u2192 Read file, use as ticket content
-- "summarize our brainstorm into a ticket" \u2192 Extract key points from conversation
-- "create a ticket for the auth bug we discussed" \u2192 Generate from session context
-- "just the tasks from this file" \u2192 Extract only task items
-
-Call the \`${ticketTool.name}\` tool with the final generated content.`;
-      } else if (ticketTool.type === "close") {
-        description = ticketTool.description;
-        promptContent = `Close a working ticket in the "${ticketTool.projectSlug}" project.
+${readResult.editingGuidance}
 
-Call the \`${ticketTool.name}\` tool with the ticket number or slug.`;
-      } else {
-        description = ticketTool.description;
-        promptContent = `Use the \`${ticketTool.name}\` tool.`;
-      }
-      return {
-        description,
-        messages: [
-          {
-            role: "user",
-            content: {
-              type: "text",
-              text: promptContent
-            }
+---
+_To update this ${readResult.resourceType}, call prompts_update with content parameter._`
           }
         ]
       };
     }
-    if (promptName === "prompts_list") {
+    if (result.mode === "write") {
+      const writeResult = result;
+      const resourceLabel = writeResult.resourceType.charAt(0).toUpperCase() + writeResult.resourceType.slice(1);
+      const versionInfo = writeResult.version !== void 0 ? `
+Version: ${writeResult.version}` : "";
+      const updatedInfo = writeResult.updatedAt ? `
+Updated: ${writeResult.updatedAt}` : "";
       return {
-        description: "List all available prompts",
-        messages: [
+        content: [
           {
-            role: "user",
-            content: {
-              type: "text",
-              text: `List all available prompts.
+            type: "text",
+            text: `\u2705 ${writeResult.message}
 
-Call the \`prompts_list\` tool with optional \`search\` parameter to filter results.`
-            }
+${resourceLabel}: ${writeResult.slug}${versionInfo}${updatedInfo}`
           }
         ]
       };
     }
-    const runPromptMatch = promptName.match(/^prompts_run\s+(.+)$/);
-    if (promptName === "prompts_run" || runPromptMatch) {
-      let promptContent;
-      let description;
-      if (runPromptMatch) {
-        const promptSlug = runPromptMatch[1].trim();
-        description = `Execute prompt "${promptSlug}"`;
-        promptContent = `Execute the "${promptSlug}" prompt.
+    return {
+      content: [{ type: "text", text: "Unknown response format" }],
+      isError: true
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] prompts_update error:`, error);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error updating prompt: ${errorMessage}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
 
-Call the \`prompts_run\` tool with slug: "${promptSlug}".`;
-      } else {
-        description = "Execute a prompt by slug";
-        promptContent = `Execute a prompt by slug.
+// src/handlers/tickets.ts
+async function handleTicketsWork(args, config, convexClient, projectSlug) {
+  const { ticketSlug, agent } = parseWorkArgs(args);
+  const resolvedAgent = resolveAgent(agent);
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.mutation(
+      "mcp_tickets:workMcpTicket",
+      {
+        ...buildAuthArgs(config),
+        projectSlug,
+        ticketSlug,
+        agentId: resolvedAgent
+      }
+    );
+    if (!result) {
+      const agentContext = resolvedAgent ? ` for agent "${resolvedAgent}"` : "";
+      const message = ticketSlug ? `Ticket "${ticketSlug}" not found or not in open/working status in project "${projectSlug}"${agentContext}.` : `No open tickets${agentContext} in project "${projectSlug}".`;
+      return {
+        content: [{ type: "text", text: message }]
+      };
+    }
+    if (isAccessDenied(result)) {
+      return {
+        content: [{ type: "text", text: `Access denied: ${result.error}` }],
+        isError: true
+      };
+    }
+    const workResult = result;
+    const startedInfo = workResult.startedAt ? `
+Started: ${new Date(workResult.startedAt).toISOString()}` : "";
+    const pausedNotice = workResult.pausedAt ? `
 
-## Usage
-Call the \`prompts_run\` tool with the prompt slug.
+**\u26A0\uFE0F PAUSED TICKET HANDOFF**: This ticket was paused on ${new Date(workResult.pausedAt).toISOString()}. A previous agent checkpointed their progress. Review the checkpoint content below (look for "## Progress", "## Context", "## Remaining", "## Blockers" sections) and resume where they left off.
+` : "";
+    const statusNote = workResult.wasOpened ? `_Ticket moved to working status. ${workResult.remainingTickets} ticket(s) remaining in queue._` : `_Resuming work on this ticket. ${workResult.remainingTickets} ticket(s) in queue._`;
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# Ticket: ${workResult.slug} [WORKING]${startedInfo}${pausedNotice}
 
-## Available Prompts
-Use \`prompts_list\` to list all available prompts.
+${workResult.content}
 
-## Example
-/ppm:prompts_run code-review
+---
+${statusNote}`
+        }
+      ]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] tickets_work error:`, error);
+    return {
+      content: [{ type: "text", text: `Error getting work: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
+async function handleTicketsCreate(args, config, convexClient, projectSlug) {
+  const parsedArgs = parseCreateArgs(args);
+  if (!parsedArgs) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: Missing content parameter. Provide the ticket content (first line becomes the slug).`
+        }
+      ],
+      isError: true
+    };
+  }
+  const { content, agent } = parsedArgs;
+  const resolvedAgent = resolveAgent(agent);
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.mutation(
+      "mcp_tickets:createMcpTicket",
+      {
+        ...buildAuthArgs(config),
+        projectSlug,
+        content,
+        agentId: resolvedAgent
+      }
+    );
+    const agentInfo = result.agentId ? `
+Assigned to: ${result.agentId}` : "";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u2705 Created ticket [${result.slug}] in backlog for project "${projectSlug}".${agentInfo}
+
+Position: #${result.position} of ${result.totalBacklog} backlog tickets
+Preview: ${result.preview}
+
+_Ticket created in backlog. Use \`tickets_work ${result.slug}\` to move it to working status._`
+        }
+      ]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] tickets_create error:`, error);
+    return {
+      content: [{ type: "text", text: `Error creating ticket: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
+async function handleTicketsClose(args, config, convexClient, projectSlug) {
+  const parsedArgs = parseCloseArgs(args);
+  if (!parsedArgs) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: Missing ticketSlug parameter. Usage: Provide a ticket number (e.g., "102") or full slug (e.g., "102-fix-auth").`
+        }
+      ],
+      isError: true
+    };
+  }
+  const { ticketSlug, metadata } = parsedArgs;
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.mutation(
+      "mcp_tickets:closeMcpTicket",
+      {
+        ...buildAuthArgs(config),
+        projectSlug,
+        ticketSlug,
+        metadata
+      }
+    );
+    let responseText = `\u2705 Ticket [${result.slug}] closed in project "${projectSlug}".
+
+Closed at: ${new Date(result.closedAt).toISOString()}`;
+    if (result.metadata && Object.keys(result.metadata).length > 0) {
+      responseText += `
 
-This will execute the "code-review" prompt.`;
+**Metadata saved:**`;
+      for (const [key, value] of Object.entries(result.metadata)) {
+        responseText += `
+- ${key}: ${JSON.stringify(value)}`;
       }
+    }
+    responseText += `
+
+_Reminder: Ensure all embedded \`[RUN_PROMPT ...]\` directives were executed before closing._`;
+    return {
+      content: [{ type: "text", text: responseText }]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] tickets_close error:`, error);
+    return {
+      content: [{ type: "text", text: `Error closing ticket: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
+async function handleTicketsPause(args, config, convexClient, projectSlug) {
+  const parsedArgs = parsePauseArgs(args);
+  if (!parsedArgs) {
+    const rawArgs = args;
+    const hasTicketSlug = typeof rawArgs?.ticketSlug === "string" && rawArgs.ticketSlug;
+    const hasContent = typeof rawArgs?.content === "string" && rawArgs.content;
+    if (!hasTicketSlug) {
       return {
-        description,
-        messages: [
+        content: [
           {
-            role: "user",
-            content: {
-              type: "text",
-              text: promptContent
-            }
+            type: "text",
+            text: `Error: Missing ticketSlug parameter. Provide a ticket number (e.g., "102") or full slug.`
           }
-        ]
+        ],
+        isError: true
       };
     }
-    throw new Error(`Unknown prompt: ${promptName}. Use prompts_run to execute prompts.`);
-  });
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const tools = [
-      // System tools with full input schemas
-      ...SYSTEM_TOOLS.map((st) => ({
-        name: st.name,
-        description: st.description,
-        inputSchema: st.inputSchema
-      })),
-      // Dynamic ticket tools per project (Ticket 135, 149, 151, 153, unified work)
-      ...dynamicTicketTools.map((tt) => {
-        let inputSchema;
-        if (tt.type === "close") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              ticketSlug: {
-                type: "string",
-                description: "Ticket number (e.g., '102') or full slug (e.g., '102-fix-auth')"
-              },
-              metadata: {
-                type: "object",
-                description: "Optional: Key-value metadata to store with the closed ticket (e.g., evaluation scores, completion notes).",
-                additionalProperties: {
-                  oneOf: [
-                    { type: "string" },
-                    { type: "number" },
-                    { type: "boolean" }
-                  ]
-                }
-              }
-            },
-            required: ["ticketSlug"]
-          };
-        } else if (tt.type === "pause") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              ticketSlug: {
-                type: "string",
-                description: "Ticket number (e.g., '102') or full slug (e.g., '102-fix-auth')"
-              },
-              content: {
-                type: "string",
-                description: "Comprehensive checkpoint for handoff. Review the session and include: ## Progress (completed tasks with specifics, decisions made and why) ## Context (user preferences, edge cases discovered, key feedback received) ## Remaining (specific next steps, file:line references if applicable) ## Blockers (unresolved issues, open questions). This enables the next agent to continue seamlessly."
-              }
-            },
-            required: ["ticketSlug", "content"]
-          };
-        } else if (tt.type === "work") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              ticketSlug: {
-                type: "string",
-                description: "Optional: Ticket number (e.g., '102') or full slug. If not provided, gets next ticket from open queue."
-              },
-              agent: {
-                type: "string",
-                description: "Optional: Agent slug to filter queue. Overrides PPM_AGENT_NAME env var. Omit for owner mode (no filtering)."
-              }
-            },
-            required: []
-          };
-        } else if (tt.type === "create") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              content: {
-                type: "string",
-                description: "The generated ticket content. First line should be a clear descriptive title (becomes the slug). Body contains tasks, description, context as needed."
-              },
-              agent: {
-                type: "string",
-                description: "Optional: Agent slug to assign ticket to. Overrides PPM_AGENT_NAME env var. Omit for unassigned."
-              }
-            },
-            required: ["content"]
-          };
-        } else if (tt.type === "search") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              query: {
-                type: "string",
-                description: "Search query (min 3 characters)"
-              },
-              agent: {
-                type: "string",
-                description: "Optional: Agent slug to filter results. Overrides PPM_AGENT_NAME env var. Omit for all tickets."
-              }
-            },
-            required: ["query"]
-          };
-        } else if (tt.type === "get") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              ticketSlug: {
-                type: "string",
-                description: "Ticket number (e.g., '102') or full slug"
-              }
-            },
-            required: ["ticketSlug"]
-          };
-        } else if (tt.type === "list") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              agent: {
-                type: "string",
-                description: "Optional: Agent slug to filter tickets. Overrides PPM_AGENT_NAME env var. Omit for all tickets."
-              }
-            },
-            required: []
-          };
-        } else if (tt.type === "update") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              ticketSlug: {
-                type: "string",
-                description: "Ticket number (e.g., '102') or full slug (e.g., '102-fix-auth')"
-              },
-              content: {
-                type: "string",
-                description: "Update content to append to the ticket (markdown supported)"
-              },
-              agent: {
-                type: "string",
-                description: "Optional: Reassign ticket to this agent. Use empty string '' to unassign."
-              }
-            },
-            required: ["ticketSlug", "content"]
-          };
-        } else {
-          inputSchema = {
-            type: "object",
-            properties: {},
-            required: []
-          };
-        }
-        return {
-          name: tt.name,
-          description: tt.description,
-          inputSchema
-        };
-      }),
-      // Global prompts_run tool
-      {
-        name: "prompts_run",
-        description: "Execute a prompt by slug. Use prompts_list to list available prompts.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            slug: {
-              type: "string",
-              description: "Prompt slug to execute (e.g., 'code-review', 'plan')"
-            }
-          },
-          required: ["slug"]
-        }
-      },
-      // Global prompts_list tool
-      {
-        name: "prompts_list",
-        description: "List all available prompts",
-        inputSchema: {
-          type: "object",
-          properties: {
-            search: {
-              type: "string",
-              description: "Optional search term to filter prompts by name or description (case-insensitive)"
-            }
+    if (!hasContent) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Missing content parameter. Describe what's done, what remains, and any blockers.`
           }
-        }
-      },
-      // Global prompts_update tool (CLI-based prompt/snippet/template editing)
+        ],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: `Error: Missing required parameters.` }],
+      isError: true
+    };
+  }
+  const { ticketSlug, content } = parsedArgs;
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.mutation(
+      "mcp_tickets:pauseMcpTicket",
       {
-        name: "prompts_update",
-        description: "Read or update a prompt, snippet, or template. Without content: returns resource with context. With content: saves new version.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            slug: {
-              type: "string",
-              description: "Resource slug to read or update. Searches prompts first, then snippets, then templates. Supports fuzzy matching."
-            },
-            content: {
-              type: "string",
-              description: "New resource content (omit for read-only mode)"
-            }
-          },
-          required: ["slug"]
-        }
-      },
-      // Dynamic memory tools (implement-memory-system)
-      ...dynamicMemoryTools.map((mt) => {
-        let inputSchema;
-        if (mt.type === "load") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              query: {
-                type: "string",
-                description: "Optional: search query to filter agent memories. If not provided, returns recent memories."
-              }
-            },
-            required: []
-          };
-        } else if (mt.type === "load_extreme") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              query: {
-                type: "string",
-                description: "Optional: search query to filter agent memories. If not provided, returns recent memories."
-              }
-            },
-            required: []
-          };
-        } else if (mt.type === "add") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              content: {
-                type: "string",
-                description: "Memory content to record. Be concise and focused on key decisions, patterns, or context."
-              }
-            },
-            required: ["content"]
-          };
-        } else if (mt.type === "list_all") {
-          inputSchema = {
-            type: "object",
-            properties: {
-              typeFilter: {
-                type: "string",
-                enum: ["all", "user", "agent"],
-                description: "Optional: Filter by memory type. 'user' = rules, 'agent' = history. Default: 'all'"
-              }
-            },
-            required: []
-          };
-        } else {
-          inputSchema = {
-            type: "object",
-            properties: {},
-            required: []
-          };
-        }
-        return {
-          name: mt.name,
-          description: mt.description,
-          inputSchema
-        };
-      }),
-      // Dynamic per-prompt tools (each prompt as its own global tool)
-      ...dynamicPromptTools.map((pt) => ({
-        name: pt.name,
-        description: pt.description,
-        inputSchema: {
-          type: "object",
-          properties: {},
-          required: []
-        }
-      }))
-    ];
-    return { tools };
-  });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const toolName = request.params.name;
-    if (toolName === "prompts_run") {
-      const parsedArgs = parsePromptsRunArgs(request.params.arguments);
-      if (!parsedArgs) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: Missing 'slug' parameter. Provide prompt slug (e.g., 'code-review', 'plan').
-
-Use \`prompts_list\` to list available prompts.`
-            }
-          ],
-          isError: true
-        };
+        ...buildAuthArgs(config),
+        projectSlug,
+        ticketSlug,
+        content
       }
-      const { slug: promptSlug } = parsedArgs;
-      try {
-        const result = await fetchAndExecuteAccountScopedPrompt(
-          promptSlug,
-          config,
-          convexClient
-        );
-        const promptText = result.messages.map((msg) => msg.content.text).join("\n\n");
-        return {
-          content: [
-            {
-              type: "text",
-              text: promptText
-            }
-          ]
-        };
-      } catch (error) {
-        if (error instanceof AmbiguousPromptError) {
-          const suggestionsList = error.suggestions.map((s) => `  \u2022 ${s}`).join("\n");
-          console.error(`[MCP] ${toolName} ambiguous match:`, error.suggestions);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Multiple prompts match "${promptSlug}". Please specify one of:
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u2705 Ticket [${result.slug}] paused and returned to open queue in project "${projectSlug}".
 
-${suggestionsList}
+Paused at: ${new Date(result.pausedAt).toISOString()}
 
-Example: \`prompts_run ${error.suggestions[0]}\``
-              }
-            ],
-            isError: true
-          };
+_Ticket moved from working \u2192 open. Checkpoint content has been appended. Any agent can pick it up with \`tickets_work\`._`
         }
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        console.error(`[MCP] ${toolName} error:`, error);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error executing prompt "${promptSlug}": ${errorMessage}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-    if (toolName === "prompts_list") {
-      const { search: searchTerm } = parsePromptsListArgs(request.params.arguments);
-      let filteredPrompts = [...accountScopedPrompts];
-      if (searchTerm) {
-        const lowerSearch = searchTerm.toLowerCase();
-        filteredPrompts = filteredPrompts.filter(
-          (p) => p.slug.toLowerCase().includes(lowerSearch) || p.description?.toLowerCase().includes(lowerSearch)
-        );
-      }
-      filteredPrompts.sort((a, b) => a.slug.localeCompare(b.slug));
-      const userPromptList = filteredPrompts.map((p) => {
-        const desc = p.description || "No description";
-        return `\u2022 ${p.slug}
-  Description: ${desc}`;
-      }).join("\n\n");
-      const summary = searchTerm ? `Found ${filteredPrompts.length} prompt(s) matching "${searchTerm}":` : `Available prompts (${filteredPrompts.length} total):`;
+      ]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] tickets_pause error:`, error);
+    return {
+      content: [{ type: "text", text: `Error pausing ticket: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
+async function handleTicketsSearch(args, config, convexClient, projectSlug) {
+  const parsedArgs = parseSearchArgs(args);
+  if (!parsedArgs) {
+    return {
+      content: [{ type: "text", text: `Error: Search query must be at least 3 characters` }],
+      isError: true
+    };
+  }
+  const { query, agent } = parsedArgs;
+  const resolvedAgent = resolveAgent(agent);
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.query("mcp_tickets:searchMcpTickets", {
+      ...buildAuthArgs(config),
+      projectSlug,
+      query,
+      agentId: resolvedAgent
+    });
+    const agentContext = resolvedAgent ? ` for agent "${resolvedAgent}"` : "";
+    if (result.length === 0) {
       return {
         content: [
           {
             type: "text",
-            text: userPromptList ? `${summary}
-
-${userPromptList}` : `${summary}
-
-No prompts found.`
+            text: `No tickets found matching "${query}"${agentContext} in project "${projectSlug}".`
           }
         ]
       };
     }
-    if (toolName === "prompts_update") {
-      const parsedArgs = parsePromptsUpdateArgs(request.params.arguments);
-      if (!parsedArgs) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: Missing 'slug' parameter. Provide prompt slug to read or update.
+    const formattedList = result.map((t) => {
+      const statusBadge = t.status === "open" ? "\u{1F7E2}" : t.status === "working" ? "\u{1F7E1}" : t.status === "closed" ? "\u26AB" : "\u26AA";
+      const num = t.ticketNumber ? `#${t.ticketNumber}` : "";
+      const agentBadge = t.agentId ? ` [${t.agentId}]` : "";
+      const metadataHint = t.metadata && Object.keys(t.metadata).length > 0 ? ` {${Object.keys(t.metadata).length} meta}` : "";
+      return `${statusBadge} ${num} ${t.slug}${agentBadge}${metadataHint}
+   ${t.matchSnippet}`;
+    }).join("\n\n");
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Found ${result.length} ticket(s) matching "${query}"${agentContext}:
 
-Usage:
-- Read mode: prompts_update { slug: "my-prompt" }
-- Write mode: prompts_update { slug: "my-prompt", content: "new content..." }`
-            }
-          ],
-          isError: true
-        };
+${formattedList}`
+        }
+      ]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] tickets_search error:`, error);
+    return {
+      content: [{ type: "text", text: `Error searching tickets: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
+async function handleTicketsGet(args, config, convexClient, projectSlug) {
+  const parsedArgs = parseGetArgs(args);
+  if (!parsedArgs) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: Missing ticketSlug parameter. Provide a ticket number (e.g., "102") or full slug.`
+        }
+      ],
+      isError: true
+    };
+  }
+  const { ticketSlug } = parsedArgs;
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.query(
+      "mcp_tickets:getMcpTicket",
+      {
+        ...buildAuthArgs(config),
+        projectSlug,
+        ticketSlug
       }
-      try {
-        const result = await convexClient.mutation(
-          "mcp_prompts:updateMcpPrompt",
+    );
+    if (!result) {
+      return {
+        content: [
           {
-            ...buildAuthArgs(config),
-            promptSlug: parsedArgs.slug,
-            content: parsedArgs.content
-          }
-        );
-        if (!result.success) {
-          const errorResult = result;
-          if (errorResult.suggestions) {
-            const suggestionsList = errorResult.suggestions.map((s) => `  \u2022 ${s}`).join("\n");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `${errorResult.error}
-
-Did you mean one of these?
-${suggestionsList}`
-                }
-              ],
-              isError: true
-            };
+            type: "text",
+            text: `Ticket "${ticketSlug}" not found in project "${projectSlug}".`
           }
-          return {
-            content: [{ type: "text", text: errorResult.error }],
-            isError: true
-          };
-        }
-        if (result.mode === "read") {
-          const readResult = result;
-          const matchNote = readResult.matchType !== "exact" ? `
-_Note: Matched via ${readResult.matchType} match_` : "";
-          const aiTagNotice = readResult.hasAiTags ? `
-
-## \u26A1 AI Tags Detected
-This ${readResult.resourceType} contains AI tags that need processing: **${readResult.aiTags?.join(", ")}**
-
-Process these tags by reading the instructions in each tag, generating appropriate content, and saving the result with the content parameter.` : "";
-          const versionInfo = readResult.version !== void 0 ? ` (v${readResult.version})` : "";
-          const resourceLabel = readResult.resourceType.charAt(0).toUpperCase() + readResult.resourceType.slice(1);
-          const contextSection = readResult.context ? `
-
-## Available Resources
-\`\`\`json
-${JSON.stringify(readResult.context, null, 2)}
-\`\`\`` : "";
-          return {
-            content: [
-              {
-                type: "text",
-                text: `# ${resourceLabel}: ${readResult.slug}${versionInfo}${matchNote}${aiTagNotice}
-
-## Description
-${readResult.description || "No description"}
-
-## Content
-\`\`\`
-${readResult.content}
-\`\`\`${contextSection}
+        ]
+      };
+    }
+    if (isAccessDenied(result)) {
+      return {
+        content: [{ type: "text", text: `Access denied: ${result.error}` }],
+        isError: true
+      };
+    }
+    const getResult = result;
+    const statusBadge = getResult.status.toUpperCase();
+    const startedInfo = getResult.startedAt ? `
+Started: ${new Date(getResult.startedAt).toISOString()}` : "";
+    const closedInfo = getResult.closedAt ? `
+Closed: ${new Date(getResult.closedAt).toISOString()}` : "";
+    let metadataInfo = "";
+    if (getResult.metadata && Object.keys(getResult.metadata).length > 0) {
+      metadataInfo = "\n\n**Metadata:**";
+      for (const [key, value] of Object.entries(getResult.metadata)) {
+        metadataInfo += `
+- ${key}: ${JSON.stringify(value)}`;
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# Ticket: ${getResult.slug} [${statusBadge}]${startedInfo}${closedInfo}
 
-${readResult.editingGuidance}
+${getResult.content}${metadataInfo}
 
 ---
-_To update this ${readResult.resourceType}, call prompts_update with content parameter._`
-              }
-            ]
-          };
-        }
-        if (result.mode === "write") {
-          const writeResult = result;
-          const resourceLabel = writeResult.resourceType.charAt(0).toUpperCase() + writeResult.resourceType.slice(1);
-          const versionInfo = writeResult.version !== void 0 ? `
-Version: ${writeResult.version}` : "";
-          const updatedInfo = writeResult.updatedAt ? `
-Updated: ${writeResult.updatedAt}` : "";
-          return {
-            content: [
-              {
-                type: "text",
-                text: `\u2705 ${writeResult.message}
-
-${resourceLabel}: ${writeResult.slug}${versionInfo}${updatedInfo}`
-              }
-            ]
-          };
+_Read-only inspection. Use tickets_work to start working on this ticket._`
         }
-        return {
-          content: [{ type: "text", text: "Unknown response format" }],
-          isError: true
-        };
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        console.error(`[MCP] prompts_update error:`, error);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error updating prompt: ${errorMessage}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-    const ticketTool = dynamicTicketTools.find((tt) => tt.name === toolName);
-    if (ticketTool) {
-      if (ticketTool.type === "work") {
-        const { ticketSlug, agent } = parseWorkArgs(request.params.arguments);
-        const resolvedAgent = resolveAgent(agent);
-        try {
-          const result = await convexClient.mutation(
-            "mcp_tickets:workMcpTicket",
-            {
-              ...buildAuthArgs(config),
-              projectSlug: ticketTool.projectSlug,
-              ticketSlug,
-              // Optional: specific ticket to work on
-              agentId: resolvedAgent
-              // Agent filtering (implement-agent-routing)
-            }
-          );
-          if (!result) {
-            const agentContext = resolvedAgent ? ` for agent "${resolvedAgent}"` : "";
-            const message = ticketSlug ? `Ticket "${ticketSlug}" not found or not in open/working status in project "${ticketTool.projectSlug}"${agentContext}.` : `No open tickets${agentContext} in project "${ticketTool.projectSlug}".`;
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: message
-                }
-              ]
-            };
-          }
-          if (isAccessDenied(result)) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Access denied: ${result.error}`
-                }
-              ],
-              isError: true
-            };
+      ]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] tickets_get error:`, error);
+    return {
+      content: [{ type: "text", text: `Error getting ticket: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
+async function handleTicketsList(args, config, convexClient, projectSlug) {
+  const { agent } = parseListArgs(args);
+  const resolvedAgent = resolveAgent(agent);
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.query("mcp_tickets:listMcpTickets", {
+      ...buildAuthArgs(config),
+      projectSlug,
+      agentId: resolvedAgent
+    });
+    const agentContext = resolvedAgent ? ` for agent "${resolvedAgent}"` : "";
+    if (result.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No active tickets${agentContext} in project "${projectSlug}". All tickets are closed or archived.`
           }
-          const workResult = result;
-          const startedInfo = workResult.startedAt ? `
-Started: ${new Date(workResult.startedAt).toISOString()}` : "";
-          const pausedNotice = workResult.pausedAt ? `
-
-**\u26A0\uFE0F PAUSED TICKET HANDOFF**: This ticket was paused on ${new Date(workResult.pausedAt).toISOString()}. A previous agent checkpointed their progress. Review the checkpoint content below (look for "## Progress", "## Context", "## Remaining", "## Blockers" sections) and resume where they left off.
-` : "";
-          const statusNote = workResult.wasOpened ? `_Ticket moved to working status. ${workResult.remainingTickets} ticket(s) remaining in queue._` : `_Resuming work on this ticket. ${workResult.remainingTickets} ticket(s) in queue._`;
-          return {
-            content: [
-              {
-                type: "text",
-                text: `# Ticket: ${workResult.slug} [WORKING]${startedInfo}${pausedNotice}
+        ]
+      };
+    }
+    const openTickets = result.filter((t) => t.status === "open");
+    const workingTickets = result.filter((t) => t.status === "working");
+    const backlogTickets = result.filter((t) => t.status === "backlog");
+    const formatTicketLine = (t) => {
+      const num = t.ticketNumber ? `#${t.ticketNumber}` : "";
+      const agentBadge = !resolvedAgent && t.agentId ? ` [${t.agentId}]` : "";
+      return `  ${t.position}. ${num} ${t.slug}${agentBadge}
+     ${t.preview}`;
+    };
+    const sections = [];
+    if (openTickets.length > 0) {
+      sections.push(
+        `**\u{1F7E2} Open (${openTickets.length})**
+${openTickets.map(formatTicketLine).join("\n")}`
+      );
+    }
+    if (workingTickets.length > 0) {
+      sections.push(
+        `**\u{1F7E1} Working (${workingTickets.length})**
+${workingTickets.map(formatTicketLine).join("\n")}`
+      );
+    }
+    if (backlogTickets.length > 0) {
+      sections.push(
+        `**\u26AA Backlog (${backlogTickets.length})**
+${backlogTickets.map(formatTicketLine).join("\n")}`
+      );
+    }
+    const headerSuffix = resolvedAgent ? ` (Agent: ${resolvedAgent})` : "";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# Active Queue: ${projectSlug}${headerSuffix}
 
-${workResult.content}
+${result.length} ticket(s) in queue
 
----
-${statusNote}`
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] tickets_work error:`, error);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error getting work: ${errorMessage}`
-              }
-            ],
-            isError: true
-          };
+${sections.join("\n\n")}`
         }
-      } else if (ticketTool.type === "create") {
-        const parsedArgs = parseCreateArgs(request.params.arguments);
-        if (!parsedArgs) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: Missing content parameter. Provide the ticket content (first line becomes the slug).`
-              }
-            ],
-            isError: true
-          };
+      ]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] tickets_list error:`, error);
+    return {
+      content: [{ type: "text", text: `Error listing tickets: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
+async function handleTicketsUpdate(args, config, convexClient, projectSlug) {
+  const parsedArgs = parseUpdateArgs(args);
+  if (!parsedArgs) {
+    const rawArgs = args;
+    const hasTicketSlug = typeof rawArgs?.ticketSlug === "string" && rawArgs.ticketSlug;
+    const hasContent = typeof rawArgs?.content === "string" && rawArgs.content;
+    if (!hasTicketSlug) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Missing ticketSlug parameter. Provide a ticket number (e.g., "102") or full slug.`
+          }
+        ],
+        isError: true
+      };
+    }
+    if (!hasContent) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Missing content parameter. Provide the update content to append to the ticket.`
+          }
+        ],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: `Error: Missing required parameters.` }],
+      isError: true
+    };
+  }
+  const { ticketSlug, content, agent } = parsedArgs;
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.mutation("mcp_tickets:updateMcpTicket", {
+      ...buildAuthArgs(config),
+      projectSlug,
+      ticketSlug,
+      content,
+      ...agent !== void 0 && { agentId: agent }
+    });
+    const agentInfo = result.agentId ? `
+Assigned to: ${result.agentId}` : agent === "" ? "\nAgent: Unassigned" : "";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u2705 Ticket [${result.slug}] updated in project "${projectSlug}".${agentInfo}
+Updated at: ${new Date(result.updatedAt).toISOString()}
+_Ticket content has been appended with your update._`
         }
-        const { content, agent } = parsedArgs;
-        const resolvedAgent = resolveAgent(agent);
-        try {
-          const result = await convexClient.mutation(
-            "mcp_tickets:createMcpTicket",
-            {
-              ...buildAuthArgs(config),
-              projectSlug: ticketTool.projectSlug,
-              content,
-              agentId: resolvedAgent
-              // Agent assignment (implement-agent-routing)
-            }
-          );
-          const agentInfo = result.agentId ? `
-Assigned to: ${result.agentId}` : "";
-          return {
-            content: [
-              {
-                type: "text",
-                text: `\u2705 Created ticket [${result.slug}] in backlog for project "${ticketTool.projectSlug}".${agentInfo}
+      ]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] tickets_update error:`, error);
+    return {
+      content: [{ type: "text", text: `Error updating ticket: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
 
-Position: #${result.position} of ${result.totalBacklog} backlog tickets
-Preview: ${result.preview}
+// src/handlers/memories.ts
+async function handleMemoriesLoad(args, config, convexClient, projectSlug) {
+  const { query } = parseMemoriesLoadArgs(args);
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.query("mcp_memories:loadMemories", {
+      ...buildAuthArgs(config),
+      projectSlug,
+      query
+    });
+    const sections = [];
+    if (result.userMemories.length > 0) {
+      const rulesText = result.userMemories.map((m, i) => `${i + 1}. ${m.content}`).join("\n");
+      sections.push(`## Rules (${result.userMemories.length})
+${rulesText}`);
+    } else {
+      sections.push(`## Rules
+_No rules defined. Create rules in the Memories page._`);
+    }
+    if (result.agentMemories.length > 0) {
+      const historyText = result.agentMemories.map((m) => {
+        const ticketRef = m.ticketNumber ? `[#${m.ticketNumber}]` : "";
+        const date = new Date(m.createdAt).toISOString().split("T")[0];
+        return `\u2022 ${ticketRef} ${m.content} _(${date})_`;
+      }).join("\n");
+      const searchNote = query ? ` matching "${query}"` : " (recent)";
+      sections.push(`## History${searchNote} (${result.agentMemories.length})
+${historyText}`);
+    } else {
+      const searchNote = query ? ` matching "${query}"` : "";
+      sections.push(`## History${searchNote}
+_No memories recorded yet._`);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# Project Memories: ${projectSlug}
 
-_Ticket created in backlog. Use \`tickets_work ${result.slug}\` to move it to working status._`
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] tickets_create error:`, error);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error creating ticket: ${errorMessage}`
-              }
-            ],
-            isError: true
-          };
+${sections.join("\n\n")}`
         }
-      } else if (ticketTool.type === "close") {
-        const parsedArgs = parseCloseArgs(request.params.arguments);
-        if (!parsedArgs) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: Missing ticketSlug parameter. Usage: Provide a ticket number (e.g., "102") or full slug (e.g., "102-fix-auth").`
-              }
-            ],
-            isError: true
-          };
+      ]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] memories_load error:`, error);
+    return {
+      content: [{ type: "text", text: `Error loading memories: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
+async function handleMemoriesLoadExtreme(args, config, convexClient, projectSlug) {
+  const { query } = parseMemoriesLoadArgs(args);
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.query(
+      "mcp_memories:loadMemoriesExtreme",
+      {
+        ...buildAuthArgs(config),
+        projectSlug,
+        query
+      }
+    );
+    const lines = [];
+    lines.push(`# Project Memories: ${projectSlug}
+`);
+    lines.push(`## Rules (${result.userMemories.length})`);
+    if (result.userMemories.length > 0) {
+      result.userMemories.forEach((m, i) => {
+        lines.push(`${i + 1}. ${m.content}`);
+      });
+    } else {
+      lines.push(`_No rules defined. Create rules in the Memories page._`);
+    }
+    lines.push("");
+    const historyHeader = query ? `## History matching "${query}" (${result.agentMemories.length})` : `## Recent History (${result.agentMemories.length})`;
+    lines.push(historyHeader);
+    lines.push("");
+    for (const memory of result.agentMemories) {
+      lines.push("---");
+      lines.push(`**Memory:** ${memory.content}`);
+      if (memory.ticket) {
+        lines.push(`**Ticket:** #${memory.ticket.ticketNumber}-${memory.ticket.slug}`);
+      }
+      const date = new Date(memory.createdAt).toISOString().split("T")[0];
+      lines.push(`**Date:** ${date}`);
+      lines.push("");
+      if (memory.ticket) {
+        lines.push("<ticket-content>");
+        lines.push(memory.ticket.content);
+        lines.push("</ticket-content>");
+      } else {
+        lines.push("_(No linked ticket)_");
+      }
+      lines.push("");
+    }
+    return {
+      content: [{ type: "text", text: lines.join("\n") }]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] memories_load_extreme error:`, error);
+    return {
+      content: [{ type: "text", text: `Error loading extreme memories: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
+async function handleMemoriesAdd(args, config, convexClient, projectSlug) {
+  const parsedArgs = parseMemoriesAddArgs(args);
+  if (!parsedArgs) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: Missing content parameter. Provide the memory content to record.`
         }
-        const { ticketSlug, metadata } = parsedArgs;
-        try {
-          const result = await convexClient.mutation(
-            "mcp_tickets:closeMcpTicket",
-            {
-              ...buildAuthArgs(config),
-              projectSlug: ticketTool.projectSlug,
-              ticketSlug,
-              metadata
-            }
-          );
-          let responseText = `\u2705 Ticket [${result.slug}] closed in project "${ticketTool.projectSlug}".
+      ],
+      isError: true
+    };
+  }
+  const { content } = parsedArgs;
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.mutation("mcp_memories:addMemory", {
+      ...buildAuthArgs(config),
+      projectSlug,
+      content
+    });
+    let responseText;
+    if (result.linkedTicket) {
+      const ticketRef = `#${result.linkedTicket.number}`;
+      const fallbackNote = result.linkedViaFallback ? " (recently closed)" : "";
+      responseText = `\u2705 Memory recorded for ticket [${ticketRef}]${fallbackNote} in project "${projectSlug}".
 
-Closed at: ${new Date(result.closedAt).toISOString()}`;
-          if (result.metadata && Object.keys(result.metadata).length > 0) {
-            responseText += `
+_Memory will be available in future context via [MEMORY_LOAD]._`;
+    } else {
+      responseText = `\u2705 Memory recorded in project "${projectSlug}".
 
-**Metadata saved:**`;
-            for (const [key, value] of Object.entries(result.metadata)) {
-              responseText += `
-- ${key}: ${JSON.stringify(value)}`;
-            }
-          }
-          responseText += `
+_Memory created without ticket linkage (no working ticket or recent closed ticket)._
+_Memory will be available in future context via [MEMORY_LOAD]._`;
+    }
+    return {
+      content: [{ type: "text", text: responseText }]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] memories_add error:`, error);
+    return {
+      content: [{ type: "text", text: `Error adding memory: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
+async function handleMemoriesListAll(args, config, convexClient, projectSlug) {
+  const parsedArgs = parseMemoriesListAllArgs(args);
+  const typedClient = convexClient;
+  try {
+    const result = await typedClient.query("mcp_memories:listAllMemories", {
+      ...buildAuthArgs(config),
+      projectSlug,
+      typeFilter: parsedArgs.typeFilter
+    });
+    const formatDate = (ts) => new Date(ts).toISOString().split("T")[0];
+    const userMemories = result.memories.filter((m) => m.type === "user");
+    const agentMemories = result.memories.filter((m) => m.type === "agent");
+    let output = `# Project Memories (${result.totalCount} total)
 
-_Reminder: Ensure all embedded \`[RUN_PROMPT ...]\` directives were executed before closing._`;
-          return {
-            content: [
-              {
-                type: "text",
-                text: responseText
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] tickets_close error:`, error);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error closing ticket: ${errorMessage}`
-              }
-            ],
-            isError: true
-          };
-        }
-      } else if (ticketTool.type === "pause") {
-        const parsedArgs = parsePauseArgs(request.params.arguments);
-        if (!parsedArgs) {
-          const args = request.params.arguments;
-          const hasTicketSlug = typeof args?.ticketSlug === "string" && args.ticketSlug;
-          const hasContent = typeof args?.content === "string" && args.content;
-          if (!hasTicketSlug) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Error: Missing ticketSlug parameter. Provide a ticket number (e.g., "102") or full slug.`
-                }
-              ],
-              isError: true
-            };
-          }
-          if (!hasContent) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Error: Missing content parameter. Describe what's done, what remains, and any blockers.`
-                }
-              ],
-              isError: true
-            };
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: Missing required parameters.`
-              }
-            ],
-            isError: true
-          };
-        }
-        const { ticketSlug, content } = parsedArgs;
-        try {
-          const result = await convexClient.mutation(
-            "mcp_tickets:pauseMcpTicket",
-            {
-              ...buildAuthArgs(config),
-              projectSlug: ticketTool.projectSlug,
-              ticketSlug,
-              content
-            }
-          );
-          return {
-            content: [
-              {
-                type: "text",
-                text: `\u2705 Ticket [${result.slug}] paused and returned to open queue in project "${ticketTool.projectSlug}".
+`;
+    if (userMemories.length > 0) {
+      output += `## Rules (${userMemories.length})
+`;
+      userMemories.forEach((m, i) => {
+        output += `${i + 1}. [${m.id}] ${m.content}
+`;
+      });
+      output += "\n";
+    }
+    if (agentMemories.length > 0) {
+      output += `## Agent History (${agentMemories.length})
+`;
+      agentMemories.forEach((m) => {
+        const ticketRef = m.ticketNumber ? ` [#${m.ticketNumber}]` : "";
+        output += `\u2022 [${m.id}]${ticketRef} ${m.content.substring(0, 100)}${m.content.length > 100 ? "..." : ""} _(${formatDate(m.createdAt)})_
+`;
+      });
+    }
+    return {
+      content: [{ type: "text", text: output }]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[MCP] memories_list_all error:`, error);
+    return {
+      content: [{ type: "text", text: `Error listing memories: ${errorMessage}` }],
+      isError: true
+    };
+  }
+}
+
+// src/server.ts
+async function startServer(config, convexClient) {
+  console.error("[MCP] Validating project token...");
+  const validation = await validateProjectToken(convexClient, config.projectToken);
+  if (!validation.valid) {
+    throw new Error(`Invalid project token: ${validation.error}`);
+  }
+  const projectSlug = validation.projectSlug;
+  console.error(`[MCP] Project token validated for project "${projectSlug}"`);
+  console.error("[MCP] Fetching prompt metadata...");
+  const accountScopedPrompts = await fetchAccountScopedPromptMetadataByToken(
+    convexClient,
+    config.projectToken
+  );
+  console.error(`[MCP] Project token mode: loaded ${accountScopedPrompts.length} prompts`);
+  const slashCommandPrompts = accountScopedPrompts.filter((p) => p.slashCommand === true);
+  console.error(`[MCP] ${slashCommandPrompts.length} prompts registered as slash commands`);
+  if (accountScopedPrompts.length === 0) {
+    console.error(
+      "[MCP] WARNING: No prompts found. Create prompts in the 'prompts' section to expose them via MCP."
+    );
+  }
+  const ticketTools = getTicketToolDefinitions(projectSlug);
+  const memoryTools = getMemoryToolDefinitions();
+  const promptTools = getPromptToolDefinitions();
+  console.error(`[MCP] Registering ${ticketTools.length} ticket tools...`);
+  console.error(`[MCP] Registering ${memoryTools.length} memory tools...`);
+  console.error(`[MCP] Registering ${promptTools.length} global prompt tools...`);
+  const dynamicPromptTools = accountScopedPrompts.map((prompt) => {
+    const folderPrefix = prompt.folderPath ? `[${prompt.folderPath}] ` : "";
+    const baseDescription = prompt.description || `Execute the "${prompt.slug}" prompt`;
+    return {
+      name: prompt.slug,
+      description: folderPrefix + baseDescription,
+      promptSlug: prompt.slug
+    };
+  });
+  console.error(`[MCP] Registering ${dynamicPromptTools.length} per-prompt tools (global)...`);
+  const promptNames = /* @__PURE__ */ new Set();
+  const duplicates = [];
+  accountScopedPrompts.forEach((p) => {
+    if (promptNames.has(p.slug)) {
+      duplicates.push(p.slug);
+    }
+    promptNames.add(p.slug);
+  });
+  if (duplicates.length > 0) {
+    console.error(
+      `[MCP] WARNING: Duplicate prompt slugs detected: ${duplicates.join(", ")}. Only the first occurrence will be registered.`
+    );
+  }
+  const server = new Server(
+    { name: "ppm-mcp-server", version: "3.1.0" },
+    { capabilities: { prompts: {}, tools: {} } }
+  );
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return {
+      prompts: [
+        // Global prompt tools (prompts_run, prompts_list, prompts_update)
+        ...promptTools.map((t) => ({ name: t.name, description: t.description })),
+        // Ticket tools
+        ...ticketTools.map((t) => ({ name: t.name, description: t.description })),
+        // Memory tools
+        ...memoryTools.map((t) => ({ name: t.name, description: t.description })),
+        // User prompts with slashCommand: true
+        ...slashCommandPrompts.map((p) => ({
+          name: p.slug,
+          description: p.description || `Execute the "${p.slug}" prompt`
+        }))
+      ]
+    };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const promptName = request.params.name;
+    const ticketWorkMatch = promptName.match(/^tickets_work\s+(.+)$/);
+    if (ticketWorkMatch) {
+      const ticketArg = ticketWorkMatch[1].trim();
+      return {
+        description: `Work on ticket "${ticketArg}" from "${projectSlug}"`,
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Get work on ticket "${ticketArg}" from the "${projectSlug}" project.
 
-Paused at: ${new Date(result.pausedAt).toISOString()}
+Call the \`tickets_work\` tool with ticketSlug: "${ticketArg}".
 
-_Ticket moved from working \u2192 open. Checkpoint content has been appended. Any agent can pick it up with \`tickets_work\`._`
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] tickets_pause error:`, error);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error pausing ticket: ${errorMessage}`
-              }
-            ],
-            isError: true
-          };
-        }
-      } else if (ticketTool.type === "search") {
-        const parsedArgs = parseSearchArgs(request.params.arguments);
-        if (!parsedArgs) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: Search query must be at least 3 characters`
-              }
-            ],
-            isError: true
-          };
-        }
-        const { query, agent } = parsedArgs;
-        const resolvedAgent = resolveAgent(agent);
-        try {
-          const result = await convexClient.query(
-            "mcp_tickets:searchMcpTickets",
-            {
-              ...buildAuthArgs(config),
-              projectSlug: ticketTool.projectSlug,
-              query,
-              agentId: resolvedAgent
-              // Agent filtering (implement-agent-routing)
+This will open the ticket if it's in the open queue, or resume it if already working.`
             }
-          );
-          const agentContext = resolvedAgent ? ` for agent "${resolvedAgent}"` : "";
-          if (result.length === 0) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `No tickets found matching "${query}"${agentContext} in project "${ticketTool.projectSlug}".`
-                }
-              ]
-            };
           }
-          const formattedList = result.map((t) => {
-            const statusBadge = t.status === "open" ? "\u{1F7E2}" : t.status === "working" ? "\u{1F7E1}" : t.status === "closed" ? "\u26AB" : "\u26AA";
-            const num = t.ticketNumber ? `#${t.ticketNumber}` : "";
-            const agentBadge = t.agentId ? ` [${t.agentId}]` : "";
-            const metadataHint = t.metadata && Object.keys(t.metadata).length > 0 ? ` {${Object.keys(t.metadata).length} meta}` : "";
-            return `${statusBadge} ${num} ${t.slug}${agentBadge}${metadataHint}
-   ${t.matchSnippet}`;
-          }).join("\n\n");
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Found ${result.length} ticket(s) matching "${query}"${agentContext}:
+        ]
+      };
+    }
+    const ticketTool = ticketTools.find((t) => t.name === promptName);
+    if (ticketTool) {
+      return buildTicketPromptResponse(ticketTool.type, ticketTool.name, projectSlug);
+    }
+    if (promptName === "prompts_list") {
+      return {
+        description: "List all available prompts",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `List all available prompts.
 
-${formattedList}`
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] tickets_search error:`, error);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error searching tickets: ${errorMessage}`
-              }
-            ],
-            isError: true
-          };
-        }
-      } else if (ticketTool.type === "get") {
-        const parsedArgs = parseGetArgs(request.params.arguments);
-        if (!parsedArgs) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: Missing ticketSlug parameter. Provide a ticket number (e.g., "102") or full slug.`
-              }
-            ],
-            isError: true
-          };
-        }
-        const { ticketSlug } = parsedArgs;
-        try {
-          const result = await convexClient.query(
-            "mcp_tickets:getMcpTicket",
-            {
-              ...buildAuthArgs(config),
-              projectSlug: ticketTool.projectSlug,
-              ticketSlug
-            }
-          );
-          if (!result) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Ticket "${ticketSlug}" not found in project "${ticketTool.projectSlug}".`
-                }
-              ]
-            };
-          }
-          if (isAccessDenied(result)) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Access denied: ${result.error}`
-                }
-              ],
-              isError: true
-            };
-          }
-          const getResult = result;
-          const statusBadge = getResult.status.toUpperCase();
-          const startedInfo = getResult.startedAt ? `
-Started: ${new Date(getResult.startedAt).toISOString()}` : "";
-          const closedInfo = getResult.closedAt ? `
-Closed: ${new Date(getResult.closedAt).toISOString()}` : "";
-          let metadataInfo = "";
-          if (getResult.metadata && Object.keys(getResult.metadata).length > 0) {
-            metadataInfo = "\n\n**Metadata:**";
-            for (const [key, value] of Object.entries(getResult.metadata)) {
-              metadataInfo += `
-- ${key}: ${JSON.stringify(value)}`;
+Call the \`prompts_list\` tool with optional \`search\` parameter to filter results.`
             }
           }
-          return {
-            content: [
-              {
-                type: "text",
-                text: `# Ticket: ${getResult.slug} [${statusBadge}]${startedInfo}${closedInfo}
-
-${getResult.content}${metadataInfo}
-
----
-_Read-only inspection. Use tickets_work to start working on this ticket._`
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] tickets_get error:`, error);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error getting ticket: ${errorMessage}`
-              }
-            ],
-            isError: true
-          };
-        }
-      } else if (ticketTool.type === "list") {
-        const { agent } = parseListArgs(request.params.arguments);
-        const resolvedAgent = resolveAgent(agent);
-        try {
-          const result = await convexClient.query(
-            "mcp_tickets:listMcpTickets",
+        ]
+      };
+    }
+    const runPromptMatch = promptName.match(/^prompts_run\s+(.+)$/);
+    if (promptName === "prompts_run" || runPromptMatch) {
+      if (runPromptMatch) {
+        const promptSlug = runPromptMatch[1].trim();
+        return {
+          description: `Execute prompt "${promptSlug}"`,
+          messages: [
             {
-              ...buildAuthArgs(config),
-              projectSlug: ticketTool.projectSlug,
-              agentId: resolvedAgent
-              // Agent filtering (implement-agent-routing)
-            }
-          );
-          const agentContext = resolvedAgent ? ` for agent "${resolvedAgent}"` : "";
-          if (result.length === 0) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `No active tickets${agentContext} in project "${ticketTool.projectSlug}". All tickets are closed or archived.`
-                }
-              ]
-            };
-          }
-          const openTickets = result.filter((t) => t.status === "open");
-          const workingTickets = result.filter((t) => t.status === "working");
-          const backlogTickets = result.filter((t) => t.status === "backlog");
-          const formatTicketLine = (t) => {
-            const num = t.ticketNumber ? `#${t.ticketNumber}` : "";
-            const agentBadge = !resolvedAgent && t.agentId ? ` [${t.agentId}]` : "";
-            return `  ${t.position}. ${num} ${t.slug}${agentBadge}
-     ${t.preview}`;
-          };
-          const sections = [];
-          if (openTickets.length > 0) {
-            sections.push(`**\u{1F7E2} Open (${openTickets.length})**
-${openTickets.map(formatTicketLine).join("\n")}`);
-          }
-          if (workingTickets.length > 0) {
-            sections.push(`**\u{1F7E1} Working (${workingTickets.length})**
-${workingTickets.map(formatTicketLine).join("\n")}`);
-          }
-          if (backlogTickets.length > 0) {
-            sections.push(`**\u26AA Backlog (${backlogTickets.length})**
-${backlogTickets.map(formatTicketLine).join("\n")}`);
-          }
-          const headerSuffix = resolvedAgent ? ` (Agent: ${resolvedAgent})` : "";
-          return {
-            content: [
-              {
+              role: "user",
+              content: {
                 type: "text",
-                text: `# Active Queue: ${ticketTool.projectSlug}${headerSuffix}
+                text: `Execute the "${promptSlug}" prompt.
 
-${result.length} ticket(s) in queue
-
-${sections.join("\n\n")}`
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] tickets_list error:`, error);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error listing tickets: ${errorMessage}`
-              }
-            ],
-            isError: true
-          };
-        }
-      } else if (ticketTool.type === "update") {
-        const parsedArgs = parseUpdateArgs(request.params.arguments);
-        if (!parsedArgs) {
-          const args = request.params.arguments;
-          const hasTicketSlug = typeof args?.ticketSlug === "string" && args.ticketSlug;
-          const hasContent = typeof args?.content === "string" && args.content;
-          if (!hasTicketSlug) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Error: Missing ticketSlug parameter. Provide a ticket number (e.g., "102") or full slug.`
-                }
-              ],
-              isError: true
-            };
-          }
-          if (!hasContent) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Error: Missing content parameter. Provide the update content to append to the ticket.`
-                }
-              ],
-              isError: true
-            };
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: Missing required parameters.`
+Call the \`prompts_run\` tool with slug: "${promptSlug}".`
               }
-            ],
-            isError: true
-          };
-        }
-        const { ticketSlug, content, agent } = parsedArgs;
-        try {
-          const result = await convexClient.mutation(
-            "mcp_tickets:updateMcpTicket",
-            {
-              ...buildAuthArgs(config),
-              projectSlug: ticketTool.projectSlug,
-              ticketSlug,
-              content,
-              // Agent reassignment (implement-agent-routing)
-              // Only include if explicitly provided (empty string = unassign)
-              ...agent !== void 0 && { agentId: agent }
             }
-          );
-          const agentInfo = result.agentId ? `
-Assigned to: ${result.agentId}` : agent === "" ? "\nAgent: Unassigned" : "";
-          return {
-            content: [
-              {
-                type: "text",
-                text: `\u2705 Ticket [${result.slug}] updated in project "${ticketTool.projectSlug}".${agentInfo}
-Updated at: ${new Date(result.updatedAt).toISOString()}
-_Ticket content has been appended with your update._`
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] tickets_update error:`, error);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error updating ticket: ${errorMessage}`
-              }
-            ],
-            isError: true
-          };
-        }
+          ]
+        };
       }
-    }
-    const memoryTool = dynamicMemoryTools.find((mt) => mt.name === toolName);
-    if (memoryTool) {
-      if (memoryTool.type === "load") {
-        const { query } = parseMemoriesLoadArgs(request.params.arguments);
-        try {
-          const result = await convexClient.query(
-            "mcp_memories:loadMemories",
-            {
-              ...buildAuthArgs(config),
-              projectSlug: memoryTool.projectSlug,
-              query
-            }
-          );
-          const sections = [];
-          if (result.userMemories.length > 0) {
-            const rulesText = result.userMemories.map((m, i) => `${i + 1}. ${m.content}`).join("\n");
-            sections.push(`## Rules (${result.userMemories.length})
-${rulesText}`);
-          } else {
-            sections.push(`## Rules
-_No rules defined. Create rules in the Memories page._`);
-          }
-          if (result.agentMemories.length > 0) {
-            const historyText = result.agentMemories.map((m) => {
-              const ticketRef = m.ticketNumber ? `[#${m.ticketNumber}]` : "";
-              const date = new Date(m.createdAt).toISOString().split("T")[0];
-              return `\u2022 ${ticketRef} ${m.content} _(${date})_`;
-            }).join("\n");
-            const searchNote = query ? ` matching "${query}"` : " (recent)";
-            sections.push(`## History${searchNote} (${result.agentMemories.length})
-${historyText}`);
-          } else {
-            const searchNote = query ? ` matching "${query}"` : "";
-            sections.push(`## History${searchNote}
-_No memories recorded yet._`);
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: `# Project Memories: ${memoryTool.projectSlug}
+      return {
+        description: "Execute a prompt by slug",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Execute a prompt by slug.
 
-${sections.join("\n\n")}`
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] memories_load error:`, error);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error loading memories: ${errorMessage}`
-              }
-            ],
-            isError: true
-          };
-        }
-      } else if (memoryTool.type === "load_extreme") {
-        const { query } = parseMemoriesLoadArgs(request.params.arguments);
-        try {
-          const result = await convexClient.query(
-            "mcp_memories:loadMemoriesExtreme",
-            {
-              ...buildAuthArgs(config),
-              projectSlug: memoryTool.projectSlug,
-              query
-            }
-          );
-          const lines = [];
-          lines.push(`# Project Memories: ${memoryTool.projectSlug}
-`);
-          lines.push(`## Rules (${result.userMemories.length})`);
-          if (result.userMemories.length > 0) {
-            result.userMemories.forEach((m, i) => {
-              lines.push(`${i + 1}. ${m.content}`);
-            });
-          } else {
-            lines.push(`_No rules defined. Create rules in the Memories page._`);
-          }
-          lines.push("");
-          const historyHeader = query ? `## History matching "${query}" (${result.agentMemories.length})` : `## Recent History (${result.agentMemories.length})`;
-          lines.push(historyHeader);
-          lines.push("");
-          for (const memory of result.agentMemories) {
-            lines.push("---");
-            lines.push(`**Memory:** ${memory.content}`);
-            if (memory.ticket) {
-              lines.push(`**Ticket:** #${memory.ticket.ticketNumber}-${memory.ticket.slug}`);
-            }
-            const date = new Date(memory.createdAt).toISOString().split("T")[0];
-            lines.push(`**Date:** ${date}`);
-            lines.push("");
-            if (memory.ticket) {
-              lines.push("<ticket-content>");
-              lines.push(memory.ticket.content);
-              lines.push("</ticket-content>");
-            } else {
-              lines.push("_(No linked ticket)_");
-            }
-            lines.push("");
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: lines.join("\n")
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] memories_load_extreme error:`, error);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error loading extreme memories: ${errorMessage}`
-              }
-            ],
-            isError: true
-          };
-        }
-      } else if (memoryTool.type === "add") {
-        const parsedArgs = parseMemoriesAddArgs(request.params.arguments);
-        if (!parsedArgs) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: Missing content parameter. Provide the memory content to record.`
-              }
-            ],
-            isError: true
-          };
-        }
-        const { content } = parsedArgs;
-        try {
-          const result = await convexClient.mutation(
-            "mcp_memories:addMemory",
-            {
-              ...buildAuthArgs(config),
-              projectSlug: memoryTool.projectSlug,
-              content
-            }
-          );
-          let responseText;
-          if (result.linkedTicket) {
-            const ticketRef = `#${result.linkedTicket.number}`;
-            const fallbackNote = result.linkedViaFallback ? " (recently closed)" : "";
-            responseText = `\u2705 Memory recorded for ticket [${ticketRef}]${fallbackNote} in project "${memoryTool.projectSlug}".
+## Usage
+Call the \`prompts_run\` tool with the prompt slug.
 
-_Memory will be available in future context via [MEMORY_LOAD]._`;
-          } else {
-            responseText = `\u2705 Memory recorded in project "${memoryTool.projectSlug}".
+## Available Prompts
+Use \`prompts_list\` to list all available prompts.
 
-_Memory created without ticket linkage (no working ticket or recent closed ticket)._
-_Memory will be available in future context via [MEMORY_LOAD]._`;
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: responseText
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] memories_add error:`, error);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error adding memory: ${errorMessage}`
-              }
-            ],
-            isError: true
-          };
-        }
-      } else if (memoryTool.type === "list_all") {
-        const parsedArgs = parseMemoriesListAllArgs(request.params.arguments);
-        try {
-          const result = await convexClient.query(
-            "mcp_memories:listAllMemories",
-            {
-              ...buildAuthArgs(config),
-              projectSlug: memoryTool.projectSlug,
-              typeFilter: parsedArgs.typeFilter
-            }
-          );
-          const formatDate = (ts) => new Date(ts).toISOString().split("T")[0];
-          const userMemories = result.memories.filter((m) => m.type === "user");
-          const agentMemories = result.memories.filter((m) => m.type === "agent");
-          let output = `# Project Memories (${result.totalCount} total)
+## Example
+/ppm:prompts_run code-review
 
-`;
-          if (userMemories.length > 0) {
-            output += `## Rules (${userMemories.length})
-`;
-            userMemories.forEach((m, i) => {
-              output += `${i + 1}. [${m.id}] ${m.content}
-`;
-            });
-            output += "\n";
-          }
-          if (agentMemories.length > 0) {
-            output += `## Agent History (${agentMemories.length})
-`;
-            agentMemories.forEach((m) => {
-              const ticketRef = m.ticketNumber ? ` [#${m.ticketNumber}]` : "";
-              output += `\u2022 [${m.id}]${ticketRef} ${m.content.substring(0, 100)}${m.content.length > 100 ? "..." : ""} _(${formatDate(m.createdAt)})_
-`;
-            });
+This will execute the "code-review" prompt.`
+            }
           }
-          return {
-            content: [{ type: "text", text: output }]
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.error(`[MCP] memories_list_all error:`, error);
-          return {
-            content: [{ type: "text", text: `Error listing memories: ${errorMessage}` }],
-            isError: true
-          };
-        }
+        ]
+      };
+    }
+    const userSlashCommand = slashCommandPrompts.find((p) => p.slug === promptName);
+    if (userSlashCommand) {
+      try {
+        const result = await fetchAndExecuteAccountScopedPrompt(
+          userSlashCommand.slug,
+          config,
+          convexClient
+        );
+        return {
+          description: userSlashCommand.description || `Execute "${userSlashCommand.slug}"`,
+          messages: result.messages.map((msg) => ({
+            role: msg.role,
+            content: { type: "text", text: msg.content.text }
+          }))
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Error executing slash command "${promptName}": ${errorMessage}`);
       }
     }
+    throw new Error(`Unknown prompt: ${promptName}. Use prompts_run to execute prompts.`);
+  });
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        // Ticket tools
+        ...ticketTools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        })),
+        // Prompt tools (global)
+        ...promptTools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        })),
+        // Memory tools
+        ...memoryTools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        })),
+        // Per-prompt tools
+        ...dynamicPromptTools.map((pt) => ({
+          name: pt.name,
+          description: pt.description,
+          inputSchema: { type: "object", properties: {}, required: [] }
+        }))
+      ]
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    const args = request.params.arguments;
+    if (toolName === "prompts_run") {
+      return handlePromptsRun(args, config, convexClient);
+    }
+    if (toolName === "prompts_list") {
+      return handlePromptsList(args, config, convexClient, accountScopedPrompts);
+    }
+    if (toolName === "prompts_update") {
+      return handlePromptsUpdate(args, config, convexClient);
+    }
+    if (toolName === "tickets_work") {
+      return handleTicketsWork(args, config, convexClient, projectSlug);
+    }
+    if (toolName === "tickets_create") {
+      return handleTicketsCreate(args, config, convexClient, projectSlug);
+    }
+    if (toolName === "tickets_close") {
+      return handleTicketsClose(args, config, convexClient, projectSlug);
+    }
+    if (toolName === "tickets_pause") {
+      return handleTicketsPause(args, config, convexClient, projectSlug);
+    }
+    if (toolName === "tickets_search") {
+      return handleTicketsSearch(args, config, convexClient, projectSlug);
+    }
+    if (toolName === "tickets_get") {
+      return handleTicketsGet(args, config, convexClient, projectSlug);
+    }
+    if (toolName === "tickets_list") {
+      return handleTicketsList(args, config, convexClient, projectSlug);
+    }
+    if (toolName === "tickets_update") {
+      return handleTicketsUpdate(args, config, convexClient, projectSlug);
+    }
+    if (toolName === "memories_load") {
+      return handleMemoriesLoad(args, config, convexClient, projectSlug);
+    }
+    if (toolName === "memories_load_extreme") {
+      return handleMemoriesLoadExtreme(args, config, convexClient, projectSlug);
+    }
+    if (toolName === "memories_add") {
+      return handleMemoriesAdd(args, config, convexClient, projectSlug);
+    }
+    if (toolName === "memories_list_all") {
+      return handleMemoriesListAll(args, config, convexClient, projectSlug);
+    }
     const promptTool = dynamicPromptTools.find((pt) => pt.name === toolName);
     if (promptTool) {
       try {
@@ -1844,9 +1691,7 @@ _Memory will be available in future context via [MEMORY_LOAD]._`;
           convexClient
         );
         const promptText = result.messages.map((msg) => msg.content.text).join("\n\n");
-        return {
-          content: [{ type: "text", text: promptText }]
-        };
+        return { content: [{ type: "text", text: promptText }] };
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
         console.error(`[MCP] ${toolName} error:`, error);
@@ -1856,7 +1701,15 @@ _Memory will be available in future context via [MEMORY_LOAD]._`;
         };
       }
     }
-    throw new Error(`Unknown tool: ${toolName}. Use prompts_run to execute prompts by name, or check available tools.`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Unknown tool: ${toolName}. Use prompts_run to execute prompts by name, or check available tools.`
+        }
+      ],
+      isError: true
+    };
   });
   const transport = new StdioServerTransport();
   await server.connect(transport);
@@ -1872,28 +1725,63 @@ _Memory will be available in future context via [MEMORY_LOAD]._`;
   return new Promise(() => {
   });
 }
-async function validateProjectToken(client, token) {
-  try {
-    const typedClient = client;
-    const result = await typedClient.query(
-      "projects:validateProjectToken",
-      { token }
-    );
-    if (result && result.valid) {
-      return {
-        valid: true,
-        projectId: result.projectId,
-        projectSlug: result.projectSlug,
-        ownerId: result.ownerId
-      };
-    }
-    return { valid: false, error: "Invalid project token" };
-  } catch (error) {
-    return {
-      valid: false,
-      error: error instanceof Error ? error.message : "Unknown error"
-    };
+function buildTicketPromptResponse(type, toolName, projectSlug) {
+  let promptContent;
+  let description;
+  if (type === "work") {
+    description = `Get work from the "${projectSlug}" project`;
+    promptContent = `Get work from the "${projectSlug}" project.
+
+Call the \`tickets_work\` tool to get the next ticket from the open queue.
+
+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 (type === "create") {
+    description = `Create a new ticket in "${projectSlug}"`;
+    promptContent = `Create a new ticket in the "${projectSlug}" project queue.
+
+## How This Works
+The user provides **instructions** (not raw content). You interpret those instructions to generate the ticket.
+
+## Instructions
+1. **Read the user's request** - they may reference a file, ask you to summarize a session, or describe what they want
+2. **Process the input** - read files, extract relevant sections, summarize as needed
+3. **Generate ticket content** with a clear, descriptive title as the first line
+4. **Call the tool** with the generated content
+
+## Content Format
+\`\`\`
+[Clear descriptive title - this becomes the slug]
+
+[Body content - tasks, description, context, etc.]
+\`\`\`
+
+## Examples
+- "create a ticket from /path/to/plan.md" \u2192 Read file, use as ticket content
+- "summarize our brainstorm into a ticket" \u2192 Extract key points from conversation
+- "create a ticket for the auth bug we discussed" \u2192 Generate from session context
+- "just the tasks from this file" \u2192 Extract only task items
+
+Call the \`${toolName}\` tool with the final generated content.`;
+  } else if (type === "close") {
+    description = `Close a working ticket in "${projectSlug}"`;
+    promptContent = `Close a working ticket in the "${projectSlug}" project.
+
+Call the \`${toolName}\` tool with the ticket number or slug.`;
+  } else {
+    description = `Use the ${toolName} tool`;
+    promptContent = `Use the \`${toolName}\` tool.`;
   }
+  return {
+    description,
+    messages: [
+      {
+        role: "user",
+        content: { type: "text", text: promptContent }
+      }
+    ]
+  };
 }
 
 // src/index.ts