@vibescope/mcp-server 0.1.0 → 0.2.1

package/dist/handlers/tasks.js

@@ -15,8 +15,82 @@
  * - add_subtask
  * - get_subtasks
  */
-import { validateRequired, validateUUID, validateTaskStatus, validatePriority, validateProgressPercentage, validateEstimatedMinutes, ValidationError, } from '../validators.js';
+import { parseArgs, uuidValidator, taskStatusValidator, priorityValidator, progressValidator, minutesValidator, createEnumValidator, ValidationError, } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+// Valid task types
+const VALID_TASK_TYPES = [
+    'frontend', 'backend', 'database', 'feature', 'bugfix',
+    'design', 'mcp', 'testing', 'docs', 'infra', 'other'
+];
+// ============================================================================
+// Argument Schemas
+// ============================================================================
+const getTasksSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', validate: taskStatusValidator },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+    search_query: { type: 'string' },
+    include_subtasks: { type: 'boolean', default: false },
+    include_metadata: { type: 'boolean', default: false },
+};
+const getNextTaskSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const addTaskSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    priority: { type: 'number', default: 3, validate: priorityValidator },
+    estimated_minutes: { type: 'number', validate: minutesValidator },
+    blocking: { type: 'boolean', default: false },
+    task_type: { type: 'string', validate: createEnumValidator(VALID_TASK_TYPES) },
+};
+const updateTaskSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string' },
+    description: { type: 'string' },
+    priority: { type: 'number', validate: priorityValidator },
+    status: { type: 'string', validate: taskStatusValidator },
+    progress_percentage: { type: 'number', validate: progressValidator },
+    progress_note: { type: 'string' },
+    estimated_minutes: { type: 'number', validate: minutesValidator },
+    git_branch: { type: 'string' },
+    task_type: { type: 'string', validate: createEnumValidator(VALID_TASK_TYPES) },
+};
+const completeTaskSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    summary: { type: 'string' },
+};
+const deleteTaskSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const addTaskReferenceSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    url: { type: 'string', required: true },
+    label: { type: 'string' },
+};
+const removeTaskReferenceSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    url: { type: 'string', required: true },
+};
+const batchUpdateTasksSchema = {
+    updates: { type: 'array', required: true },
+};
+const batchCompleteTasksSchema = {
+    completions: { type: 'array', required: true },
+};
+const addSubtaskSchema = {
+    parent_task_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    priority: { type: 'number', validate: priorityValidator },
+    estimated_minutes: { type: 'number', validate: minutesValidator },
+};
+const getSubtasksSchema = {
+    parent_task_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', validate: taskStatusValidator },
+};
 function getTaskCompleteGitInstructions(gitWorkflow, gitMainBranch, gitDevelopBranch, taskBranch, taskTitle, taskId) {
     if (gitWorkflow === 'none') {
         return undefined;
@@ -68,14 +142,11 @@ export function getValidationApprovedGitInstructions(config, taskBranch) {
 // Task Handlers - Using API Client
 // ============================================================================
 export const getTasks = async (args, ctx) => {
-    const { project_id, status, limit = 50, offset = 0, search_query, include_subtasks = false, include_metadata = false } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateTaskStatus(status);
+    const { project_id, status, limit, offset, search_query, include_subtasks, include_metadata } = parseArgs(args, getTasksSchema);
     const api = getApiClient();
     const response = await api.getTasks(project_id, {
         status,
-        limit: Math.min(limit, 200),
+        limit: Math.min(limit ?? 50, 200),
         offset,
         include_subtasks,
         search_query,
@@ -93,9 +164,7 @@ export const getTasks = async (args, ctx) => {
     };
 };
 export const getNextTask = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id } = parseArgs(args, getNextTaskSchema);
     const api = getApiClient();
     const response = await api.getNextTask(project_id, ctx.session.currentSessionId || undefined);
     if (!response.ok) {
@@ -138,12 +207,7 @@ export const getNextTask = async (args, ctx) => {
     return { result };
 };
 export const addTask = async (args, ctx) => {
-    const { project_id, title, description, priority = 3, estimated_minutes, blocking = false, task_type } = args;
-    validateRequired(project_id, 'project_id');
-    validateRequired(title, 'title');
-    validateUUID(project_id, 'project_id');
-    validatePriority(priority);
-    validateEstimatedMinutes(estimated_minutes);
+    const { project_id, title, description, priority, estimated_minutes, blocking, task_type } = parseArgs(args, addTaskSchema);
     const api = getApiClient();
     const response = await api.createTask(project_id, {
         title,
@@ -152,6 +216,7 @@ export const addTask = async (args, ctx) => {
         estimated_minutes,
         blocking,
         session_id: ctx.session.currentSessionId || undefined,
+        task_type,
     });
     if (!response.ok) {
         throw new Error(`Failed to add task: ${response.error}`);
@@ -169,13 +234,8 @@ export const addTask = async (args, ctx) => {
     return { result };
 };
 export const updateTask = async (args, ctx) => {
-    const { task_id, progress_note, ...updates } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    validateTaskStatus(updates.status);
-    validatePriority(updates.priority);
-    validateProgressPercentage(updates.progress_percentage);
-    validateEstimatedMinutes(updates.estimated_minutes);
+    const { task_id, title, description, priority, status, progress_percentage, progress_note, estimated_minutes, git_branch, task_type } = parseArgs(args, updateTaskSchema);
+    const updates = { title, description, priority, status, progress_percentage, estimated_minutes, git_branch, task_type };
     const api = getApiClient();
     const response = await api.updateTask(task_id, {
         ...updates,
@@ -208,14 +268,39 @@ export const updateTask = async (args, ctx) => {
                 },
             };
         }
+        if (response.error?.includes('branch_conflict')) {
+            return {
+                result: {
+                    error: 'branch_conflict',
+                    message: response.error,
+                    conflicting_task_id: response.data?.conflicting_task_id,
+                    conflicting_task_title: response.data?.conflicting_task_title,
+                },
+            };
+        }
         throw new Error(`Failed to update task: ${response.error}`);
     }
-    return { result: { success: true, task_id } };
+    // Build result - include git workflow info when transitioning to in_progress
+    const data = response.data;
+    const result = { success: true, task_id };
+    if (data?.git_workflow) {
+        result.git_workflow = data.git_workflow;
+    }
+    if (data?.worktree_setup) {
+        result.worktree_setup = data.worktree_setup;
+    }
+    if (data?.next_step) {
+        result.next_step = data.next_step;
+    }
+    // Warn if transitioning to in_progress without git_branch
+    if (updates.status === 'in_progress' && !updates.git_branch) {
+        result.warning = 'git_branch not set. For multi-agent collaboration, set git_branch when marking in_progress to track your worktree.';
+        result.hint = 'Call update_task again with git_branch parameter after creating your worktree.';
+    }
+    return { result };
 };
 export const completeTask = async (args, ctx) => {
-    const { task_id, summary } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
+    const { task_id, summary } = parseArgs(args, completeTaskSchema);
     const api = getApiClient();
     const response = await api.completeTask(task_id, {
         summary,
@@ -239,15 +324,17 @@ export const completeTask = async (args, ctx) => {
     if (data.context) {
         result.context = data.context;
     }
+    // Pass through warnings (e.g., missing git_branch)
+    if (data.warnings) {
+        result.warnings = data.warnings;
+    }
     // Git workflow instructions are already in API response but we need to fetch
     // task details if we want to include them (API should return these)
     result.next_action = data.next_action;
     return { result };
 };
 export const deleteTask = async (args, ctx) => {
-    const { task_id } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
+    const { task_id } = parseArgs(args, deleteTaskSchema);
     const api = getApiClient();
     const response = await api.deleteTask(task_id);
     if (!response.ok) {
@@ -256,10 +343,7 @@ export const deleteTask = async (args, ctx) => {
     return { result: { success: true, deleted_id: task_id } };
 };
 export const addTaskReference = async (args, ctx) => {
-    const { task_id, url, label } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    validateRequired(url, 'url');
+    const { task_id, url, label } = parseArgs(args, addTaskReferenceSchema);
     const api = getApiClient();
     const response = await api.addTaskReference(task_id, url, label);
     if (!response.ok) {
@@ -276,10 +360,7 @@ export const addTaskReference = async (args, ctx) => {
     };
 };
 export const removeTaskReference = async (args, ctx) => {
-    const { task_id, url } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    validateRequired(url, 'url');
+    const { task_id, url } = parseArgs(args, removeTaskReferenceSchema);
     const api = getApiClient();
     const response = await api.removeTaskReference(task_id, url);
     if (!response.ok) {
@@ -291,61 +372,52 @@ export const removeTaskReference = async (args, ctx) => {
     return { result: { success: true } };
 };
 export const batchUpdateTasks = async (args, ctx) => {
-    const { updates } = args;
-    if (!updates || !Array.isArray(updates) || updates.length === 0) {
+    const { updates } = parseArgs(args, batchUpdateTasksSchema);
+    const typedUpdates = updates;
+    if (!Array.isArray(typedUpdates) || typedUpdates.length === 0) {
         throw new ValidationError('updates must be a non-empty array', {
             field: 'updates',
             hint: 'Provide an array of task updates with at least one item',
         });
     }
-    if (updates.length > 50) {
+    if (typedUpdates.length > 50) {
         throw new ValidationError('Too many updates. Maximum is 50 per batch.', {
             field: 'updates',
             hint: 'Split your updates into smaller batches',
         });
     }
-    // Validate all inputs first
-    for (const update of updates) {
-        validateRequired(update.task_id, 'task_id');
-        validateUUID(update.task_id, 'task_id');
-        validateTaskStatus(update.status);
-        validatePriority(update.priority);
-        validateProgressPercentage(update.progress_percentage);
-    }
+    // Individual item validation happens at API level
     const api = getApiClient();
-    const response = await api.batchUpdateTasks(updates);
+    const response = await api.batchUpdateTasks(typedUpdates);
     if (!response.ok) {
         throw new Error(`Failed to batch update tasks: ${response.error}`);
     }
     return {
         result: {
             success: response.data?.success || false,
-            total: updates.length,
+            total: typedUpdates.length,
             succeeded: response.data?.updated_count || 0,
         },
     };
 };
 export const batchCompleteTasks = async (args, ctx) => {
-    const { completions } = args;
-    if (!completions || !Array.isArray(completions) || completions.length === 0) {
+    const { completions } = parseArgs(args, batchCompleteTasksSchema);
+    const typedCompletions = completions;
+    if (!Array.isArray(typedCompletions) || typedCompletions.length === 0) {
         throw new ValidationError('completions must be a non-empty array', {
             field: 'completions',
             hint: 'Provide an array of task completions with at least one item',
         });
     }
-    if (completions.length > 50) {
+    if (typedCompletions.length > 50) {
         throw new ValidationError('Too many completions. Maximum is 50 per batch.', {
             field: 'completions',
             hint: 'Split your completions into smaller batches',
         });
     }
-    // Validate all inputs first
-    for (const completion of completions) {
-        validateRequired(completion.task_id, 'task_id');
-        validateUUID(completion.task_id, 'task_id');
-    }
+    // Individual item validation happens at API level
     const api = getApiClient();
-    const response = await api.batchCompleteTasks(completions);
+    const response = await api.batchCompleteTasks(typedCompletions);
     if (!response.ok) {
         throw new Error(`Failed to batch complete tasks: ${response.error}`);
     }
@@ -353,9 +425,9 @@ export const batchCompleteTasks = async (args, ctx) => {
     return {
         result: {
             success: data?.success || false,
-            total: completions.length,
+            total: typedCompletions.length,
             succeeded: data?.completed_count || 0,
-            failed: completions.length - (data?.completed_count || 0),
+            failed: typedCompletions.length - (data?.completed_count || 0),
             next_task: data?.next_task,
         },
     };
@@ -364,14 +436,7 @@ export const batchCompleteTasks = async (args, ctx) => {
 // Subtask Handlers
 // ============================================================================
 export const addSubtask = async (args, ctx) => {
-    const { parent_task_id, title, description, priority, estimated_minutes } = args;
-    validateRequired(parent_task_id, 'parent_task_id');
-    validateUUID(parent_task_id, 'parent_task_id');
-    validateRequired(title, 'title');
-    if (priority !== undefined)
-        validatePriority(priority);
-    if (estimated_minutes !== undefined)
-        validateEstimatedMinutes(estimated_minutes);
+    const { parent_task_id, title, description, priority, estimated_minutes } = parseArgs(args, addSubtaskSchema);
     const api = getApiClient();
     const response = await api.addSubtask(parent_task_id, {
         title,
@@ -400,11 +465,7 @@ export const addSubtask = async (args, ctx) => {
     };
 };
 export const getSubtasks = async (args, ctx) => {
-    const { parent_task_id, status } = args;
-    validateRequired(parent_task_id, 'parent_task_id');
-    validateUUID(parent_task_id, 'parent_task_id');
-    if (status)
-        validateTaskStatus(status);
+    const { parent_task_id, status } = parseArgs(args, getSubtasksSchema);
     const api = getApiClient();
     const response = await api.getSubtasks(parent_task_id, status);
     if (!response.ok) {

package/dist/handlers/tool-docs.d.ts

@@ -1,8 +1,9 @@
 /**
  * Tool Documentation
  *
- * This file contains detailed documentation for all MCP tools.
- * It is loaded dynamically by get_tool_info to reduce memory footprint
- * when tool documentation is not needed.
+ * Externalized documentation for all MCP tools.
+ * This file is lazy-loaded by get_tool_info to save tokens.
+ *
+ * Token savings: ~8,000 tokens per schema load when this isn't bundled.
  */
 export declare const TOOL_INFO: Record<string, string>;

package/dist/handlers/tool-docs.js

@@ -1,9 +1,10 @@
 /**
  * Tool Documentation
  *
- * This file contains detailed documentation for all MCP tools.
- * It is loaded dynamically by get_tool_info to reduce memory footprint
- * when tool documentation is not needed.
+ * Externalized documentation for all MCP tools.
+ * This file is lazy-loaded by get_tool_info to save tokens.
+ *
+ * Token savings: ~8,000 tokens per schema load when this isn't bundled.
  */
 export const TOOL_INFO = {
     start_work_session: `# start_work_session
@@ -32,7 +33,8 @@ Get token usage statistics for current session.
 Send heartbeat to maintain active status. Call every 30-60 seconds.
 
 **Parameters:**
-- session_id (optional): Uses current session if not provided`,
+- session_id (optional): Uses current session if not provided
+- current_worktree_path (optional): Report your current git worktree path (e.g., "../project-task-abc123")`,
     end_work_session: `# end_work_session
 End session and release claimed tasks.
 
@@ -629,7 +631,252 @@ Get cost breakdown by task for a project.
 - limit: Max tasks to return (default: 20)
 
 **Returns:** Tasks sorted by estimated cost with model breakdown`,
-    // Knowledge base tools
+    // Subtasks
+    add_subtask: `# add_subtask
+Add a subtask to break down a larger task.
+
+**Parameters:**
+- parent_task_id (required): UUID of the parent task
+- title (required): Subtask title
+- description (optional): Detailed description
+- priority (optional): 1-5 (defaults to parent priority)
+- estimated_minutes (optional): Time estimate
+
+**Note:** Max depth is 1 (subtasks cannot have their own subtasks).`,
+    get_subtasks: `# get_subtasks
+Get subtasks for a parent task.
+
+**Parameters:**
+- parent_task_id (required): UUID of the parent task
+- status (optional): Filter by status
+
+**Returns:** Subtasks with aggregate completion stats.`,
+    // Bodies of work
+    create_body_of_work: `# create_body_of_work
+Create a new body of work to group tasks into phases.
+
+**Parameters:**
+- project_id (required): Project UUID
+- title (required): Title for the body of work
+- description (optional): Description
+- auto_deploy_on_completion (optional): Auto-deploy when all tasks complete (default: false)
+- deploy_environment (optional): Target environment (default: production)
+- deploy_version_bump (optional): Version bump (default: minor)
+- deploy_trigger (optional): When to trigger auto-deploy (default: all_completed_validated)`,
+    update_body_of_work: `# update_body_of_work
+Update a body of work's settings.
+
+**Parameters:**
+- body_of_work_id (required): Body of work UUID
+- title, description (optional)
+- auto_deploy_on_completion, deploy_environment, deploy_version_bump, deploy_trigger (optional)`,
+    get_body_of_work: `# get_body_of_work
+Get a body of work with all its tasks organized by phase.
+
+**Parameters:**
+- body_of_work_id (required): Body of work UUID
+
+**Returns:** Body of work with tasks grouped by pre/core/post phases.`,
+    get_bodies_of_work: `# get_bodies_of_work
+List bodies of work for a project.
+
+**Parameters:**
+- project_id (required): Project UUID
+- status (optional): Filter by status (draft, active, completed, cancelled)
+- limit (optional): Max items (default 50)`,
+    delete_body_of_work: `# delete_body_of_work
+Delete a body of work. Tasks are preserved but no longer grouped.
+
+**Parameters:**
+- body_of_work_id (required): Body of work UUID`,
+    add_task_to_body_of_work: `# add_task_to_body_of_work
+Add a task to a body of work in a specific phase.
+
+**Parameters:**
+- body_of_work_id (required): Body of work UUID
+- task_id (required): Task UUID to add
+- phase (optional): pre, core, or post (default: core)
+- order_index (optional): Order within phase`,
+    remove_task_from_body_of_work: `# remove_task_from_body_of_work
+Remove a task from its body of work.
+
+**Parameters:**
+- task_id (required): Task UUID to remove
+
+**Note:** The task is preserved, just no longer grouped.`,
+    activate_body_of_work: `# activate_body_of_work
+Activate a draft body of work to start execution.
+
+**Parameters:**
+- body_of_work_id (required): Body of work UUID
+
+**Note:** Requires at least one task. Once active, tasks follow phase order.`,
+    add_task_dependency: `# add_task_dependency
+Add a dependency between tasks in a body of work.
+
+**Parameters:**
+- body_of_work_id (required): Body of work UUID
+- task_id (required): Task that depends on another
+- depends_on_task_id (required): Task that must complete first
+
+**Note:** Prevents circular dependencies.`,
+    remove_task_dependency: `# remove_task_dependency
+Remove a dependency between tasks.
+
+**Parameters:**
+- task_id (required): Task UUID
+- depends_on_task_id (required): Dependency task UUID`,
+    get_task_dependencies: `# get_task_dependencies
+Get task dependencies for a body of work or specific task.
+
+**Parameters:**
+- body_of_work_id (optional): Body of work UUID
+- task_id (optional): Specific task UUID`,
+    get_next_body_of_work_task: `# get_next_body_of_work_task
+Get the next available task from a body of work.
+
+**Parameters:**
+- body_of_work_id (required): Body of work UUID
+
+**Note:** Considers phase order (pre → core → post) and dependencies.`,
+    // Sprints
+    create_sprint: `# create_sprint
+Create a new sprint with time bounds and velocity tracking.
+
+**Parameters:**
+- project_id (required): Project UUID
+- title (required): Sprint title (e.g., "Sprint 5")
+- start_date (required): Start date (YYYY-MM-DD)
+- end_date (required): End date (YYYY-MM-DD)
+- goal (optional): Sprint goal statement
+- auto_deploy_on_completion, deploy_environment, deploy_version_bump (optional)`,
+    update_sprint: `# update_sprint
+Update a sprint's details.
+
+**Parameters:**
+- sprint_id (required): Sprint UUID
+- title, goal, start_date, end_date (optional)
+- auto_deploy_on_completion, deploy_environment, deploy_version_bump (optional)`,
+    get_sprint: `# get_sprint
+Get a sprint with all its tasks organized by phase.
+
+**Parameters:**
+- sprint_id (required): Sprint UUID
+
+**Returns:** Sprint with progress percentage, velocity points, committed points.`,
+    get_sprints: `# get_sprints
+List sprints for a project with velocity metrics.
+
+**Parameters:**
+- project_id (required): Project UUID
+- status (optional): planning, active, in_review, retrospective, completed, cancelled
+- limit (optional): Max sprints (default 20)`,
+    delete_sprint: `# delete_sprint
+Delete a sprint. Tasks are preserved but no longer grouped.
+
+**Parameters:**
+- sprint_id (required): Sprint UUID`,
+    start_sprint: `# start_sprint
+Start a sprint. Transitions from 'planning' to 'active'.
+
+**Parameters:**
+- sprint_id (required): Sprint UUID
+
+**Note:** Locks committed_points at current total story points.`,
+    complete_sprint: `# complete_sprint
+Complete a sprint. Handles retrospective phase and auto-deployment.
+
+**Parameters:**
+- sprint_id (required): Sprint UUID
+- retrospective_notes (optional): Sprint retrospective notes
+- skip_retrospective (optional): Skip retrospective phase (default: false)`,
+    add_task_to_sprint: `# add_task_to_sprint
+Add a task to a sprint with optional story points.
+
+**Parameters:**
+- sprint_id (required): Sprint UUID
+- task_id (required): Task UUID to add
+- story_points (optional): Story point estimate
+- phase (optional): pre, core, or post (default: core)`,
+    remove_task_from_sprint: `# remove_task_from_sprint
+Remove a task from a sprint.
+
+**Parameters:**
+- sprint_id (required): Sprint UUID
+- task_id (required): Task UUID to remove
+
+**Note:** Task returns to backlog.`,
+    get_sprint_backlog: `# get_sprint_backlog
+Get tasks that can be added to a sprint.
+
+**Parameters:**
+- project_id (required): Project UUID
+- sprint_id (optional): Exclude tasks already in this sprint
+
+**Returns:** Tasks not assigned to any body of work or sprint.`,
+    get_sprint_velocity: `# get_sprint_velocity
+Get velocity metrics for completed sprints.
+
+**Parameters:**
+- project_id (required): Project UUID
+- limit (optional): Number of sprints to analyze (default 10)
+
+**Returns:** Committed vs completed points, average velocity.`,
+    // Git issues
+    add_git_issue: `# add_git_issue
+Record a git-related issue (merge conflict, push failure, etc.).
+
+**Parameters:**
+- project_id (required): Project UUID
+- issue_type (required): merge_conflict, push_failed, rebase_needed, branch_diverged, pr_not_mergeable
+- branch (required): Branch where the issue occurred
+- target_branch, conflicting_files, error_message, pr_url, task_id (optional)`,
+    resolve_git_issue: `# resolve_git_issue
+Mark a git issue as resolved.
+
+**Parameters:**
+- git_issue_id (required): Git issue UUID
+- resolution_note (optional): How the issue was resolved
+- auto_resolved (optional): Whether auto-resolved`,
+    get_git_issues: `# get_git_issues
+Get git issues for a project.
+
+**Parameters:**
+- project_id (required): Project UUID
+- status (optional): open or resolved (default: open)
+- issue_type (optional): Filter by issue type
+- branch (optional): Filter by branch
+- limit (optional): Max issues (default 50)`,
+    delete_git_issue: `# delete_git_issue
+Delete a git issue.
+
+**Parameters:**
+- git_issue_id (required): Git issue UUID`,
+    // Deployment requirements
+    add_deployment_requirement: `# add_deployment_requirement
+Add a pre-deployment requirement.
+
+**Parameters:**
+- project_id (required): Project UUID
+- type (required): migration, env_var, config, manual, breaking_change, agent_task
+- title (required): Brief description
+- description (optional): Detailed instructions
+- stage (optional): preparation, deployment, or verification (default: preparation)
+- file_path (optional): File path reference
+- blocking (optional): Whether converted task blocks other work`,
+    complete_deployment_requirement: `# complete_deployment_requirement
+Mark a deployment requirement as completed.
+
+**Parameters:**
+- requirement_id (required): Requirement UUID`,
+    get_deployment_requirements: `# get_deployment_requirements
+Get pending deployment requirements.
+
+**Parameters:**
+- project_id (required): Project UUID
+- stage (optional): preparation, deployment, verification, or all
+- status (optional): pending, completed, converted_to_task, or all (default: pending)`,
+    // Knowledge base
     query_knowledge_base: `# query_knowledge_base
 Query aggregated project knowledge in a single call. Reduces token usage by combining multiple data sources.