@vibescope/mcp-server 0.2.0 → 0.2.2

package/dist/handlers/deployment.js

@@ -13,21 +13,105 @@
  * - complete_deployment_requirement
  * - get_deployment_requirements
  */
-import { ValidationError, validateRequired, validateUUID, validateEnvironment, } from '../validators.js';
+import { ValidationError, parseArgs, uuidValidator, createEnumValidator, } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+const ENVIRONMENTS = ['development', 'staging', 'production'];
+const VERSION_BUMPS = ['patch', 'minor', 'major'];
+const REQUIREMENT_TYPES = ['migration', 'env_var', 'config', 'manual', 'breaking_change', 'agent_task'];
+const REQUIREMENT_STAGES = ['preparation', 'deployment', 'verification'];
+const REQUIREMENT_STATUSES = ['pending', 'completed', 'converted_to_task', 'all'];
+const SCHEDULE_TYPES = ['once', 'hourly', 'daily', 'weekly', 'monthly'];
+// ============================================================================
+// Argument Schemas
+// ============================================================================
+const requestDeploymentSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    environment: { type: 'string', default: 'production', validate: createEnumValidator(ENVIRONMENTS) },
+    version_bump: { type: 'string', default: 'patch', validate: createEnumValidator(VERSION_BUMPS) },
+    notes: { type: 'string' },
+    git_ref: { type: 'string' },
+};
+const claimDeploymentValidationSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const reportValidationSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    build_passed: { type: 'boolean', required: true },
+    tests_passed: { type: 'boolean' },
+    error_message: { type: 'string' },
+};
+const checkDeploymentStatusSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const startDeploymentSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const completeDeploymentSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    success: { type: 'boolean', required: true },
+    summary: { type: 'string' },
+};
+const cancelDeploymentSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    reason: { type: 'string' },
+};
+const addDeploymentRequirementSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    type: { type: 'string', required: true, validate: createEnumValidator(REQUIREMENT_TYPES) },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    file_path: { type: 'string' },
+    stage: { type: 'string', default: 'preparation', validate: createEnumValidator(REQUIREMENT_STAGES) },
+    blocking: { type: 'boolean', default: false },
+    recurring: { type: 'boolean', default: false },
+};
+const completeDeploymentRequirementSchema = {
+    requirement_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const getDeploymentRequirementsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', default: 'pending', validate: createEnumValidator(REQUIREMENT_STATUSES) },
+    stage: { type: 'string', validate: createEnumValidator([...REQUIREMENT_STAGES, 'all']) },
+};
+const scheduleDeploymentSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    environment: { type: 'string', default: 'production', validate: createEnumValidator(ENVIRONMENTS) },
+    version_bump: { type: 'string', default: 'patch', validate: createEnumValidator(VERSION_BUMPS) },
+    schedule_type: { type: 'string', default: 'once', validate: createEnumValidator(SCHEDULE_TYPES) },
+    scheduled_at: { type: 'string', required: true },
+    auto_trigger: { type: 'boolean', default: true },
+    hours_interval: { type: 'number', default: 1 },
+    notes: { type: 'string' },
+    git_ref: { type: 'string' },
+};
+const getScheduledDeploymentsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    include_disabled: { type: 'boolean', default: false },
+};
+const updateScheduledDeploymentSchema = {
+    schedule_id: { type: 'string', required: true, validate: uuidValidator },
+    environment: { type: 'string', validate: createEnumValidator(ENVIRONMENTS) },
+    version_bump: { type: 'string', validate: createEnumValidator(VERSION_BUMPS) },
+    schedule_type: { type: 'string', validate: createEnumValidator(SCHEDULE_TYPES) },
+    scheduled_at: { type: 'string' },
+    auto_trigger: { type: 'boolean' },
+    hours_interval: { type: 'number' },
+    enabled: { type: 'boolean' },
+    notes: { type: 'string' },
+    git_ref: { type: 'string' },
+};
+const deleteScheduledDeploymentSchema = {
+    schedule_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const triggerScheduledDeploymentSchema = {
+    schedule_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const checkDueDeploymentsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
 export const requestDeployment = async (args, ctx) => {
-    const { project_id, environment = 'production', version_bump = 'patch', notes, git_ref } = args;
+    const { project_id, environment, version_bump, notes, git_ref } = parseArgs(args, requestDeploymentSchema);
     const { session } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateEnvironment(environment);
-    if (version_bump && !['patch', 'minor', 'major'].includes(version_bump)) {
-        throw new ValidationError('Invalid version_bump value', {
-            field: 'version_bump',
-            validValues: ['patch', 'minor', 'major'],
-            hint: 'Must be one of: patch, minor, major',
-        });
-    }
     const apiClient = getApiClient();
     const response = await apiClient.requestDeployment(project_id, {
         environment,
@@ -36,33 +120,23 @@ export const requestDeployment = async (args, ctx) => {
         git_ref
     });
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to request deployment');
+        return { result: { error: response.error || 'Failed to request deployment' }, isError: true };
     }
     return { result: response.data };
 };
 export const claimDeploymentValidation = async (args, ctx) => {
-    const { project_id } = args;
+    const { project_id } = parseArgs(args, claimDeploymentValidationSchema);
     const { session } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
     const apiClient = getApiClient();
     const response = await apiClient.claimDeploymentValidation(project_id, session.currentSessionId || undefined);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to claim deployment validation');
+        return { result: { error: response.error || 'Failed to claim deployment validation' }, isError: true };
     }
     return { result: response.data };
 };
 export const reportValidation = async (args, ctx) => {
-    const { project_id, build_passed, tests_passed, error_message } = args;
+    const { project_id, build_passed, tests_passed, error_message } = parseArgs(args, reportValidationSchema);
     const { session } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    if (build_passed === undefined) {
-        throw new ValidationError('build_passed is required', {
-            field: 'build_passed',
-            hint: 'Set to true if the build succeeded, false otherwise',
-        });
-    }
     const apiClient = getApiClient();
     const response = await apiClient.reportValidation(project_id, {
         build_passed,
@@ -70,79 +144,53 @@ export const reportValidation = async (args, ctx) => {
         error_message
     });
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to report validation');
+        return { result: { error: response.error || 'Failed to report validation' }, isError: true };
     }
     return { result: response.data };
 };
 export const checkDeploymentStatus = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id } = parseArgs(args, checkDeploymentStatusSchema);
     const apiClient = getApiClient();
     const response = await apiClient.checkDeploymentStatus(project_id);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to check deployment status');
+        return { result: { error: response.error || 'Failed to check deployment status' }, isError: true };
     }
     return { result: response.data };
 };
 export const startDeployment = async (args, ctx) => {
-    const { project_id } = args;
+    const { project_id } = parseArgs(args, startDeploymentSchema);
     const { session } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
     const apiClient = getApiClient();
     const response = await apiClient.startDeployment(project_id, session.currentSessionId || undefined);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to start deployment');
+        return { result: { error: response.error || 'Failed to start deployment' }, isError: true };
     }
     return { result: response.data };
 };
 export const completeDeployment = async (args, ctx) => {
-    const { project_id, success, summary } = args;
+    const { project_id, success, summary } = parseArgs(args, completeDeploymentSchema);
     const { session } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    if (success === undefined) {
-        throw new ValidationError('success is required', {
-            field: 'success',
-            hint: 'Set to true if deployment succeeded, false otherwise',
-        });
-    }
     const apiClient = getApiClient();
     const response = await apiClient.completeDeployment(project_id, {
         success,
         summary
     });
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to complete deployment');
+        return { result: { error: response.error || 'Failed to complete deployment' }, isError: true };
     }
     return { result: response.data };
 };
 export const cancelDeployment = async (args, ctx) => {
-    const { project_id, reason } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id, reason } = parseArgs(args, cancelDeploymentSchema);
     const apiClient = getApiClient();
     const response = await apiClient.cancelDeployment(project_id, reason);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to cancel deployment');
+        return { result: { error: response.error || 'Failed to cancel deployment' }, isError: true };
     }
     return { result: response.data };
 };
 export const addDeploymentRequirement = async (args, ctx) => {
-    const { project_id, type, title, description, file_path, stage = 'preparation', blocking = false, recurring = false } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(type, 'type');
-    validateRequired(title, 'title');
-    const validTypes = ['migration', 'env_var', 'config', 'manual', 'breaking_change', 'agent_task'];
-    if (!validTypes.includes(type)) {
-        throw new ValidationError(`type must be one of: ${validTypes.join(', ')}`);
-    }
-    const validStages = ['preparation', 'deployment', 'verification'];
-    if (!validStages.includes(stage)) {
-        throw new ValidationError(`stage must be one of: ${validStages.join(', ')}`);
-    }
+    const { project_id, type, title, description, file_path, stage, blocking, recurring } = parseArgs(args, addDeploymentRequirementSchema);
     const apiClient = getApiClient();
     const response = await apiClient.addDeploymentRequirement(project_id, {
         type: type,
@@ -154,32 +202,28 @@ export const addDeploymentRequirement = async (args, ctx) => {
         recurring
     });
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to add deployment requirement');
+        return { result: { error: response.error || 'Failed to add deployment requirement' }, isError: true };
     }
     return { result: response.data };
 };
 export const completeDeploymentRequirement = async (args, ctx) => {
-    const { requirement_id } = args;
-    validateRequired(requirement_id, 'requirement_id');
-    validateUUID(requirement_id, 'requirement_id');
+    const { requirement_id } = parseArgs(args, completeDeploymentRequirementSchema);
     const apiClient = getApiClient();
     const response = await apiClient.completeDeploymentRequirement(requirement_id);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to complete deployment requirement');
+        return { result: { error: response.error || 'Failed to complete deployment requirement' }, isError: true };
     }
     return { result: response.data };
 };
 export const getDeploymentRequirements = async (args, ctx) => {
-    const { project_id, status = 'pending', stage } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id, status, stage } = parseArgs(args, getDeploymentRequirementsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getDeploymentRequirements(project_id, {
         status: status,
         stage: stage
     });
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to get deployment requirements');
+        return { result: { error: response.error || 'Failed to get deployment requirements' }, isError: true };
     }
     return { result: response.data };
 };
@@ -187,23 +231,7 @@ export const getDeploymentRequirements = async (args, ctx) => {
 // Scheduled Deployments
 // ============================================================================
 export const scheduleDeployment = async (args, ctx) => {
-    const { project_id, environment = 'production', version_bump = 'patch', schedule_type = 'once', scheduled_at, auto_trigger = true, notes, git_ref, } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(scheduled_at, 'scheduled_at');
-    validateEnvironment(environment);
-    if (!['patch', 'minor', 'major'].includes(version_bump)) {
-        throw new ValidationError('Invalid version_bump value', {
-            field: 'version_bump',
-            validValues: ['patch', 'minor', 'major'],
-        });
-    }
-    if (!['once', 'daily', 'weekly', 'monthly'].includes(schedule_type)) {
-        throw new ValidationError('Invalid schedule_type value', {
-            field: 'schedule_type',
-            validValues: ['once', 'daily', 'weekly', 'monthly'],
-        });
-    }
+    const { project_id, environment, version_bump, schedule_type, scheduled_at, auto_trigger, hours_interval, notes, git_ref, } = parseArgs(args, scheduleDeploymentSchema);
     // Parse and validate scheduled_at
     const scheduledDate = new Date(scheduled_at);
     if (isNaN(scheduledDate.getTime())) {
@@ -217,6 +245,13 @@ export const scheduleDeployment = async (args, ctx) => {
             field: 'scheduled_at',
         });
     }
+    // Validate hours_interval for hourly schedule type (default is 1)
+    const hoursInterval = hours_interval ?? 1;
+    if (schedule_type === 'hourly' && (hoursInterval < 1 || hoursInterval > 24)) {
+        throw new ValidationError('hours_interval must be between 1 and 24', {
+            field: 'hours_interval',
+        });
+    }
     const apiClient = getApiClient();
     const response = await apiClient.scheduleDeployment(project_id, {
         environment: environment,
@@ -224,46 +259,33 @@ export const scheduleDeployment = async (args, ctx) => {
         schedule_type: schedule_type,
         scheduled_at: scheduledDate.toISOString(),
         auto_trigger,
+        hours_interval: hoursInterval,
         notes,
         git_ref
     });
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to schedule deployment');
+        return { result: { error: response.error || 'Failed to schedule deployment' }, isError: true };
     }
     return { result: response.data };
 };
 export const getScheduledDeployments = async (args, ctx) => {
-    const { project_id, include_disabled = false } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id, include_disabled } = parseArgs(args, getScheduledDeploymentsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getScheduledDeployments(project_id, include_disabled);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to get scheduled deployments');
+        return { result: { error: response.error || 'Failed to get scheduled deployments' }, isError: true };
     }
     return { result: response.data };
 };
 export const updateScheduledDeployment = async (args, ctx) => {
-    const { schedule_id, environment, version_bump, schedule_type, scheduled_at, auto_trigger, enabled, notes, git_ref, } = args;
-    validateRequired(schedule_id, 'schedule_id');
-    validateUUID(schedule_id, 'schedule_id');
+    const { schedule_id, environment, version_bump, schedule_type, scheduled_at, auto_trigger, hours_interval, enabled, notes, git_ref, } = parseArgs(args, updateScheduledDeploymentSchema);
     const updates = {};
-    if (environment !== undefined) {
-        validateEnvironment(environment);
+    if (environment !== undefined)
         updates.environment = environment;
-    }
-    if (version_bump !== undefined) {
-        if (!['patch', 'minor', 'major'].includes(version_bump)) {
-            throw new ValidationError('Invalid version_bump value');
-        }
+    if (version_bump !== undefined)
         updates.version_bump = version_bump;
-    }
-    if (schedule_type !== undefined) {
-        if (!['once', 'daily', 'weekly', 'monthly'].includes(schedule_type)) {
-            throw new ValidationError('Invalid schedule_type value');
-        }
+    if (schedule_type !== undefined)
         updates.schedule_type = schedule_type;
-    }
     if (scheduled_at !== undefined) {
         const scheduledDate = new Date(scheduled_at);
         if (isNaN(scheduledDate.getTime())) {
@@ -273,6 +295,12 @@ export const updateScheduledDeployment = async (args, ctx) => {
     }
     if (auto_trigger !== undefined)
         updates.auto_trigger = auto_trigger;
+    if (hours_interval !== undefined) {
+        if (hours_interval < 1 || hours_interval > 24) {
+            throw new ValidationError('hours_interval must be between 1 and 24');
+        }
+        updates.hours_interval = hours_interval;
+    }
     if (enabled !== undefined)
         updates.enabled = enabled;
     if (notes !== undefined)
@@ -285,41 +313,35 @@ export const updateScheduledDeployment = async (args, ctx) => {
     const apiClient = getApiClient();
     const response = await apiClient.updateScheduledDeployment(schedule_id, updates);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to update scheduled deployment');
+        return { result: { error: response.error || 'Failed to update scheduled deployment' }, isError: true };
     }
     return { result: response.data };
 };
 export const deleteScheduledDeployment = async (args, ctx) => {
-    const { schedule_id } = args;
-    validateRequired(schedule_id, 'schedule_id');
-    validateUUID(schedule_id, 'schedule_id');
+    const { schedule_id } = parseArgs(args, deleteScheduledDeploymentSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteScheduledDeployment(schedule_id);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to delete scheduled deployment');
+        return { result: { error: response.error || 'Failed to delete scheduled deployment' }, isError: true };
     }
     return { result: response.data };
 };
 export const triggerScheduledDeployment = async (args, ctx) => {
-    const { schedule_id } = args;
+    const { schedule_id } = parseArgs(args, triggerScheduledDeploymentSchema);
     const { session } = ctx;
-    validateRequired(schedule_id, 'schedule_id');
-    validateUUID(schedule_id, 'schedule_id');
     const apiClient = getApiClient();
     const response = await apiClient.triggerScheduledDeployment(schedule_id, session.currentSessionId || undefined);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to trigger scheduled deployment');
+        return { result: { error: response.error || 'Failed to trigger scheduled deployment' }, isError: true };
     }
     return { result: response.data };
 };
 export const checkDueDeployments = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id } = parseArgs(args, checkDueDeploymentsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.checkDueDeployments(project_id);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to check due deployments');
+        return { result: { error: response.error || 'Failed to check due deployments' }, isError: true };
     }
     return { result: response.data };
 };

package/dist/handlers/discovery.d.ts

@@ -9,6 +9,13 @@
  * This saves ~8,000 tokens per schema load.
  */
 import type { Handler, HandlerRegistry } from './types.js';
+export declare const TOOL_CATEGORIES: Record<string, {
+    description: string;
+    tools: Array<{
+        name: string;
+        brief: string;
+    }>;
+}>;
 export declare const discoverTools: Handler;
 export declare const getToolInfo: Handler;
 /**

package/dist/handlers/discovery.js

@@ -8,6 +8,14 @@
  * Note: Tool documentation is lazy-loaded from tool-docs.ts to save tokens.
  * This saves ~8,000 tokens per schema load.
  */
+import { parseArgs } from '../validators.js';
+// Argument schemas for type-safe parsing
+const discoverToolsSchema = {
+    category: { type: 'string' },
+};
+const getToolInfoSchema = {
+    tool_name: { type: 'string', required: true },
+};
 // Lazy-loaded tool documentation cache
 let toolInfoCache = null;
 /**
@@ -22,8 +30,8 @@ async function getToolDocs() {
     toolInfoCache = TOOL_INFO;
     return toolInfoCache;
 }
-// Tool categories with brief descriptions
-const TOOL_CATEGORIES = {
+// Tool categories with brief descriptions (exported for documentation generation)
+export const TOOL_CATEGORIES = {
     session: {
         description: 'Session lifecycle and monitoring',
         tools: [
@@ -108,6 +116,7 @@ const TOOL_CATEGORIES = {
         tools: [
             { name: 'add_finding', brief: 'Record audit finding' },
             { name: 'get_findings', brief: 'List findings' },
+            { name: 'get_findings_stats', brief: 'Get findings statistics' },
             { name: 'update_finding', brief: 'Update finding status' },
             { name: 'delete_finding', brief: 'Remove finding' },
         ],
@@ -161,6 +170,26 @@ const TOOL_CATEGORIES = {
             { name: 'add_task_to_body_of_work', brief: 'Add task to group' },
             { name: 'remove_task_from_body_of_work', brief: 'Remove from group' },
             { name: 'activate_body_of_work', brief: 'Activate for work' },
+            { name: 'add_task_dependency', brief: 'Add task dependency' },
+            { name: 'remove_task_dependency', brief: 'Remove task dependency' },
+            { name: 'get_task_dependencies', brief: 'List task dependencies' },
+            { name: 'get_next_body_of_work_task', brief: 'Get next available task' },
+        ],
+    },
+    sprints: {
+        description: 'Time-bounded sprints with velocity tracking',
+        tools: [
+            { name: 'create_sprint', brief: 'Create new sprint' },
+            { name: 'update_sprint', brief: 'Update sprint details' },
+            { name: 'get_sprint', brief: 'Get sprint with tasks' },
+            { name: 'get_sprints', brief: 'List project sprints' },
+            { name: 'delete_sprint', brief: 'Delete sprint' },
+            { name: 'start_sprint', brief: 'Start sprint' },
+            { name: 'complete_sprint', brief: 'Complete sprint' },
+            { name: 'add_task_to_sprint', brief: 'Add task to sprint' },
+            { name: 'remove_task_from_sprint', brief: 'Remove from sprint' },
+            { name: 'get_sprint_backlog', brief: 'Get available tasks' },
+            { name: 'get_sprint_velocity', brief: 'Velocity metrics' },
         ],
     },
     requests: {
@@ -198,6 +227,17 @@ const TOOL_CATEGORIES = {
             { name: 'update_cost_alert', brief: 'Update alert config' },
             { name: 'delete_cost_alert', brief: 'Remove alert' },
             { name: 'get_task_costs', brief: 'Cost per task' },
+            { name: 'get_body_of_work_costs', brief: 'Cost per body of work' },
+            { name: 'get_sprint_costs', brief: 'Cost per sprint' },
+        ],
+    },
+    git_issues: {
+        description: 'Git conflict and issue tracking',
+        tools: [
+            { name: 'add_git_issue', brief: 'Record git issue' },
+            { name: 'resolve_git_issue', brief: 'Mark resolved' },
+            { name: 'get_git_issues', brief: 'List git issues' },
+            { name: 'delete_git_issue', brief: 'Delete git issue' },
         ],
     },
     knowledge: {
@@ -206,9 +246,61 @@ const TOOL_CATEGORIES = {
             { name: 'query_knowledge_base', brief: 'Aggregated project knowledge in one call' },
         ],
     },
+    discovery: {
+        description: 'Tool discovery and documentation',
+        tools: [
+            { name: 'discover_tools', brief: 'List tools by category' },
+            { name: 'get_tool_info', brief: 'Get detailed tool docs' },
+        ],
+    },
+    subtasks: {
+        description: 'Break tasks into smaller pieces',
+        tools: [
+            { name: 'add_subtask', brief: 'Add subtask to task' },
+            { name: 'get_subtasks', brief: 'List task subtasks' },
+        ],
+    },
+    worktrees: {
+        description: 'Git worktree management',
+        tools: [
+            { name: 'get_stale_worktrees', brief: 'Find orphaned worktrees' },
+            { name: 'clear_worktree_path', brief: 'Clear worktree from task' },
+        ],
+    },
+    roles: {
+        description: 'Agent role management',
+        tools: [
+            { name: 'get_role_settings', brief: 'Get project role settings' },
+            { name: 'update_role_settings', brief: 'Configure role behavior' },
+            { name: 'set_session_role', brief: 'Set session role' },
+            { name: 'get_agents_by_role', brief: 'List agents by role' },
+        ],
+    },
+    file_locks: {
+        description: 'File checkout/locking for multi-agent',
+        tools: [
+            { name: 'checkout_file', brief: 'Lock file for editing' },
+            { name: 'checkin_file', brief: 'Release file lock' },
+            { name: 'get_file_checkouts', brief: 'List file locks' },
+            { name: 'abandon_checkout', brief: 'Force-release lock' },
+            { name: 'is_file_available', brief: 'Check if file is free' },
+        ],
+    },
+    connectors: {
+        description: 'External integration connectors',
+        tools: [
+            { name: 'get_connectors', brief: 'List project connectors' },
+            { name: 'get_connector', brief: 'Get connector details' },
+            { name: 'add_connector', brief: 'Create new connector' },
+            { name: 'update_connector', brief: 'Update connector config' },
+            { name: 'delete_connector', brief: 'Remove connector' },
+            { name: 'test_connector', brief: 'Send test event' },
+            { name: 'get_connector_events', brief: 'Event history' },
+        ],
+    },
 };
 export const discoverTools = async (args) => {
-    const { category } = args;
+    const { category } = parseArgs(args, discoverToolsSchema);
     if (category) {
         // Return tools in specific category
         const cat = TOOL_CATEGORIES[category];
@@ -243,10 +335,7 @@ export const discoverTools = async (args) => {
     };
 };
 export const getToolInfo = async (args) => {
-    const { tool_name } = args;
-    if (!tool_name) {
-        return { result: { error: 'tool_name is required' } };
-    }
+    const { tool_name } = parseArgs(args, getToolInfoSchema);
     // Lazy-load tool documentation
     const toolDocs = await getToolDocs();
     const info = toolDocs[tool_name];